From ee3f2ce36258bf8c32e304d3a676068c674872d8 Mon Sep 17 00:00:00 2001 From: Alexander T Date: Tue, 12 May 2020 12:30:46 +0300 Subject: [PATCH 01/15] regression(38485): allow using rawText property in processing a tagged template --- src/compiler/transformers/taggedTemplate.ts | 19 ++++++++++-------- src/testRunner/unittests/transform.ts | 20 +++++++++++++++++++ ...orrectly.transformTaggedTemplateLiteral.js | 5 +++++ 3 files changed, 36 insertions(+), 8 deletions(-) create mode 100644 tests/baselines/reference/transformApi/transformsCorrectly.transformTaggedTemplateLiteral.js diff --git a/src/compiler/transformers/taggedTemplate.ts b/src/compiler/transformers/taggedTemplate.ts index 8dc0fe1a964..33710eff54f 100644 --- a/src/compiler/transformers/taggedTemplate.ts +++ b/src/compiler/transformers/taggedTemplate.ts @@ -71,18 +71,21 @@ namespace ts { * * @param node The ES6 template literal. */ - function getRawLiteral(node: LiteralLikeNode, currentSourceFile: SourceFile) { + function getRawLiteral(node: TemplateLiteralLikeNode, currentSourceFile: SourceFile) { // Find original source text, since we need to emit the raw strings of the tagged template. // The raw strings contain the (escaped) strings of what the user wrote. // Examples: `\n` is converted to "\\n", a template string with a newline to "\n". - let text = getSourceTextOfNodeFromSourceFile(currentSourceFile, node); + let text = node.rawText; + if (text === undefined) { + text = getSourceTextOfNodeFromSourceFile(currentSourceFile, node); - // text contains the original source, it will also contain quotes ("`"), dolar signs and braces ("${" and "}"), - // thus we need to remove those characters. - // First template piece starts with "`", others with "}" - // Last template piece ends with "`", others with "${" - const isLast = node.kind === SyntaxKind.NoSubstitutionTemplateLiteral || node.kind === SyntaxKind.TemplateTail; - text = text.substring(1, text.length - (isLast ? 1 : 2)); + // text contains the original source, it will also contain quotes ("`"), dolar signs and braces ("${" and "}"), + // thus we need to remove those characters. + // First template piece starts with "`", others with "}" + // Last template piece ends with "`", others with "${" + const isLast = node.kind === SyntaxKind.NoSubstitutionTemplateLiteral || node.kind === SyntaxKind.TemplateTail; + text = text.substring(1, text.length - (isLast ? 1 : 2)); + } // Newline normalization: // ES6 Spec 11.8.6.1 - Static Semantics of TV's and TRV's diff --git a/src/testRunner/unittests/transform.ts b/src/testRunner/unittests/transform.ts index cce8c92ad41..54d511233fa 100644 --- a/src/testRunner/unittests/transform.ts +++ b/src/testRunner/unittests/transform.ts @@ -50,6 +50,15 @@ namespace ts { return (node: SourceFile) => visitNode(node, visitor); } + function createTaggedTemplateLiteral(): Transformer { + return sourceFile => updateSourceFileNode(sourceFile, [ + createStatement( + createTaggedTemplate( + createIdentifier("$tpl"), + createNoSubstitutionTemplateLiteral("foo", "foo"))) + ]); + } + function transformSourceFile(sourceText: string, transformers: TransformerFactory[]) { const transformed = transform(createSourceFile("source.ts", sourceText, ScriptTarget.ES2015), transformers); const printer = createPrinter({ newLine: NewLineKind.CarriageReturnLineFeed }, { @@ -120,6 +129,17 @@ namespace ts { }).outputText; }); + testBaseline("transformTaggedTemplateLiteral", () => { + return transpileModule("", { + transformers: { + before: [createTaggedTemplateLiteral], + }, + compilerOptions: { + target: ScriptTarget.ES5 + } + }).outputText; + }); + testBaseline("issue27854", () => { return transpileModule(`oldName<{ a: string; }>\` ... \`;`, { transformers: { diff --git a/tests/baselines/reference/transformApi/transformsCorrectly.transformTaggedTemplateLiteral.js b/tests/baselines/reference/transformApi/transformsCorrectly.transformTaggedTemplateLiteral.js new file mode 100644 index 00000000000..e693443d134 --- /dev/null +++ b/tests/baselines/reference/transformApi/transformsCorrectly.transformTaggedTemplateLiteral.js @@ -0,0 +1,5 @@ +var __makeTemplateObject = (this && this.__makeTemplateObject) || function (cooked, raw) { + if (Object.defineProperty) { Object.defineProperty(cooked, "raw", { value: raw }); } else { cooked.raw = raw; } + return cooked; +}; +$tpl(__makeTemplateObject(["foo"], ["foo"])); From d154b58406cfaf5a499b0ed8cdb697fb5390c74c Mon Sep 17 00:00:00 2001 From: csigs Date: Sat, 16 May 2020 22:10:40 +0000 Subject: [PATCH 02/15] LEGO: check in for master to temporary branch. --- .../diagnosticMessages.generated.json.lcl | 37 +++++++++------ .../diagnosticMessages.generated.json.lcl | 37 +++++++++------ .../diagnosticMessages.generated.json.lcl | 43 ++++++++++++------ .../diagnosticMessages.generated.json.lcl | 37 +++++++++------ .../diagnosticMessages.generated.json.lcl | 39 +++++++++------- .../diagnosticMessages.generated.json.lcl | 37 +++++++++------ .../diagnosticMessages.generated.json.lcl | 45 ++++++++++++++----- .../diagnosticMessages.generated.json.lcl | 39 +++++++++------- .../diagnosticMessages.generated.json.lcl | 39 +++++++++------- .../diagnosticMessages.generated.json.lcl | 44 ++++++++++++------ .../diagnosticMessages.generated.json.lcl | 39 +++++++++------- .../diagnosticMessages.generated.json.lcl | 37 +++++++++------ 12 files changed, 304 insertions(+), 169 deletions(-) diff --git a/src/loc/lcl/chs/diagnosticMessages/diagnosticMessages.generated.json.lcl b/src/loc/lcl/chs/diagnosticMessages/diagnosticMessages.generated.json.lcl index 94715ed4a6c..bf58e6d2b24 100644 --- a/src/loc/lcl/chs/diagnosticMessages/diagnosticMessages.generated.json.lcl +++ b/src/loc/lcl/chs/diagnosticMessages/diagnosticMessages.generated.json.lcl @@ -48,6 +48,12 @@ + + + + + + @@ -3720,6 +3726,9 @@ + + + @@ -8610,15 +8619,6 @@ - - - - - - - - - @@ -8646,12 +8646,9 @@ - + - - - - + @@ -8664,6 +8661,12 @@ + + + + + + @@ -10389,6 +10392,12 @@ + + + + + + diff --git a/src/loc/lcl/cht/diagnosticMessages/diagnosticMessages.generated.json.lcl b/src/loc/lcl/cht/diagnosticMessages/diagnosticMessages.generated.json.lcl index cce62df571c..e1f2c14f0df 100644 --- a/src/loc/lcl/cht/diagnosticMessages/diagnosticMessages.generated.json.lcl +++ b/src/loc/lcl/cht/diagnosticMessages/diagnosticMessages.generated.json.lcl @@ -48,6 +48,12 @@ + + + + + + @@ -3720,6 +3726,9 @@ + + + @@ -8610,15 +8619,6 @@ - - - - - - - - - @@ -8646,12 +8646,9 @@ - + - - - - + @@ -8664,6 +8661,12 @@ + + + + + + @@ -10389,6 +10392,12 @@ + + + + + + diff --git a/src/loc/lcl/csy/diagnosticMessages/diagnosticMessages.generated.json.lcl b/src/loc/lcl/csy/diagnosticMessages/diagnosticMessages.generated.json.lcl index d7ca345d0e2..f9b0e8b0b6f 100644 --- a/src/loc/lcl/csy/diagnosticMessages/diagnosticMessages.generated.json.lcl +++ b/src/loc/lcl/csy/diagnosticMessages/diagnosticMessages.generated.json.lcl @@ -57,6 +57,12 @@ + + + + + + @@ -3726,6 +3732,15 @@ + + + + + + + + + @@ -8613,15 +8628,6 @@ - - - - - - - - - @@ -8649,12 +8655,9 @@ - + - - - - + @@ -8667,6 +8670,12 @@ + + + + + + @@ -10392,6 +10401,12 @@ + + + + + + diff --git a/src/loc/lcl/deu/diagnosticMessages/diagnosticMessages.generated.json.lcl b/src/loc/lcl/deu/diagnosticMessages/diagnosticMessages.generated.json.lcl index cefbc586cfe..9648a4f69c8 100644 --- a/src/loc/lcl/deu/diagnosticMessages/diagnosticMessages.generated.json.lcl +++ b/src/loc/lcl/deu/diagnosticMessages/diagnosticMessages.generated.json.lcl @@ -48,6 +48,12 @@ + + + + + + @@ -3717,6 +3723,9 @@ + + + @@ -8604,15 +8613,6 @@ - - - - - - - - - @@ -8640,12 +8640,9 @@ - + - - - - + @@ -8658,6 +8655,12 @@ + + + + + + @@ -10383,6 +10386,12 @@ + + + + + + diff --git a/src/loc/lcl/esn/diagnosticMessages/diagnosticMessages.generated.json.lcl b/src/loc/lcl/esn/diagnosticMessages/diagnosticMessages.generated.json.lcl index c8e1b56f036..9fcdd9893dc 100644 --- a/src/loc/lcl/esn/diagnosticMessages/diagnosticMessages.generated.json.lcl +++ b/src/loc/lcl/esn/diagnosticMessages/diagnosticMessages.generated.json.lcl @@ -57,6 +57,12 @@ + + + + + + @@ -3732,6 +3738,9 @@ + + + @@ -7219,7 +7228,7 @@ - + @@ -8622,15 +8631,6 @@ - - - - - - - - - @@ -8658,12 +8658,9 @@ - + - - - - + @@ -8676,6 +8673,12 @@ + + + + + + @@ -10401,6 +10404,12 @@ + + + + + + diff --git a/src/loc/lcl/fra/diagnosticMessages/diagnosticMessages.generated.json.lcl b/src/loc/lcl/fra/diagnosticMessages/diagnosticMessages.generated.json.lcl index 92422802668..4ffc04e4314 100644 --- a/src/loc/lcl/fra/diagnosticMessages/diagnosticMessages.generated.json.lcl +++ b/src/loc/lcl/fra/diagnosticMessages/diagnosticMessages.generated.json.lcl @@ -57,6 +57,12 @@ + + + + + + @@ -3732,6 +3738,9 @@ + + + @@ -8622,15 +8631,6 @@ - - - - - - - - - @@ -8658,12 +8658,9 @@ - + - - - - + @@ -8676,6 +8673,12 @@ + + + + + + @@ -10401,6 +10404,12 @@ + + + + + + diff --git a/src/loc/lcl/ita/diagnosticMessages/diagnosticMessages.generated.json.lcl b/src/loc/lcl/ita/diagnosticMessages/diagnosticMessages.generated.json.lcl index d78cb7db9af..371f9209094 100644 --- a/src/loc/lcl/ita/diagnosticMessages/diagnosticMessages.generated.json.lcl +++ b/src/loc/lcl/ita/diagnosticMessages/diagnosticMessages.generated.json.lcl @@ -48,6 +48,15 @@ + + + + + + + + + @@ -3720,6 +3729,9 @@ + + + @@ -8610,15 +8622,6 @@ - - - - - - - - - @@ -8646,11 +8649,11 @@ - + - + - + @@ -8664,6 +8667,15 @@ + + + + + + + + + @@ -10389,6 +10401,15 @@ + + + + + + + + + diff --git a/src/loc/lcl/jpn/diagnosticMessages/diagnosticMessages.generated.json.lcl b/src/loc/lcl/jpn/diagnosticMessages/diagnosticMessages.generated.json.lcl index 12e2189024d..08ef0b07536 100644 --- a/src/loc/lcl/jpn/diagnosticMessages/diagnosticMessages.generated.json.lcl +++ b/src/loc/lcl/jpn/diagnosticMessages/diagnosticMessages.generated.json.lcl @@ -48,6 +48,12 @@ + + + + + + @@ -3720,6 +3726,9 @@ + + + @@ -7207,7 +7216,7 @@ - + @@ -8610,15 +8619,6 @@ - - - - - - - - - @@ -8646,12 +8646,9 @@ - + - - - - + @@ -8664,6 +8661,12 @@ + + + + + + @@ -10389,6 +10392,12 @@ + + + + + + diff --git a/src/loc/lcl/kor/diagnosticMessages/diagnosticMessages.generated.json.lcl b/src/loc/lcl/kor/diagnosticMessages/diagnosticMessages.generated.json.lcl index 21232d20adc..1317b20beac 100644 --- a/src/loc/lcl/kor/diagnosticMessages/diagnosticMessages.generated.json.lcl +++ b/src/loc/lcl/kor/diagnosticMessages/diagnosticMessages.generated.json.lcl @@ -48,6 +48,12 @@ + + + + + + @@ -3720,6 +3726,9 @@ + + + @@ -7207,7 +7216,7 @@ - + @@ -8610,15 +8619,6 @@ - - - - - - - - - @@ -8646,12 +8646,9 @@ - + - - - - + @@ -8664,6 +8661,12 @@ + + + + + + @@ -10389,6 +10392,12 @@ + + + + + + diff --git a/src/loc/lcl/ptb/diagnosticMessages/diagnosticMessages.generated.json.lcl b/src/loc/lcl/ptb/diagnosticMessages/diagnosticMessages.generated.json.lcl index 14887d133d9..b4be36fdba9 100644 --- a/src/loc/lcl/ptb/diagnosticMessages/diagnosticMessages.generated.json.lcl +++ b/src/loc/lcl/ptb/diagnosticMessages/diagnosticMessages.generated.json.lcl @@ -41,6 +41,15 @@ + + + + + + + + + @@ -7203,7 +7212,7 @@ - + @@ -8603,15 +8612,6 @@ - - - - - - - - - @@ -8639,11 +8639,11 @@ - + - + - + @@ -8657,6 +8657,15 @@ + + + + + + + + + @@ -10382,6 +10391,15 @@ + + + + + + + + + diff --git a/src/loc/lcl/rus/diagnosticMessages/diagnosticMessages.generated.json.lcl b/src/loc/lcl/rus/diagnosticMessages/diagnosticMessages.generated.json.lcl index e62a54ac190..c699b21b978 100644 --- a/src/loc/lcl/rus/diagnosticMessages/diagnosticMessages.generated.json.lcl +++ b/src/loc/lcl/rus/diagnosticMessages/diagnosticMessages.generated.json.lcl @@ -47,6 +47,12 @@ + + + + + + @@ -3719,6 +3725,9 @@ + + + @@ -7206,7 +7215,7 @@ - + @@ -8609,15 +8618,6 @@ - - - - - - - - - @@ -8645,12 +8645,9 @@ - + - - - - + @@ -8663,6 +8660,12 @@ + + + + + + @@ -10388,6 +10391,12 @@ + + + + + + diff --git a/src/loc/lcl/trk/diagnosticMessages/diagnosticMessages.generated.json.lcl b/src/loc/lcl/trk/diagnosticMessages/diagnosticMessages.generated.json.lcl index 3a93930be96..71447b892b1 100644 --- a/src/loc/lcl/trk/diagnosticMessages/diagnosticMessages.generated.json.lcl +++ b/src/loc/lcl/trk/diagnosticMessages/diagnosticMessages.generated.json.lcl @@ -41,6 +41,12 @@ + + + + + + @@ -3713,6 +3719,9 @@ + + + @@ -8603,15 +8612,6 @@ - - - - - - - - - @@ -8639,12 +8639,9 @@ - + - - - - + @@ -8657,6 +8654,12 @@ + + + + + + @@ -10382,6 +10385,12 @@ + + + + + + From 3c1f37e913d2ef3c359a4b04d414d3aba5f3f85c Mon Sep 17 00:00:00 2001 From: Anders Hejlsberg Date: Sat, 16 May 2020 19:58:17 -0700 Subject: [PATCH 03/15] Use control flow analysis to check 'super(...)' call before 'this' access (#38612) * Use CFA graph to check this/super accesses are preceded by super() call * Accept cleaned-up API baselines * Accept new baselines * Add tests --- src/compiler/binder.ts | 10 +- src/compiler/checker.ts | 96 +++--- src/compiler/core.ts | 2 +- src/compiler/types.ts | 21 +- .../reference/api/tsserverlibrary.d.ts | 12 +- tests/baselines/reference/api/typescript.d.ts | 12 +- ...uperPropertyAccessInSuperCall01.errors.txt | 17 -- .../checkSuperCallBeforeThisAccess.errors.txt | 123 ++++++++ .../checkSuperCallBeforeThisAccess.js | 161 ++++++++++ .../checkSuperCallBeforeThisAccess.symbols | 231 +++++++++++++++ .../checkSuperCallBeforeThisAccess.types | 279 ++++++++++++++++++ .../reference/superAccess2.errors.txt | 5 +- .../checkSuperCallBeforeThisAccess.ts | 83 ++++++ 13 files changed, 948 insertions(+), 104 deletions(-) delete mode 100644 tests/baselines/reference/captureSuperPropertyAccessInSuperCall01.errors.txt create mode 100644 tests/baselines/reference/checkSuperCallBeforeThisAccess.errors.txt create mode 100644 tests/baselines/reference/checkSuperCallBeforeThisAccess.js create mode 100644 tests/baselines/reference/checkSuperCallBeforeThisAccess.symbols create mode 100644 tests/baselines/reference/checkSuperCallBeforeThisAccess.types create mode 100644 tests/cases/compiler/checkSuperCallBeforeThisAccess.ts diff --git a/src/compiler/binder.ts b/src/compiler/binder.ts index 8a47755498b..8809c34d060 100644 --- a/src/compiler/binder.ts +++ b/src/compiler/binder.ts @@ -985,7 +985,7 @@ namespace ts { return initFlowNode({ flags: FlowFlags.SwitchClause, antecedent, switchStatement, clauseStart, clauseEnd }); } - function createFlowMutation(flags: FlowFlags, antecedent: FlowNode, node: Node): FlowNode { + function createFlowMutation(flags: FlowFlags, antecedent: FlowNode, node: Expression | VariableDeclaration | ArrayBindingElement): FlowNode { setFlowNodeReferenced(antecedent); const result = initFlowNode({ flags, antecedent, node }); if (currentExceptionTarget) { @@ -1341,7 +1341,7 @@ namespace ts { // is potentially an assertion and is therefore included in the control flow. if (node.expression.kind === SyntaxKind.CallExpression) { const call = node.expression; - if (isDottedName(call.expression)) { + if (isDottedName(call.expression) && call.expression.kind !== SyntaxKind.SuperKeyword) { currentFlow = createFlowCall(currentFlow, call); } } @@ -1747,6 +1747,9 @@ namespace ts { } else { bindEachChild(node); + if (node.expression.kind === SyntaxKind.SuperKeyword) { + currentFlow = createFlowCall(currentFlow, node); + } } } if (node.expression.kind === SyntaxKind.PropertyAccessExpression) { @@ -2464,6 +2467,9 @@ namespace ts { node.flowNode = currentFlow; } return checkStrictModeIdentifier(node); + case SyntaxKind.SuperKeyword: + node.flowNode = currentFlow; + break; case SyntaxKind.PrivateIdentifier: return checkPrivateIdentifier(node as PrivateIdentifier); case SyntaxKind.PropertyAccessExpression: diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index ee6a3a81c90..fcd96daac8f 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -911,6 +911,7 @@ namespace ts { const sharedFlowNodes: FlowNode[] = []; const sharedFlowTypes: FlowType[] = []; const flowNodeReachable: (boolean | undefined)[] = []; + const flowNodePostSuper: (boolean | undefined)[] = []; const potentialThisCollisions: Node[] = []; const potentialNewTargetCollisions: Node[] = []; const potentialWeakMapCollisions: Node[] = []; @@ -20148,7 +20149,7 @@ namespace ts { noCacheCheck = false; } if (flags & (FlowFlags.Assignment | FlowFlags.Condition | FlowFlags.ArrayMutation)) { - flow = (flow).antecedent; + flow = (flow).antecedent; } else if (flags & FlowFlags.Call) { const signature = getEffectsSignature((flow).node); @@ -20198,6 +20199,51 @@ namespace ts { } } + // Return true if the given flow node is preceded by a 'super(...)' call in every possible code path + // leading to the node. + function isPostSuperFlowNode(flow: FlowNode, noCacheCheck: boolean): boolean { + while (true) { + const flags = flow.flags; + if (flags & FlowFlags.Shared) { + if (!noCacheCheck) { + const id = getFlowNodeId(flow); + const postSuper = flowNodePostSuper[id]; + return postSuper !== undefined ? postSuper : (flowNodePostSuper[id] = isPostSuperFlowNode(flow, /*noCacheCheck*/ true)); + } + noCacheCheck = false; + } + if (flags & (FlowFlags.Assignment | FlowFlags.Condition | FlowFlags.ArrayMutation | FlowFlags.SwitchClause)) { + flow = (flow).antecedent; + } + else if (flags & FlowFlags.Call) { + if ((flow).node.expression.kind === SyntaxKind.SuperKeyword) { + return true; + } + flow = (flow).antecedent; + } + else if (flags & FlowFlags.BranchLabel) { + // A branching point is post-super if every branch is post-super. + return every((flow).antecedents, f => isPostSuperFlowNode(f, /*noCacheCheck*/ false)); + } + else if (flags & FlowFlags.LoopLabel) { + // A loop is post-super if the control flow path that leads to the top is post-super. + flow = (flow).antecedents![0]; + } + else if (flags & FlowFlags.ReduceLabel) { + const target = (flow).target; + const saveAntecedents = target.antecedents; + target.antecedents = (flow).antecedents; + const result = isPostSuperFlowNode((flow).antecedent, /*noCacheCheck*/ false); + target.antecedents = saveAntecedents; + return result; + } + else { + // Unreachable nodes are considered post-super to silence errors + return !!(flags & FlowFlags.Unreachable); + } + } + } + function getFlowTypeOfReference(reference: Node, declaredType: Type, initialType = declaredType, flowContainer?: Node, couldBeUninitialized?: boolean) { let key: string | undefined; let keySet = false; @@ -21597,31 +21643,10 @@ namespace ts { } } - function findFirstSuperCall(n: Node): SuperCall | undefined { - if (isSuperCall(n)) { - return n; - } - else if (isFunctionLike(n)) { - return undefined; - } - return forEachChild(n, findFirstSuperCall); - } - - /** - * Return a cached result if super-statement is already found. - * Otherwise, find a super statement in a given constructor function and cache the result in the node-links of the constructor - * - * @param constructor constructor-function to look for super statement - */ - function getSuperCallInConstructor(constructor: ConstructorDeclaration): SuperCall | undefined { - const links = getNodeLinks(constructor); - - // Only trying to find super-call if we haven't yet tried to find one. Once we try, we will record the result - if (links.hasSuperCall === undefined) { - links.superCall = findFirstSuperCall(constructor.body!); - links.hasSuperCall = links.superCall ? true : false; - } - return links.superCall!; + function findFirstSuperCall(node: Node): SuperCall | undefined { + return isSuperCall(node) ? node : + isFunctionLike(node) ? undefined : + forEachChild(node, findFirstSuperCall); } /** @@ -21644,17 +21669,7 @@ namespace ts { // If a containing class does not have extends clause or the class extends null // skip checking whether super statement is called before "this" accessing. if (baseTypeNode && !classDeclarationExtendsNull(containingClassDecl)) { - const superCall = getSuperCallInConstructor(container); - - // We should give an error in the following cases: - // - No super-call - // - "this" is accessing before super-call. - // i.e super(this) - // this.x; super(); - // We want to make sure that super-call is done before accessing "this" so that - // "this" is not accessed as a parameter of the super-call. - if (!superCall || superCall.end > node.pos) { - // In ES6, super inside constructor of class-declaration has to precede "this" accessing + if (node.flowNode && !isPostSuperFlowNode(node.flowNode, /*noCacheCheck*/ false)) { error(node, diagnosticMessage); } } @@ -21879,7 +21894,8 @@ namespace ts { function checkSuperExpression(node: Node): Type { const isCallExpression = node.parent.kind === SyntaxKind.CallExpression && (node.parent).expression === node; - let container = getSuperContainer(node, /*stopOnFunctions*/ true); + const immediateContainer = getSuperContainer(node, /*stopOnFunctions*/ true); + let container = immediateContainer; let needToCaptureLexicalThis = false; // adjust the container reference in case if super is used inside arrow functions with arbitrarily deep nesting @@ -21915,7 +21931,7 @@ namespace ts { return errorType; } - if (!isCallExpression && container.kind === SyntaxKind.Constructor) { + if (!isCallExpression && immediateContainer.kind === SyntaxKind.Constructor) { checkThisBeforeSuper(node, container, Diagnostics.super_must_be_called_before_accessing_a_property_of_super_in_the_constructor_of_a_derived_class); } @@ -29912,7 +29928,7 @@ namespace ts { if (getClassExtendsHeritageElement(containingClassDecl)) { captureLexicalThis(node.parent, containingClassDecl); const classExtendsNull = classDeclarationExtendsNull(containingClassDecl); - const superCall = getSuperCallInConstructor(node); + const superCall = findFirstSuperCall(node.body!); if (superCall) { if (classExtendsNull) { error(superCall, Diagnostics.A_constructor_cannot_contain_a_super_call_when_its_class_extends_null); diff --git a/src/compiler/core.ts b/src/compiler/core.ts index 63e293f2e8f..651f5fe82de 100644 --- a/src/compiler/core.ts +++ b/src/compiler/core.ts @@ -150,7 +150,7 @@ namespace ts { * returns a falsey value, then returns false. * If no such value is found, the callback is applied to each element of array and `true` is returned. */ - export function every(array: readonly T[], callback: (element: T, index: number) => boolean): boolean { + export function every(array: readonly T[] | undefined, callback: (element: T, index: number) => boolean): boolean { if (array) { for (let i = 0; i < array.length; i++) { if (!callback(array[i], i)) { diff --git a/src/compiler/types.ts b/src/compiler/types.ts index 54d889b2ff4..aef4364a6b5 100644 --- a/src/compiler/types.ts +++ b/src/compiler/types.ts @@ -2791,34 +2791,21 @@ namespace ts { } export type FlowNode = - | AfterFinallyFlow - | PreFinallyFlow | FlowStart | FlowLabel | FlowAssignment | FlowCall | FlowCondition | FlowSwitchClause - | FlowArrayMutation; + | FlowArrayMutation + | FlowCall + | FlowReduceLabel; export interface FlowNodeBase { flags: FlowFlags; id?: number; // Node id used by flow type cache in checker } - export interface FlowLock { - locked?: boolean; - } - - export interface AfterFinallyFlow extends FlowNodeBase, FlowLock { - antecedent: FlowNode; - } - - export interface PreFinallyFlow extends FlowNodeBase { - antecedent: FlowNode; - lock: FlowLock; - } - // FlowStart represents the start of a control flow. For a function expression or arrow // function, the node property references the function (which in turn has a flowNode // property for the containing control flow). @@ -4316,8 +4303,6 @@ namespace ts { resolvedJsxElementAttributesType?: Type; // resolved element attributes type of a JSX openinglike element resolvedJsxElementAllAttributesType?: Type; // resolved all element attributes type of a JSX openinglike element resolvedJSDocType?: Type; // Resolved type of a JSDoc type reference - hasSuperCall?: boolean; // recorded result when we try to find super-call. We only try to find one if this flag is undefined, indicating that we haven't made an attempt. - superCall?: SuperCall; // Cached first super-call found in the constructor. Used in checking whether super is called before this-accessing switchTypes?: Type[]; // Cached array of switch case expression types jsxNamespace?: Symbol | false; // Resolved jsx namespace symbol for this node contextFreeType?: Type; // Cached context-free type used by the first pass of inference; used when a function's return is partially contextually sensitive diff --git a/tests/baselines/reference/api/tsserverlibrary.d.ts b/tests/baselines/reference/api/tsserverlibrary.d.ts index 2c7742fb88b..6ea68e933ab 100644 --- a/tests/baselines/reference/api/tsserverlibrary.d.ts +++ b/tests/baselines/reference/api/tsserverlibrary.d.ts @@ -1743,21 +1743,11 @@ declare namespace ts { Label = 12, Condition = 96 } - export type FlowNode = AfterFinallyFlow | PreFinallyFlow | FlowStart | FlowLabel | FlowAssignment | FlowCall | FlowCondition | FlowSwitchClause | FlowArrayMutation; + export type FlowNode = FlowStart | FlowLabel | FlowAssignment | FlowCall | FlowCondition | FlowSwitchClause | FlowArrayMutation | FlowCall | FlowReduceLabel; export interface FlowNodeBase { flags: FlowFlags; id?: number; } - export interface FlowLock { - locked?: boolean; - } - export interface AfterFinallyFlow extends FlowNodeBase, FlowLock { - antecedent: FlowNode; - } - export interface PreFinallyFlow extends FlowNodeBase { - antecedent: FlowNode; - lock: FlowLock; - } export interface FlowStart extends FlowNodeBase { node?: FunctionExpression | ArrowFunction | MethodDeclaration; } diff --git a/tests/baselines/reference/api/typescript.d.ts b/tests/baselines/reference/api/typescript.d.ts index c901f86e384..d2c5d5ce805 100644 --- a/tests/baselines/reference/api/typescript.d.ts +++ b/tests/baselines/reference/api/typescript.d.ts @@ -1743,21 +1743,11 @@ declare namespace ts { Label = 12, Condition = 96 } - export type FlowNode = AfterFinallyFlow | PreFinallyFlow | FlowStart | FlowLabel | FlowAssignment | FlowCall | FlowCondition | FlowSwitchClause | FlowArrayMutation; + export type FlowNode = FlowStart | FlowLabel | FlowAssignment | FlowCall | FlowCondition | FlowSwitchClause | FlowArrayMutation | FlowCall | FlowReduceLabel; export interface FlowNodeBase { flags: FlowFlags; id?: number; } - export interface FlowLock { - locked?: boolean; - } - export interface AfterFinallyFlow extends FlowNodeBase, FlowLock { - antecedent: FlowNode; - } - export interface PreFinallyFlow extends FlowNodeBase { - antecedent: FlowNode; - lock: FlowLock; - } export interface FlowStart extends FlowNodeBase { node?: FunctionExpression | ArrowFunction | MethodDeclaration; } diff --git a/tests/baselines/reference/captureSuperPropertyAccessInSuperCall01.errors.txt b/tests/baselines/reference/captureSuperPropertyAccessInSuperCall01.errors.txt deleted file mode 100644 index 6e2b7ef5787..00000000000 --- a/tests/baselines/reference/captureSuperPropertyAccessInSuperCall01.errors.txt +++ /dev/null @@ -1,17 +0,0 @@ -tests/cases/compiler/captureSuperPropertyAccessInSuperCall01.ts(9,24): error TS17011: 'super' must be called before accessing a property of 'super' in the constructor of a derived class. - - -==== tests/cases/compiler/captureSuperPropertyAccessInSuperCall01.ts (1 errors) ==== - class A { - constructor(f: () => string) { - } - public blah(): string { return ""; } - } - - class B extends A { - constructor() { - super(() => { return super.blah(); }) - ~~~~~ -!!! error TS17011: 'super' must be called before accessing a property of 'super' in the constructor of a derived class. - } - } \ No newline at end of file diff --git a/tests/baselines/reference/checkSuperCallBeforeThisAccess.errors.txt b/tests/baselines/reference/checkSuperCallBeforeThisAccess.errors.txt new file mode 100644 index 00000000000..4b38d7146f4 --- /dev/null +++ b/tests/baselines/reference/checkSuperCallBeforeThisAccess.errors.txt @@ -0,0 +1,123 @@ +tests/cases/compiler/checkSuperCallBeforeThisAccess.ts(7,18): error TS17009: 'super' must be called before accessing 'this' in the constructor of a derived class. +tests/cases/compiler/checkSuperCallBeforeThisAccess.ts(8,18): error TS17009: 'super' must be called before accessing 'this' in the constructor of a derived class. +tests/cases/compiler/checkSuperCallBeforeThisAccess.ts(9,18): error TS17011: 'super' must be called before accessing a property of 'super' in the constructor of a derived class. +tests/cases/compiler/checkSuperCallBeforeThisAccess.ts(20,22): error TS17009: 'super' must be called before accessing 'this' in the constructor of a derived class. +tests/cases/compiler/checkSuperCallBeforeThisAccess.ts(21,22): error TS17009: 'super' must be called before accessing 'this' in the constructor of a derived class. +tests/cases/compiler/checkSuperCallBeforeThisAccess.ts(22,22): error TS17011: 'super' must be called before accessing a property of 'super' in the constructor of a derived class. +tests/cases/compiler/checkSuperCallBeforeThisAccess.ts(30,30): error TS17009: 'super' must be called before accessing 'this' in the constructor of a derived class. +tests/cases/compiler/checkSuperCallBeforeThisAccess.ts(39,22): error TS17009: 'super' must be called before accessing 'this' in the constructor of a derived class. +tests/cases/compiler/checkSuperCallBeforeThisAccess.ts(43,18): error TS17009: 'super' must be called before accessing 'this' in the constructor of a derived class. +tests/cases/compiler/checkSuperCallBeforeThisAccess.ts(44,18): error TS17009: 'super' must be called before accessing 'this' in the constructor of a derived class. +tests/cases/compiler/checkSuperCallBeforeThisAccess.ts(45,18): error TS17011: 'super' must be called before accessing a property of 'super' in the constructor of a derived class. +tests/cases/compiler/checkSuperCallBeforeThisAccess.ts(59,27): error TS17009: 'super' must be called before accessing 'this' in the constructor of a derived class. +tests/cases/compiler/checkSuperCallBeforeThisAccess.ts(75,27): error TS17009: 'super' must be called before accessing 'this' in the constructor of a derived class. + + +==== tests/cases/compiler/checkSuperCallBeforeThisAccess.ts (13 errors) ==== + class A { + x = 1; + } + + class C1 extends A { + constructor(n: number) { + let a1 = this; // Error + ~~~~ +!!! error TS17009: 'super' must be called before accessing 'this' in the constructor of a derived class. + let a2 = this.x; // Error + ~~~~ +!!! error TS17009: 'super' must be called before accessing 'this' in the constructor of a derived class. + let a3 = super.x; // Error + ~~~~~ +!!! error TS17011: 'super' must be called before accessing a property of 'super' in the constructor of a derived class. + let a4 = () => this; + let a5 = () => this.x; + let a6 = () => super.x; + if (!!true) { + super(); + let b1 = this; + let b2 = this.x; + let b3 = super.x; + } + else { + let c1 = this; // Error + ~~~~ +!!! error TS17009: 'super' must be called before accessing 'this' in the constructor of a derived class. + let c2 = this.x; // Error + ~~~~ +!!! error TS17009: 'super' must be called before accessing 'this' in the constructor of a derived class. + let c3 = super.x; // Error + ~~~~~ +!!! error TS17011: 'super' must be called before accessing a property of 'super' in the constructor of a derived class. + } + if (!!true) { + switch (n) { + case 1: + super(); + let d1 = this.x; + case 2: + let d2 = this.x; // Error + ~~~~ +!!! error TS17009: 'super' must be called before accessing 'this' in the constructor of a derived class. + default: + super(); + let d3 = this.x; + } + let d4 = this.x; + } + if (!!true) { + let e1 = { w: !!true ? super() : 0 }; + let e2 = this.x; // Error + ~~~~ +!!! error TS17009: 'super' must be called before accessing 'this' in the constructor of a derived class. + let e3 = { w: !!true ? super() : super() }; + let e4 = this.x; + } + let f1 = this; // Error + ~~~~ +!!! error TS17009: 'super' must be called before accessing 'this' in the constructor of a derived class. + let f2 = this.x; // Error + ~~~~ +!!! error TS17009: 'super' must be called before accessing 'this' in the constructor of a derived class. + let f3 = super.x; // Error + ~~~~~ +!!! error TS17011: 'super' must be called before accessing a property of 'super' in the constructor of a derived class. + } + } + + // Repro from #38512 + + export class Foo { + constructor(value: number) { + } + } + + export class BarCorrectlyFails extends Foo { + constructor(something: boolean) { + if (!something) { + const value = this.bar(); // Error + ~~~~ +!!! error TS17009: 'super' must be called before accessing 'this' in the constructor of a derived class. + super(value); + } + else { + super(1337); + } + } + bar(): number { return 4; } + } + + export class BarIncorrectlyWorks extends Foo { + constructor(something: boolean) { + if (something) { + super(1337); + } + else { + const value = this.bar(); // Error + ~~~~ +!!! error TS17009: 'super' must be called before accessing 'this' in the constructor of a derived class. + super(value); + } + } + bar(): number { return 4; } + } + \ No newline at end of file diff --git a/tests/baselines/reference/checkSuperCallBeforeThisAccess.js b/tests/baselines/reference/checkSuperCallBeforeThisAccess.js new file mode 100644 index 00000000000..0bd17ed4fa3 --- /dev/null +++ b/tests/baselines/reference/checkSuperCallBeforeThisAccess.js @@ -0,0 +1,161 @@ +//// [checkSuperCallBeforeThisAccess.ts] +class A { + x = 1; +} + +class C1 extends A { + constructor(n: number) { + let a1 = this; // Error + let a2 = this.x; // Error + let a3 = super.x; // Error + let a4 = () => this; + let a5 = () => this.x; + let a6 = () => super.x; + if (!!true) { + super(); + let b1 = this; + let b2 = this.x; + let b3 = super.x; + } + else { + let c1 = this; // Error + let c2 = this.x; // Error + let c3 = super.x; // Error + } + if (!!true) { + switch (n) { + case 1: + super(); + let d1 = this.x; + case 2: + let d2 = this.x; // Error + default: + super(); + let d3 = this.x; + } + let d4 = this.x; + } + if (!!true) { + let e1 = { w: !!true ? super() : 0 }; + let e2 = this.x; // Error + let e3 = { w: !!true ? super() : super() }; + let e4 = this.x; + } + let f1 = this; // Error + let f2 = this.x; // Error + let f3 = super.x; // Error + } +} + +// Repro from #38512 + +export class Foo { + constructor(value: number) { + } +} + +export class BarCorrectlyFails extends Foo { + constructor(something: boolean) { + if (!something) { + const value = this.bar(); // Error + super(value); + } + else { + super(1337); + } + } + bar(): number { return 4; } +} + +export class BarIncorrectlyWorks extends Foo { + constructor(something: boolean) { + if (something) { + super(1337); + } + else { + const value = this.bar(); // Error + super(value); + } + } + bar(): number { return 4; } +} + + +//// [checkSuperCallBeforeThisAccess.js] +class A { + constructor() { + this.x = 1; + } +} +class C1 extends A { + constructor(n) { + let a1 = this; // Error + let a2 = this.x; // Error + let a3 = super.x; // Error + let a4 = () => this; + let a5 = () => this.x; + let a6 = () => super.x; + if (!!true) { + super(); + let b1 = this; + let b2 = this.x; + let b3 = super.x; + } + else { + let c1 = this; // Error + let c2 = this.x; // Error + let c3 = super.x; // Error + } + if (!!true) { + switch (n) { + case 1: + super(); + let d1 = this.x; + case 2: + let d2 = this.x; // Error + default: + super(); + let d3 = this.x; + } + let d4 = this.x; + } + if (!!true) { + let e1 = { w: !!true ? super() : 0 }; + let e2 = this.x; // Error + let e3 = { w: !!true ? super() : super() }; + let e4 = this.x; + } + let f1 = this; // Error + let f2 = this.x; // Error + let f3 = super.x; // Error + } +} +// Repro from #38512 +export class Foo { + constructor(value) { + } +} +export class BarCorrectlyFails extends Foo { + constructor(something) { + if (!something) { + const value = this.bar(); // Error + super(value); + } + else { + super(1337); + } + } + bar() { return 4; } +} +export class BarIncorrectlyWorks extends Foo { + constructor(something) { + if (something) { + super(1337); + } + else { + const value = this.bar(); // Error + super(value); + } + } + bar() { return 4; } +} diff --git a/tests/baselines/reference/checkSuperCallBeforeThisAccess.symbols b/tests/baselines/reference/checkSuperCallBeforeThisAccess.symbols new file mode 100644 index 00000000000..fbf9bb9d1a5 --- /dev/null +++ b/tests/baselines/reference/checkSuperCallBeforeThisAccess.symbols @@ -0,0 +1,231 @@ +=== tests/cases/compiler/checkSuperCallBeforeThisAccess.ts === +class A { +>A : Symbol(A, Decl(checkSuperCallBeforeThisAccess.ts, 0, 0)) + + x = 1; +>x : Symbol(A.x, Decl(checkSuperCallBeforeThisAccess.ts, 0, 9)) +} + +class C1 extends A { +>C1 : Symbol(C1, Decl(checkSuperCallBeforeThisAccess.ts, 2, 1)) +>A : Symbol(A, Decl(checkSuperCallBeforeThisAccess.ts, 0, 0)) + + constructor(n: number) { +>n : Symbol(n, Decl(checkSuperCallBeforeThisAccess.ts, 5, 16)) + + let a1 = this; // Error +>a1 : Symbol(a1, Decl(checkSuperCallBeforeThisAccess.ts, 6, 11)) +>this : Symbol(C1, Decl(checkSuperCallBeforeThisAccess.ts, 2, 1)) + + let a2 = this.x; // Error +>a2 : Symbol(a2, Decl(checkSuperCallBeforeThisAccess.ts, 7, 11)) +>this.x : Symbol(A.x, Decl(checkSuperCallBeforeThisAccess.ts, 0, 9)) +>this : Symbol(C1, Decl(checkSuperCallBeforeThisAccess.ts, 2, 1)) +>x : Symbol(A.x, Decl(checkSuperCallBeforeThisAccess.ts, 0, 9)) + + let a3 = super.x; // Error +>a3 : Symbol(a3, Decl(checkSuperCallBeforeThisAccess.ts, 8, 11)) +>super.x : Symbol(A.x, Decl(checkSuperCallBeforeThisAccess.ts, 0, 9)) +>super : Symbol(A, Decl(checkSuperCallBeforeThisAccess.ts, 0, 0)) +>x : Symbol(A.x, Decl(checkSuperCallBeforeThisAccess.ts, 0, 9)) + + let a4 = () => this; +>a4 : Symbol(a4, Decl(checkSuperCallBeforeThisAccess.ts, 9, 11)) +>this : Symbol(C1, Decl(checkSuperCallBeforeThisAccess.ts, 2, 1)) + + let a5 = () => this.x; +>a5 : Symbol(a5, Decl(checkSuperCallBeforeThisAccess.ts, 10, 11)) +>this.x : Symbol(A.x, Decl(checkSuperCallBeforeThisAccess.ts, 0, 9)) +>this : Symbol(C1, Decl(checkSuperCallBeforeThisAccess.ts, 2, 1)) +>x : Symbol(A.x, Decl(checkSuperCallBeforeThisAccess.ts, 0, 9)) + + let a6 = () => super.x; +>a6 : Symbol(a6, Decl(checkSuperCallBeforeThisAccess.ts, 11, 11)) +>super.x : Symbol(A.x, Decl(checkSuperCallBeforeThisAccess.ts, 0, 9)) +>super : Symbol(A, Decl(checkSuperCallBeforeThisAccess.ts, 0, 0)) +>x : Symbol(A.x, Decl(checkSuperCallBeforeThisAccess.ts, 0, 9)) + + if (!!true) { + super(); +>super : Symbol(A, Decl(checkSuperCallBeforeThisAccess.ts, 0, 0)) + + let b1 = this; +>b1 : Symbol(b1, Decl(checkSuperCallBeforeThisAccess.ts, 14, 15)) +>this : Symbol(C1, Decl(checkSuperCallBeforeThisAccess.ts, 2, 1)) + + let b2 = this.x; +>b2 : Symbol(b2, Decl(checkSuperCallBeforeThisAccess.ts, 15, 15)) +>this.x : Symbol(A.x, Decl(checkSuperCallBeforeThisAccess.ts, 0, 9)) +>this : Symbol(C1, Decl(checkSuperCallBeforeThisAccess.ts, 2, 1)) +>x : Symbol(A.x, Decl(checkSuperCallBeforeThisAccess.ts, 0, 9)) + + let b3 = super.x; +>b3 : Symbol(b3, Decl(checkSuperCallBeforeThisAccess.ts, 16, 15)) +>super.x : Symbol(A.x, Decl(checkSuperCallBeforeThisAccess.ts, 0, 9)) +>super : Symbol(A, Decl(checkSuperCallBeforeThisAccess.ts, 0, 0)) +>x : Symbol(A.x, Decl(checkSuperCallBeforeThisAccess.ts, 0, 9)) + } + else { + let c1 = this; // Error +>c1 : Symbol(c1, Decl(checkSuperCallBeforeThisAccess.ts, 19, 15)) +>this : Symbol(C1, Decl(checkSuperCallBeforeThisAccess.ts, 2, 1)) + + let c2 = this.x; // Error +>c2 : Symbol(c2, Decl(checkSuperCallBeforeThisAccess.ts, 20, 15)) +>this.x : Symbol(A.x, Decl(checkSuperCallBeforeThisAccess.ts, 0, 9)) +>this : Symbol(C1, Decl(checkSuperCallBeforeThisAccess.ts, 2, 1)) +>x : Symbol(A.x, Decl(checkSuperCallBeforeThisAccess.ts, 0, 9)) + + let c3 = super.x; // Error +>c3 : Symbol(c3, Decl(checkSuperCallBeforeThisAccess.ts, 21, 15)) +>super.x : Symbol(A.x, Decl(checkSuperCallBeforeThisAccess.ts, 0, 9)) +>super : Symbol(A, Decl(checkSuperCallBeforeThisAccess.ts, 0, 0)) +>x : Symbol(A.x, Decl(checkSuperCallBeforeThisAccess.ts, 0, 9)) + } + if (!!true) { + switch (n) { +>n : Symbol(n, Decl(checkSuperCallBeforeThisAccess.ts, 5, 16)) + + case 1: + super(); +>super : Symbol(A, Decl(checkSuperCallBeforeThisAccess.ts, 0, 0)) + + let d1 = this.x; +>d1 : Symbol(d1, Decl(checkSuperCallBeforeThisAccess.ts, 27, 23)) +>this.x : Symbol(A.x, Decl(checkSuperCallBeforeThisAccess.ts, 0, 9)) +>this : Symbol(C1, Decl(checkSuperCallBeforeThisAccess.ts, 2, 1)) +>x : Symbol(A.x, Decl(checkSuperCallBeforeThisAccess.ts, 0, 9)) + + case 2: + let d2 = this.x; // Error +>d2 : Symbol(d2, Decl(checkSuperCallBeforeThisAccess.ts, 29, 23)) +>this.x : Symbol(A.x, Decl(checkSuperCallBeforeThisAccess.ts, 0, 9)) +>this : Symbol(C1, Decl(checkSuperCallBeforeThisAccess.ts, 2, 1)) +>x : Symbol(A.x, Decl(checkSuperCallBeforeThisAccess.ts, 0, 9)) + + default: + super(); +>super : Symbol(A, Decl(checkSuperCallBeforeThisAccess.ts, 0, 0)) + + let d3 = this.x; +>d3 : Symbol(d3, Decl(checkSuperCallBeforeThisAccess.ts, 32, 23)) +>this.x : Symbol(A.x, Decl(checkSuperCallBeforeThisAccess.ts, 0, 9)) +>this : Symbol(C1, Decl(checkSuperCallBeforeThisAccess.ts, 2, 1)) +>x : Symbol(A.x, Decl(checkSuperCallBeforeThisAccess.ts, 0, 9)) + } + let d4 = this.x; +>d4 : Symbol(d4, Decl(checkSuperCallBeforeThisAccess.ts, 34, 15)) +>this.x : Symbol(A.x, Decl(checkSuperCallBeforeThisAccess.ts, 0, 9)) +>this : Symbol(C1, Decl(checkSuperCallBeforeThisAccess.ts, 2, 1)) +>x : Symbol(A.x, Decl(checkSuperCallBeforeThisAccess.ts, 0, 9)) + } + if (!!true) { + let e1 = { w: !!true ? super() : 0 }; +>e1 : Symbol(e1, Decl(checkSuperCallBeforeThisAccess.ts, 37, 15)) +>w : Symbol(w, Decl(checkSuperCallBeforeThisAccess.ts, 37, 22)) +>super : Symbol(A, Decl(checkSuperCallBeforeThisAccess.ts, 0, 0)) + + let e2 = this.x; // Error +>e2 : Symbol(e2, Decl(checkSuperCallBeforeThisAccess.ts, 38, 15)) +>this.x : Symbol(A.x, Decl(checkSuperCallBeforeThisAccess.ts, 0, 9)) +>this : Symbol(C1, Decl(checkSuperCallBeforeThisAccess.ts, 2, 1)) +>x : Symbol(A.x, Decl(checkSuperCallBeforeThisAccess.ts, 0, 9)) + + let e3 = { w: !!true ? super() : super() }; +>e3 : Symbol(e3, Decl(checkSuperCallBeforeThisAccess.ts, 39, 15)) +>w : Symbol(w, Decl(checkSuperCallBeforeThisAccess.ts, 39, 22)) +>super : Symbol(A, Decl(checkSuperCallBeforeThisAccess.ts, 0, 0)) +>super : Symbol(A, Decl(checkSuperCallBeforeThisAccess.ts, 0, 0)) + + let e4 = this.x; +>e4 : Symbol(e4, Decl(checkSuperCallBeforeThisAccess.ts, 40, 15)) +>this.x : Symbol(A.x, Decl(checkSuperCallBeforeThisAccess.ts, 0, 9)) +>this : Symbol(C1, Decl(checkSuperCallBeforeThisAccess.ts, 2, 1)) +>x : Symbol(A.x, Decl(checkSuperCallBeforeThisAccess.ts, 0, 9)) + } + let f1 = this; // Error +>f1 : Symbol(f1, Decl(checkSuperCallBeforeThisAccess.ts, 42, 11)) +>this : Symbol(C1, Decl(checkSuperCallBeforeThisAccess.ts, 2, 1)) + + let f2 = this.x; // Error +>f2 : Symbol(f2, Decl(checkSuperCallBeforeThisAccess.ts, 43, 11)) +>this.x : Symbol(A.x, Decl(checkSuperCallBeforeThisAccess.ts, 0, 9)) +>this : Symbol(C1, Decl(checkSuperCallBeforeThisAccess.ts, 2, 1)) +>x : Symbol(A.x, Decl(checkSuperCallBeforeThisAccess.ts, 0, 9)) + + let f3 = super.x; // Error +>f3 : Symbol(f3, Decl(checkSuperCallBeforeThisAccess.ts, 44, 11)) +>super.x : Symbol(A.x, Decl(checkSuperCallBeforeThisAccess.ts, 0, 9)) +>super : Symbol(A, Decl(checkSuperCallBeforeThisAccess.ts, 0, 0)) +>x : Symbol(A.x, Decl(checkSuperCallBeforeThisAccess.ts, 0, 9)) + } +} + +// Repro from #38512 + +export class Foo { +>Foo : Symbol(Foo, Decl(checkSuperCallBeforeThisAccess.ts, 46, 1)) + + constructor(value: number) { +>value : Symbol(value, Decl(checkSuperCallBeforeThisAccess.ts, 51, 16)) + } +} + +export class BarCorrectlyFails extends Foo { +>BarCorrectlyFails : Symbol(BarCorrectlyFails, Decl(checkSuperCallBeforeThisAccess.ts, 53, 1)) +>Foo : Symbol(Foo, Decl(checkSuperCallBeforeThisAccess.ts, 46, 1)) + + constructor(something: boolean) { +>something : Symbol(something, Decl(checkSuperCallBeforeThisAccess.ts, 56, 16)) + + if (!something) { +>something : Symbol(something, Decl(checkSuperCallBeforeThisAccess.ts, 56, 16)) + + const value = this.bar(); // Error +>value : Symbol(value, Decl(checkSuperCallBeforeThisAccess.ts, 58, 17)) +>this.bar : Symbol(BarCorrectlyFails.bar, Decl(checkSuperCallBeforeThisAccess.ts, 64, 5)) +>this : Symbol(BarCorrectlyFails, Decl(checkSuperCallBeforeThisAccess.ts, 53, 1)) +>bar : Symbol(BarCorrectlyFails.bar, Decl(checkSuperCallBeforeThisAccess.ts, 64, 5)) + + super(value); +>super : Symbol(Foo, Decl(checkSuperCallBeforeThisAccess.ts, 46, 1)) +>value : Symbol(value, Decl(checkSuperCallBeforeThisAccess.ts, 58, 17)) + } + else { + super(1337); +>super : Symbol(Foo, Decl(checkSuperCallBeforeThisAccess.ts, 46, 1)) + } + } + bar(): number { return 4; } +>bar : Symbol(BarCorrectlyFails.bar, Decl(checkSuperCallBeforeThisAccess.ts, 64, 5)) +} + +export class BarIncorrectlyWorks extends Foo { +>BarIncorrectlyWorks : Symbol(BarIncorrectlyWorks, Decl(checkSuperCallBeforeThisAccess.ts, 66, 1)) +>Foo : Symbol(Foo, Decl(checkSuperCallBeforeThisAccess.ts, 46, 1)) + + constructor(something: boolean) { +>something : Symbol(something, Decl(checkSuperCallBeforeThisAccess.ts, 69, 16)) + + if (something) { +>something : Symbol(something, Decl(checkSuperCallBeforeThisAccess.ts, 69, 16)) + + super(1337); +>super : Symbol(Foo, Decl(checkSuperCallBeforeThisAccess.ts, 46, 1)) + } + else { + const value = this.bar(); // Error +>value : Symbol(value, Decl(checkSuperCallBeforeThisAccess.ts, 74, 17)) +>this.bar : Symbol(BarIncorrectlyWorks.bar, Decl(checkSuperCallBeforeThisAccess.ts, 77, 5)) +>this : Symbol(BarIncorrectlyWorks, Decl(checkSuperCallBeforeThisAccess.ts, 66, 1)) +>bar : Symbol(BarIncorrectlyWorks.bar, Decl(checkSuperCallBeforeThisAccess.ts, 77, 5)) + + super(value); +>super : Symbol(Foo, Decl(checkSuperCallBeforeThisAccess.ts, 46, 1)) +>value : Symbol(value, Decl(checkSuperCallBeforeThisAccess.ts, 74, 17)) + } + } + bar(): number { return 4; } +>bar : Symbol(BarIncorrectlyWorks.bar, Decl(checkSuperCallBeforeThisAccess.ts, 77, 5)) +} + diff --git a/tests/baselines/reference/checkSuperCallBeforeThisAccess.types b/tests/baselines/reference/checkSuperCallBeforeThisAccess.types new file mode 100644 index 00000000000..7a6914107f2 --- /dev/null +++ b/tests/baselines/reference/checkSuperCallBeforeThisAccess.types @@ -0,0 +1,279 @@ +=== tests/cases/compiler/checkSuperCallBeforeThisAccess.ts === +class A { +>A : A + + x = 1; +>x : number +>1 : 1 +} + +class C1 extends A { +>C1 : C1 +>A : A + + constructor(n: number) { +>n : number + + let a1 = this; // Error +>a1 : this +>this : this + + let a2 = this.x; // Error +>a2 : number +>this.x : number +>this : this +>x : number + + let a3 = super.x; // Error +>a3 : number +>super.x : number +>super : A +>x : number + + let a4 = () => this; +>a4 : () => this +>() => this : () => this +>this : this + + let a5 = () => this.x; +>a5 : () => number +>() => this.x : () => number +>this.x : number +>this : this +>x : number + + let a6 = () => super.x; +>a6 : () => number +>() => super.x : () => number +>super.x : number +>super : A +>x : number + + if (!!true) { +>!!true : true +>!true : false +>true : true + + super(); +>super() : void +>super : typeof A + + let b1 = this; +>b1 : this +>this : this + + let b2 = this.x; +>b2 : number +>this.x : number +>this : this +>x : number + + let b3 = super.x; +>b3 : number +>super.x : number +>super : A +>x : number + } + else { + let c1 = this; // Error +>c1 : this +>this : this + + let c2 = this.x; // Error +>c2 : number +>this.x : number +>this : this +>x : number + + let c3 = super.x; // Error +>c3 : number +>super.x : number +>super : A +>x : number + } + if (!!true) { +>!!true : true +>!true : false +>true : true + + switch (n) { +>n : number + + case 1: +>1 : 1 + + super(); +>super() : void +>super : typeof A + + let d1 = this.x; +>d1 : number +>this.x : number +>this : this +>x : number + + case 2: +>2 : 2 + + let d2 = this.x; // Error +>d2 : number +>this.x : number +>this : this +>x : number + + default: + super(); +>super() : void +>super : typeof A + + let d3 = this.x; +>d3 : number +>this.x : number +>this : this +>x : number + } + let d4 = this.x; +>d4 : number +>this.x : number +>this : this +>x : number + } + if (!!true) { +>!!true : true +>!true : false +>true : true + + let e1 = { w: !!true ? super() : 0 }; +>e1 : { w: number | void; } +>{ w: !!true ? super() : 0 } : { w: number | void; } +>w : number | void +>!!true ? super() : 0 : void | 0 +>!!true : true +>!true : false +>true : true +>super() : void +>super : typeof A +>0 : 0 + + let e2 = this.x; // Error +>e2 : number +>this.x : number +>this : this +>x : number + + let e3 = { w: !!true ? super() : super() }; +>e3 : { w: void; } +>{ w: !!true ? super() : super() } : { w: void; } +>w : void +>!!true ? super() : super() : void +>!!true : true +>!true : false +>true : true +>super() : void +>super : typeof A +>super() : void +>super : typeof A + + let e4 = this.x; +>e4 : number +>this.x : number +>this : this +>x : number + } + let f1 = this; // Error +>f1 : this +>this : this + + let f2 = this.x; // Error +>f2 : number +>this.x : number +>this : this +>x : number + + let f3 = super.x; // Error +>f3 : number +>super.x : number +>super : A +>x : number + } +} + +// Repro from #38512 + +export class Foo { +>Foo : Foo + + constructor(value: number) { +>value : number + } +} + +export class BarCorrectlyFails extends Foo { +>BarCorrectlyFails : BarCorrectlyFails +>Foo : Foo + + constructor(something: boolean) { +>something : boolean + + if (!something) { +>!something : boolean +>something : boolean + + const value = this.bar(); // Error +>value : number +>this.bar() : number +>this.bar : () => number +>this : this +>bar : () => number + + super(value); +>super(value) : void +>super : typeof Foo +>value : number + } + else { + super(1337); +>super(1337) : void +>super : typeof Foo +>1337 : 1337 + } + } + bar(): number { return 4; } +>bar : () => number +>4 : 4 +} + +export class BarIncorrectlyWorks extends Foo { +>BarIncorrectlyWorks : BarIncorrectlyWorks +>Foo : Foo + + constructor(something: boolean) { +>something : boolean + + if (something) { +>something : boolean + + super(1337); +>super(1337) : void +>super : typeof Foo +>1337 : 1337 + } + else { + const value = this.bar(); // Error +>value : number +>this.bar() : number +>this.bar : () => number +>this : this +>bar : () => number + + super(value); +>super(value) : void +>super : typeof Foo +>value : number + } + } + bar(): number { return 4; } +>bar : () => number +>4 : 4 +} + diff --git a/tests/baselines/reference/superAccess2.errors.txt b/tests/baselines/reference/superAccess2.errors.txt index 65d4c10794d..e5475595472 100644 --- a/tests/baselines/reference/superAccess2.errors.txt +++ b/tests/baselines/reference/superAccess2.errors.txt @@ -7,7 +7,6 @@ tests/cases/compiler/superAccess2.ts(11,33): error TS1034: 'super' must be follo tests/cases/compiler/superAccess2.ts(11,40): error TS2336: 'super' cannot be referenced in constructor arguments. tests/cases/compiler/superAccess2.ts(11,40): error TS17011: 'super' must be called before accessing a property of 'super' in the constructor of a derived class. tests/cases/compiler/superAccess2.ts(11,45): error TS1034: 'super' must be followed by an argument list or member access. -tests/cases/compiler/superAccess2.ts(11,59): error TS17011: 'super' must be called before accessing a property of 'super' in the constructor of a derived class. tests/cases/compiler/superAccess2.ts(11,64): error TS1034: 'super' must be followed by an argument list or member access. tests/cases/compiler/superAccess2.ts(15,19): error TS1034: 'super' must be followed by an argument list or member access. tests/cases/compiler/superAccess2.ts(17,15): error TS2576: Property 'y' is a static member of type 'P' @@ -15,7 +14,7 @@ tests/cases/compiler/superAccess2.ts(20,26): error TS1034: 'super' must be follo tests/cases/compiler/superAccess2.ts(21,15): error TS2339: Property 'x' does not exist on type 'typeof P'. -==== tests/cases/compiler/superAccess2.ts (15 errors) ==== +==== tests/cases/compiler/superAccess2.ts (14 errors) ==== class P { x() { } static y() { } @@ -45,8 +44,6 @@ tests/cases/compiler/superAccess2.ts(21,15): error TS2339: Property 'x' does not !!! error TS17011: 'super' must be called before accessing a property of 'super' in the constructor of a derived class. ~ !!! error TS1034: 'super' must be followed by an argument list or member access. - ~~~~~ -!!! error TS17011: 'super' must be called before accessing a property of 'super' in the constructor of a derived class. ~ !!! error TS1034: 'super' must be followed by an argument list or member access. super(); diff --git a/tests/cases/compiler/checkSuperCallBeforeThisAccess.ts b/tests/cases/compiler/checkSuperCallBeforeThisAccess.ts new file mode 100644 index 00000000000..1b97d7bea7a --- /dev/null +++ b/tests/cases/compiler/checkSuperCallBeforeThisAccess.ts @@ -0,0 +1,83 @@ +// @strict: true +// @target: esnext + +class A { + x = 1; +} + +class C1 extends A { + constructor(n: number) { + let a1 = this; // Error + let a2 = this.x; // Error + let a3 = super.x; // Error + let a4 = () => this; + let a5 = () => this.x; + let a6 = () => super.x; + if (!!true) { + super(); + let b1 = this; + let b2 = this.x; + let b3 = super.x; + } + else { + let c1 = this; // Error + let c2 = this.x; // Error + let c3 = super.x; // Error + } + if (!!true) { + switch (n) { + case 1: + super(); + let d1 = this.x; + case 2: + let d2 = this.x; // Error + default: + super(); + let d3 = this.x; + } + let d4 = this.x; + } + if (!!true) { + let e1 = { w: !!true ? super() : 0 }; + let e2 = this.x; // Error + let e3 = { w: !!true ? super() : super() }; + let e4 = this.x; + } + let f1 = this; // Error + let f2 = this.x; // Error + let f3 = super.x; // Error + } +} + +// Repro from #38512 + +export class Foo { + constructor(value: number) { + } +} + +export class BarCorrectlyFails extends Foo { + constructor(something: boolean) { + if (!something) { + const value = this.bar(); // Error + super(value); + } + else { + super(1337); + } + } + bar(): number { return 4; } +} + +export class BarIncorrectlyWorks extends Foo { + constructor(something: boolean) { + if (something) { + super(1337); + } + else { + const value = this.bar(); // Error + super(value); + } + } + bar(): number { return 4; } +} From 437d68d64b69e51270866101d38753f83e8c0970 Mon Sep 17 00:00:00 2001 From: csigs Date: Mon, 18 May 2020 10:10:25 +0000 Subject: [PATCH 04/15] LEGO: check in for master to temporary branch. --- .../diagnosticMessages.generated.json.lcl | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/src/loc/lcl/chs/diagnosticMessages/diagnosticMessages.generated.json.lcl b/src/loc/lcl/chs/diagnosticMessages/diagnosticMessages.generated.json.lcl index bf58e6d2b24..c6894237adc 100644 --- a/src/loc/lcl/chs/diagnosticMessages/diagnosticMessages.generated.json.lcl +++ b/src/loc/lcl/chs/diagnosticMessages/diagnosticMessages.generated.json.lcl @@ -51,6 +51,9 @@ + + + @@ -10395,6 +10398,9 @@ + + + From 2b703d254a72d78740d65dc1c6743ae00245e404 Mon Sep 17 00:00:00 2001 From: Alexander T Date: Mon, 18 May 2020 15:22:03 +0300 Subject: [PATCH 05/15] fix(33233): add outlining for comments before property access expression --- src/services/outliningElementsCollector.ts | 4 ++++ .../fourslash/getOutliningForBlockComments.ts | 20 +++++++++++++++++++ .../getOutliningForSingleLineComments.ts | 12 +++++++++++ 3 files changed, 36 insertions(+) diff --git a/src/services/outliningElementsCollector.ts b/src/services/outliningElementsCollector.ts index 7f3028c2c6f..f818123abdc 100644 --- a/src/services/outliningElementsCollector.ts +++ b/src/services/outliningElementsCollector.ts @@ -42,6 +42,10 @@ namespace ts.OutliningElementsCollector { addOutliningForLeadingCommentsForNode(n.parent.parent.parent, sourceFile, cancellationToken, out); } + if (isFunctionLike(n) && isBinaryExpression(n.parent) && isPropertyAccessExpression(n.parent.left)) { + addOutliningForLeadingCommentsForNode(n.parent.left, sourceFile, cancellationToken, out); + } + const span = getOutliningSpanForNode(n, sourceFile); if (span) out.push(span); diff --git a/tests/cases/fourslash/getOutliningForBlockComments.ts b/tests/cases/fourslash/getOutliningForBlockComments.ts index cc0bbc3c310..567806877ba 100644 --- a/tests/cases/fourslash/getOutliningForBlockComments.ts +++ b/tests/cases/fourslash/getOutliningForBlockComments.ts @@ -110,6 +110,26 @@ //// const sum2 = (y, z) =>[| { //// return y + z; //// }|]; +//// +////function Foo()[| { +//// [|/** +//// * Description +//// * +//// * @param {string} param +//// * @returns +//// */|] +//// this.method = function (param)[| { +//// }|] +//// +//// [|/** +//// * Description +//// * +//// * @param {string} param +//// * @returns +//// */|] +//// function method(param)[| { +//// }|] +////}|] verify.outliningSpansInCurrentFile(test.ranges()); diff --git a/tests/cases/fourslash/getOutliningForSingleLineComments.ts b/tests/cases/fourslash/getOutliningForSingleLineComments.ts index 903b1c55494..9ada3fca446 100644 --- a/tests/cases/fourslash/getOutliningForSingleLineComments.ts +++ b/tests/cases/fourslash/getOutliningForSingleLineComments.ts @@ -72,6 +72,18 @@ ////// One single line comment should not be collapsed ////class WithOneSingleLineComment[| { ////}|] +//// +////function Foo()[| { +//// [|// comment 1 +//// // comment 2|] +//// this.method = function (param)[| { +//// }|] +//// +//// [|// comment 1 +//// // comment 2|] +//// function method(param)[| { +//// }|] +////}|] verify.outliningSpansInCurrentFile(test.ranges()); From 48d6e8dee5f5218c52a0aeee32d009e95b867439 Mon Sep 17 00:00:00 2001 From: csigs Date: Mon, 18 May 2020 16:10:40 +0000 Subject: [PATCH 06/15] LEGO: check in for master to temporary branch. --- .../diagnosticMessages.generated.json.lcl | 6 +++ .../diagnosticMessages.generated.json.lcl | 42 +++++++++++++------ 2 files changed, 36 insertions(+), 12 deletions(-) diff --git a/src/loc/lcl/chs/diagnosticMessages/diagnosticMessages.generated.json.lcl b/src/loc/lcl/chs/diagnosticMessages/diagnosticMessages.generated.json.lcl index c6894237adc..1659967c85b 100644 --- a/src/loc/lcl/chs/diagnosticMessages/diagnosticMessages.generated.json.lcl +++ b/src/loc/lcl/chs/diagnosticMessages/diagnosticMessages.generated.json.lcl @@ -8652,6 +8652,9 @@ + + + @@ -8667,6 +8670,9 @@ + + + diff --git a/src/loc/lcl/plk/diagnosticMessages/diagnosticMessages.generated.json.lcl b/src/loc/lcl/plk/diagnosticMessages/diagnosticMessages.generated.json.lcl index 3909794c3f6..ee2556975b7 100644 --- a/src/loc/lcl/plk/diagnosticMessages/diagnosticMessages.generated.json.lcl +++ b/src/loc/lcl/plk/diagnosticMessages/diagnosticMessages.generated.json.lcl @@ -41,6 +41,15 @@ + + + + + + + + + @@ -8600,15 +8609,6 @@ - - - - - - - - - @@ -8636,11 +8636,11 @@ - + - + - + @@ -8654,6 +8654,15 @@ + + + + + + + + + @@ -10379,6 +10388,15 @@ + + + + + + + + + From 92dc5b8754c71ff1d69a3f317984248bd4cfa1ad Mon Sep 17 00:00:00 2001 From: csigs Date: Mon, 18 May 2020 22:10:33 +0000 Subject: [PATCH 07/15] LEGO: check in for master to temporary branch. --- .../diagnosticMessages.generated.json.lcl | 3 +++ .../diagnosticMessages.generated.json.lcl | 12 ++++++++++++ .../diagnosticMessages.generated.json.lcl | 14 +++++++++++++- 3 files changed, 28 insertions(+), 1 deletion(-) diff --git a/src/loc/lcl/deu/diagnosticMessages/diagnosticMessages.generated.json.lcl b/src/loc/lcl/deu/diagnosticMessages/diagnosticMessages.generated.json.lcl index 9648a4f69c8..d93ca3cb645 100644 --- a/src/loc/lcl/deu/diagnosticMessages/diagnosticMessages.generated.json.lcl +++ b/src/loc/lcl/deu/diagnosticMessages/diagnosticMessages.generated.json.lcl @@ -10389,6 +10389,9 @@ + + + diff --git a/src/loc/lcl/rus/diagnosticMessages/diagnosticMessages.generated.json.lcl b/src/loc/lcl/rus/diagnosticMessages/diagnosticMessages.generated.json.lcl index c699b21b978..2103003ab8b 100644 --- a/src/loc/lcl/rus/diagnosticMessages/diagnosticMessages.generated.json.lcl +++ b/src/loc/lcl/rus/diagnosticMessages/diagnosticMessages.generated.json.lcl @@ -50,6 +50,9 @@ + + + @@ -8648,6 +8651,9 @@ + + + @@ -8663,6 +8669,9 @@ + + + @@ -10394,6 +10403,9 @@ + + + diff --git a/src/loc/lcl/trk/diagnosticMessages/diagnosticMessages.generated.json.lcl b/src/loc/lcl/trk/diagnosticMessages/diagnosticMessages.generated.json.lcl index 71447b892b1..f54f92252c4 100644 --- a/src/loc/lcl/trk/diagnosticMessages/diagnosticMessages.generated.json.lcl +++ b/src/loc/lcl/trk/diagnosticMessages/diagnosticMessages.generated.json.lcl @@ -44,6 +44,9 @@ + + + @@ -7209,7 +7212,7 @@ - + @@ -8642,6 +8645,9 @@ + + + @@ -8657,6 +8663,9 @@ + + + @@ -10388,6 +10397,9 @@ + + + From 90b772a751c6cd56a9f5f07a7cec5bf0cc4ed151 Mon Sep 17 00:00:00 2001 From: csigs Date: Tue, 19 May 2020 04:10:35 +0000 Subject: [PATCH 08/15] LEGO: check in for master to temporary branch. --- .../diagnosticMessages.generated.json.lcl | 14 +++++++++++++- .../diagnosticMessages.generated.json.lcl | 11 ++++++++++- .../diagnosticMessages.generated.json.lcl | 12 ++++++++++++ 3 files changed, 35 insertions(+), 2 deletions(-) diff --git a/src/loc/lcl/csy/diagnosticMessages/diagnosticMessages.generated.json.lcl b/src/loc/lcl/csy/diagnosticMessages/diagnosticMessages.generated.json.lcl index f9b0e8b0b6f..c978880ba7a 100644 --- a/src/loc/lcl/csy/diagnosticMessages/diagnosticMessages.generated.json.lcl +++ b/src/loc/lcl/csy/diagnosticMessages/diagnosticMessages.generated.json.lcl @@ -60,6 +60,9 @@ + + + @@ -7225,7 +7228,7 @@ - + @@ -8658,6 +8661,9 @@ + + + @@ -8673,6 +8679,9 @@ + + + @@ -10404,6 +10413,9 @@ + + + diff --git a/src/loc/lcl/deu/diagnosticMessages/diagnosticMessages.generated.json.lcl b/src/loc/lcl/deu/diagnosticMessages/diagnosticMessages.generated.json.lcl index d93ca3cb645..b2b9c285f77 100644 --- a/src/loc/lcl/deu/diagnosticMessages/diagnosticMessages.generated.json.lcl +++ b/src/loc/lcl/deu/diagnosticMessages/diagnosticMessages.generated.json.lcl @@ -51,6 +51,9 @@ + + + @@ -7213,7 +7216,7 @@ - + @@ -8643,6 +8646,9 @@ + + + @@ -8658,6 +8664,9 @@ + + + diff --git a/src/loc/lcl/fra/diagnosticMessages/diagnosticMessages.generated.json.lcl b/src/loc/lcl/fra/diagnosticMessages/diagnosticMessages.generated.json.lcl index 4ffc04e4314..0659ab6c495 100644 --- a/src/loc/lcl/fra/diagnosticMessages/diagnosticMessages.generated.json.lcl +++ b/src/loc/lcl/fra/diagnosticMessages/diagnosticMessages.generated.json.lcl @@ -60,6 +60,9 @@ + + + @@ -8661,6 +8664,9 @@ + + + @@ -8676,6 +8682,9 @@ + + + @@ -10407,6 +10416,9 @@ + + + From e72e01d9ff551b7cf927dccbf26ceec2a2e9acfe Mon Sep 17 00:00:00 2001 From: Tim van der Lippe Date: Tue, 19 May 2020 12:06:09 +0100 Subject: [PATCH 09/15] Remove mentions of runtests-browser in CONTRIBUTING.md The gulp tasks were removed in #30054, but the contributing guidelines weren't updated accordingly. --- CONTRIBUTING.md | 13 ------------- 1 file changed, 13 deletions(-) diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index d6ecd1d66ae..06d20d60acf 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -139,19 +139,6 @@ gulp runtests --tests=2dArrays ## Debugging the tests -To debug the tests, invoke the `runtests-browser` task from gulp. -You will probably only want to debug one test at a time: - -```Shell -gulp runtests-browser --tests=2dArrays -``` - -You can specify which browser to use for debugging. Currently, Chrome and IE are supported: - -```Shell -gulp runtests-browser --tests=2dArrays --browser=chrome -``` - You can debug with VS Code or Node instead with `gulp runtests --inspect=true`: ```Shell From 77075df2d7c63d4dcdf3989d1b80bb90a09cd7c4 Mon Sep 17 00:00:00 2001 From: Tim van der Lippe Date: Tue, 19 May 2020 12:11:29 +0100 Subject: [PATCH 10/15] Fix debug command for Node debugging If you would run with `--inspect=true`, the following error would be thrown: [12:08:13] > node --inspect-brk=true TypeScript/node_modules/mocha/bin/_mocha -R scripts/failed-tests -O "reporter=mocha-fivemat-progress-reporter" -g "implementsJSDocReferencesDeclarationEmit" --colors -t 0 built/local/run.js Unable to resolve "true": unknown node or service --- CONTRIBUTING.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index d6ecd1d66ae..80f8f4b2fde 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -152,10 +152,10 @@ You can specify which browser to use for debugging. Currently, Chrome and IE are gulp runtests-browser --tests=2dArrays --browser=chrome ``` -You can debug with VS Code or Node instead with `gulp runtests --inspect=true`: +You can debug with VS Code or Node instead with `gulp runtests --inspect`: ```Shell -gulp runtests --tests=2dArrays --inspect=true +gulp runtests --tests=2dArrays --inspect ``` You can also use the [provided VS Code launch configuration](./.vscode/launch.template.json) to launch a debug session for an open test file. Rename the file 'launch.json', open the test file of interest, and launch the debugger from the debug panel (or press F5). From 707e9770564865d10168e3722eec4eb9e20d32db Mon Sep 17 00:00:00 2001 From: Andrew Branch Date: Tue, 19 May 2020 13:14:32 -0700 Subject: [PATCH 11/15] Ensure formatter can always get a newline character (#38579) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * Ensure formatter can always get a newline character * Make FormatContext.host optional since it’s not necessary if format options are all applied * Make FormattingHost required again --- src/harness/fourslashImpl.ts | 6 +++++ src/harness/fourslashInterfaceImpl.ts | 4 ++++ src/services/formatting/formatting.ts | 7 +++--- src/services/formatting/rulesMap.ts | 4 ++-- src/services/services.ts | 18 +++++++-------- src/services/types.ts | 5 +++++ src/services/utilities.ts | 6 ++--- .../services/convertToAsyncFunction.ts | 2 +- .../unittests/services/extract/helpers.ts | 4 ++-- .../unittests/services/textChanges.ts | 2 +- tests/cases/fourslash/fourslash.ts | 2 ++ .../organizeImportsNoFormatOptions.ts | 22 +++++++++++++++++++ 12 files changed, 61 insertions(+), 21 deletions(-) create mode 100644 tests/cases/fourslash/organizeImportsNoFormatOptions.ts diff --git a/src/harness/fourslashImpl.ts b/src/harness/fourslashImpl.ts index 5436413701d..dd4135ca40c 100644 --- a/src/harness/fourslashImpl.ts +++ b/src/harness/fourslashImpl.ts @@ -515,6 +515,12 @@ namespace FourSlash { } } + public verifyOrganizeImports(newContent: string) { + const changes = this.languageService.organizeImports({ fileName: this.activeFile.fileName, type: "file" }, this.formatCodeSettings, ts.emptyOptions); + this.applyChanges(changes); + this.verifyFileContent(this.activeFile.fileName, newContent); + } + private raiseError(message: string): never { throw new Error(this.messageAtLastKnownMarker(message)); } diff --git a/src/harness/fourslashInterfaceImpl.ts b/src/harness/fourslashInterfaceImpl.ts index ca7ac8f58ff..f4905c00b84 100644 --- a/src/harness/fourslashInterfaceImpl.ts +++ b/src/harness/fourslashInterfaceImpl.ts @@ -560,6 +560,10 @@ namespace FourSlashInterface { public noMoveToNewFile(): void { this.state.noMoveToNewFile(); } + + public organizeImports(newContent: string) { + this.state.verifyOrganizeImports(newContent); + } } export class Edit { diff --git a/src/services/formatting/formatting.ts b/src/services/formatting/formatting.ts index 31aff6b210a..951ad5e5bba 100644 --- a/src/services/formatting/formatting.ts +++ b/src/services/formatting/formatting.ts @@ -3,6 +3,7 @@ namespace ts.formatting { export interface FormatContext { readonly options: FormatCodeSettings; readonly getRules: RulesMap; + readonly host: FormattingHost; } export interface TextRangeWithKind extends TextRange { @@ -394,7 +395,7 @@ namespace ts.formatting { initialIndentation: number, delta: number, formattingScanner: FormattingScanner, - { options, getRules }: FormatContext, + { options, getRules, host }: FormatContext, requestKind: FormattingRequestKind, rangeContainsError: (r: TextRange) => boolean, sourceFile: SourceFileLike): TextChange[] { @@ -1193,7 +1194,7 @@ namespace ts.formatting { previousRange: TextRangeWithKind, previousStartLine: number, currentRange: TextRangeWithKind, - currentStartLine: number, + currentStartLine: number ): LineAction { const onLaterLine = currentStartLine !== previousStartLine; switch (rule.action) { @@ -1221,7 +1222,7 @@ namespace ts.formatting { // edit should not be applied if we have one line feed between elements const lineDelta = currentStartLine - previousStartLine; if (lineDelta !== 1) { - recordReplace(previousRange.end, currentRange.pos - previousRange.end, options.newLineCharacter!); + recordReplace(previousRange.end, currentRange.pos - previousRange.end, getNewLineOrDefaultFromHost(host, options)); return onLaterLine ? LineAction.None : LineAction.LineAdded; } break; diff --git a/src/services/formatting/rulesMap.ts b/src/services/formatting/rulesMap.ts index f466b397d20..ccee491040f 100644 --- a/src/services/formatting/rulesMap.ts +++ b/src/services/formatting/rulesMap.ts @@ -1,7 +1,7 @@ /* @internal */ namespace ts.formatting { - export function getFormatContext(options: FormatCodeSettings): FormatContext { - return { options, getRules: getRulesMap() }; + export function getFormatContext(options: FormatCodeSettings, host: FormattingHost): FormatContext { + return { options, getRules: getRulesMap(), host }; } let rulesMapCache: RulesMap | undefined; diff --git a/src/services/services.ts b/src/services/services.ts index f50d99e55d1..6668ee14f37 100644 --- a/src/services/services.ts +++ b/src/services/services.ts @@ -1502,7 +1502,7 @@ namespace ts { position, { name, source }, host, - (formattingOptions && formatting.getFormatContext(formattingOptions))!, // TODO: GH#18217 + (formattingOptions && formatting.getFormatContext(formattingOptions, host))!, // TODO: GH#18217 preferences, cancellationToken, ); @@ -1840,16 +1840,16 @@ namespace ts { function getFormattingEditsForRange(fileName: string, start: number, end: number, options: FormatCodeOptions | FormatCodeSettings): TextChange[] { const sourceFile = syntaxTreeCache.getCurrentSourceFile(fileName); - return formatting.formatSelection(start, end, sourceFile, formatting.getFormatContext(toEditorSettings(options))); + return formatting.formatSelection(start, end, sourceFile, formatting.getFormatContext(toEditorSettings(options), host)); } function getFormattingEditsForDocument(fileName: string, options: FormatCodeOptions | FormatCodeSettings): TextChange[] { - return formatting.formatDocument(syntaxTreeCache.getCurrentSourceFile(fileName), formatting.getFormatContext(toEditorSettings(options))); + return formatting.formatDocument(syntaxTreeCache.getCurrentSourceFile(fileName), formatting.getFormatContext(toEditorSettings(options), host)); } function getFormattingEditsAfterKeystroke(fileName: string, position: number, key: string, options: FormatCodeOptions | FormatCodeSettings): TextChange[] { const sourceFile = syntaxTreeCache.getCurrentSourceFile(fileName); - const formatContext = formatting.getFormatContext(toEditorSettings(options)); + const formatContext = formatting.getFormatContext(toEditorSettings(options), host); if (!isInComment(sourceFile, position)) { switch (key) { @@ -1871,7 +1871,7 @@ namespace ts { synchronizeHostData(); const sourceFile = getValidSourceFile(fileName); const span = createTextSpanFromBounds(start, end); - const formatContext = formatting.getFormatContext(formatOptions); + const formatContext = formatting.getFormatContext(formatOptions, host); return flatMap(deduplicate(errorCodes, equateValues, compareValues), errorCode => { cancellationToken.throwIfCancellationRequested(); @@ -1883,7 +1883,7 @@ namespace ts { synchronizeHostData(); Debug.assert(scope.type === "file"); const sourceFile = getValidSourceFile(scope.fileName); - const formatContext = formatting.getFormatContext(formatOptions); + const formatContext = formatting.getFormatContext(formatOptions, host); return codefix.getAllFixes({ fixId, sourceFile, program, host, cancellationToken, formatContext, preferences }); } @@ -1892,13 +1892,13 @@ namespace ts { synchronizeHostData(); Debug.assert(scope.type === "file"); const sourceFile = getValidSourceFile(scope.fileName); - const formatContext = formatting.getFormatContext(formatOptions); + const formatContext = formatting.getFormatContext(formatOptions, host); return OrganizeImports.organizeImports(sourceFile, formatContext, host, program, preferences); } function getEditsForFileRename(oldFilePath: string, newFilePath: string, formatOptions: FormatCodeSettings, preferences: UserPreferences = emptyOptions): readonly FileTextChanges[] { - return ts.getEditsForFileRename(getProgram()!, oldFilePath, newFilePath, host, formatting.getFormatContext(formatOptions), preferences, sourceMapper); + return ts.getEditsForFileRename(getProgram()!, oldFilePath, newFilePath, host, formatting.getFormatContext(formatOptions, host), preferences, sourceMapper); } function applyCodeActionCommand(action: CodeActionCommand, formatSettings?: FormatCodeSettings): Promise; @@ -2141,7 +2141,7 @@ namespace ts { endPosition, program: getProgram()!, host, - formatContext: formatting.getFormatContext(formatOptions!), // TODO: GH#18217 + formatContext: formatting.getFormatContext(formatOptions!, host), // TODO: GH#18217 cancellationToken, preferences, }; diff --git a/src/services/types.ts b/src/services/types.ts index 13c68364664..fd8ade8f8e6 100644 --- a/src/services/types.ts +++ b/src/services/types.ts @@ -203,6 +203,11 @@ namespace ts { has(dependencyName: string, inGroups?: PackageJsonDependencyGroup): boolean; } + /** @internal */ + export interface FormattingHost { + getNewLine?(): string; + } + // // Public interface of the host of a language service instance. // diff --git a/src/services/utilities.ts b/src/services/utilities.ts index 617855c584a..b1799167c43 100644 --- a/src/services/utilities.ts +++ b/src/services/utilities.ts @@ -2085,9 +2085,9 @@ namespace ts { /** * The default is CRLF. */ - export function getNewLineOrDefaultFromHost(host: LanguageServiceHost | LanguageServiceShimHost, formatSettings?: FormatCodeSettings) { - return (formatSettings && formatSettings.newLineCharacter) || - (host.getNewLine && host.getNewLine()) || + export function getNewLineOrDefaultFromHost(host: FormattingHost, formatSettings?: FormatCodeSettings) { + return formatSettings?.newLineCharacter || + host.getNewLine?.() || carriageReturnLineFeed; } diff --git a/src/testRunner/unittests/services/convertToAsyncFunction.ts b/src/testRunner/unittests/services/convertToAsyncFunction.ts index 999e1580a98..78a2f43f6c3 100644 --- a/src/testRunner/unittests/services/convertToAsyncFunction.ts +++ b/src/testRunner/unittests/services/convertToAsyncFunction.ts @@ -306,7 +306,7 @@ interface Array {}` cancellationToken: { throwIfCancellationRequested: noop, isCancellationRequested: returnFalse }, preferences: emptyOptions, host: notImplementedHost, - formatContext: formatting.getFormatContext(testFormatSettings) + formatContext: formatting.getFormatContext(testFormatSettings, notImplementedHost) }; const diagnostics = languageService.getSuggestionDiagnostics(f.path); diff --git a/src/testRunner/unittests/services/extract/helpers.ts b/src/testRunner/unittests/services/extract/helpers.ts index a998bf6f510..a4787529994 100644 --- a/src/testRunner/unittests/services/extract/helpers.ts +++ b/src/testRunner/unittests/services/extract/helpers.ts @@ -102,7 +102,7 @@ namespace ts { startPosition: selectionRange.pos, endPosition: selectionRange.end, host: notImplementedHost, - formatContext: formatting.getFormatContext(testFormatSettings), + formatContext: formatting.getFormatContext(testFormatSettings, notImplementedHost), preferences: emptyOptions, }; const rangeToExtract = refactor.extractSymbol.getRangeToExtract(sourceFile, createTextSpanFromRange(selectionRange)); @@ -164,7 +164,7 @@ namespace ts { startPosition: selectionRange.pos, endPosition: selectionRange.end, host: notImplementedHost, - formatContext: formatting.getFormatContext(testFormatSettings), + formatContext: formatting.getFormatContext(testFormatSettings, notImplementedHost), preferences: emptyOptions, }; const rangeToExtract = refactor.extractSymbol.getRangeToExtract(sourceFile, createTextSpanFromRange(selectionRange)); diff --git a/src/testRunner/unittests/services/textChanges.ts b/src/testRunner/unittests/services/textChanges.ts index 2d76b64696d..5c3a103c238 100644 --- a/src/testRunner/unittests/services/textChanges.ts +++ b/src/testRunner/unittests/services/textChanges.ts @@ -19,7 +19,7 @@ namespace ts { const newLineCharacter = getNewLineCharacter(printerOptions); function getRuleProvider(placeOpenBraceOnNewLineForFunctions: boolean): formatting.FormatContext { - return formatting.getFormatContext(placeOpenBraceOnNewLineForFunctions ? { ...testFormatSettings, placeOpenBraceOnNewLineForFunctions: true } : testFormatSettings); + return formatting.getFormatContext(placeOpenBraceOnNewLineForFunctions ? { ...testFormatSettings, placeOpenBraceOnNewLineForFunctions: true } : testFormatSettings, notImplementedHost); } // validate that positions that were recovered from the printed text actually match positions that will be created if the same text is parsed. diff --git a/tests/cases/fourslash/fourslash.ts b/tests/cases/fourslash/fourslash.ts index d9b47adc1fb..d7d4935118d 100644 --- a/tests/cases/fourslash/fourslash.ts +++ b/tests/cases/fourslash/fourslash.ts @@ -394,6 +394,8 @@ declare namespace FourSlashInterface { noMoveToNewFile(): void; generateTypes(...options: GenerateTypesOptions[]): void; + + organizeImports(newContent: string): void; } class edit { backspace(count?: number): void; diff --git a/tests/cases/fourslash/organizeImportsNoFormatOptions.ts b/tests/cases/fourslash/organizeImportsNoFormatOptions.ts new file mode 100644 index 00000000000..24626441222 --- /dev/null +++ b/tests/cases/fourslash/organizeImportsNoFormatOptions.ts @@ -0,0 +1,22 @@ +/// + +// #38548 + +////import { +//// stat, +//// statSync, +////} from "fs"; +////export function fakeFn() { +//// stat; +//// statSync; +////} + +format.setFormatOptions({}); + +// Default newline is carriage return. +// See `getNewLineOrDefaultFromHost()` in services/utilities.ts. +verify.organizeImports( +`import {\r\nstat,\r\nstatSync\r\n} from "fs";\r\nexport function fakeFn() { + stat; + statSync; +}`); From 7ba0a6592d159999cb4a9dcb91fca0e7765bbbf1 Mon Sep 17 00:00:00 2001 From: Anders Hejlsberg Date: Tue, 19 May 2020 13:42:30 -0700 Subject: [PATCH 12/15] No contextual types from circular mapped type properties (#38653) * No contextual types from circular mapped type properties * Add regression test --- src/compiler/checker.ts | 6 ++- .../reference/circularContextualMappedType.js | 32 ++++++++++++ .../circularContextualMappedType.symbols | 51 +++++++++++++++++++ .../circularContextualMappedType.types | 50 ++++++++++++++++++ .../compiler/circularContextualMappedType.ts | 20 ++++++++ 5 files changed, 158 insertions(+), 1 deletion(-) create mode 100644 tests/baselines/reference/circularContextualMappedType.js create mode 100644 tests/baselines/reference/circularContextualMappedType.symbols create mode 100644 tests/baselines/reference/circularContextualMappedType.types create mode 100644 tests/cases/compiler/circularContextualMappedType.ts diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index fcd96daac8f..8b8a12fa723 100644 --- a/src/compiler/checker.ts +++ b/src/compiler/checker.ts @@ -22469,6 +22469,10 @@ namespace ts { } } + function isCircularMappedProperty(symbol: Symbol) { + return !!(getCheckFlags(symbol) & CheckFlags.Mapped && !(symbol).type && findResolutionCycleStartIndex(symbol, TypeSystemPropertyName.Type) >= 0); + } + function getTypeOfPropertyOfContextualType(type: Type, name: __String) { return mapType(type, t => { if (isGenericMappedType(t)) { @@ -22482,7 +22486,7 @@ namespace ts { else if (t.flags & TypeFlags.StructuredType) { const prop = getPropertyOfType(t, name); if (prop) { - return getTypeOfSymbol(prop); + return isCircularMappedProperty(prop) ? undefined : getTypeOfSymbol(prop); } if (isTupleType(t)) { const restType = getRestTypeOfTupleType(t); diff --git a/tests/baselines/reference/circularContextualMappedType.js b/tests/baselines/reference/circularContextualMappedType.js new file mode 100644 index 00000000000..7bd989c843a --- /dev/null +++ b/tests/baselines/reference/circularContextualMappedType.js @@ -0,0 +1,32 @@ +//// [circularContextualMappedType.ts] +type Func = () => T; + +type Mapped = { [K in keyof T]: Func }; + +declare function reproduce(options: number): void; +declare function reproduce(options: Mapped): T + +reproduce({ + name: () => { return 123 } +}); + +reproduce({ + name() { return 123 } +}); + +reproduce({ + name: function () { return 123 } +}); + + +//// [circularContextualMappedType.js] +"use strict"; +reproduce({ + name: function () { return 123; } +}); +reproduce({ + name: function () { return 123; } +}); +reproduce({ + name: function () { return 123; } +}); diff --git a/tests/baselines/reference/circularContextualMappedType.symbols b/tests/baselines/reference/circularContextualMappedType.symbols new file mode 100644 index 00000000000..445906d48c1 --- /dev/null +++ b/tests/baselines/reference/circularContextualMappedType.symbols @@ -0,0 +1,51 @@ +=== tests/cases/compiler/circularContextualMappedType.ts === +type Func = () => T; +>Func : Symbol(Func, Decl(circularContextualMappedType.ts, 0, 0)) +>T : Symbol(T, Decl(circularContextualMappedType.ts, 0, 10)) +>T : Symbol(T, Decl(circularContextualMappedType.ts, 0, 10)) + +type Mapped = { [K in keyof T]: Func }; +>Mapped : Symbol(Mapped, Decl(circularContextualMappedType.ts, 0, 23)) +>T : Symbol(T, Decl(circularContextualMappedType.ts, 2, 12)) +>K : Symbol(K, Decl(circularContextualMappedType.ts, 2, 20)) +>T : Symbol(T, Decl(circularContextualMappedType.ts, 2, 12)) +>Func : Symbol(Func, Decl(circularContextualMappedType.ts, 0, 0)) +>T : Symbol(T, Decl(circularContextualMappedType.ts, 2, 12)) +>K : Symbol(K, Decl(circularContextualMappedType.ts, 2, 20)) + +declare function reproduce(options: number): void; +>reproduce : Symbol(reproduce, Decl(circularContextualMappedType.ts, 2, 48), Decl(circularContextualMappedType.ts, 4, 50)) +>options : Symbol(options, Decl(circularContextualMappedType.ts, 4, 27)) + +declare function reproduce(options: Mapped): T +>reproduce : Symbol(reproduce, Decl(circularContextualMappedType.ts, 2, 48), Decl(circularContextualMappedType.ts, 4, 50)) +>T : Symbol(T, Decl(circularContextualMappedType.ts, 5, 27)) +>options : Symbol(options, Decl(circularContextualMappedType.ts, 5, 30)) +>Mapped : Symbol(Mapped, Decl(circularContextualMappedType.ts, 0, 23)) +>T : Symbol(T, Decl(circularContextualMappedType.ts, 5, 27)) +>T : Symbol(T, Decl(circularContextualMappedType.ts, 5, 27)) + +reproduce({ +>reproduce : Symbol(reproduce, Decl(circularContextualMappedType.ts, 2, 48), Decl(circularContextualMappedType.ts, 4, 50)) + + name: () => { return 123 } +>name : Symbol(name, Decl(circularContextualMappedType.ts, 7, 11)) + +}); + +reproduce({ +>reproduce : Symbol(reproduce, Decl(circularContextualMappedType.ts, 2, 48), Decl(circularContextualMappedType.ts, 4, 50)) + + name() { return 123 } +>name : Symbol(name, Decl(circularContextualMappedType.ts, 11, 11)) + +}); + +reproduce({ +>reproduce : Symbol(reproduce, Decl(circularContextualMappedType.ts, 2, 48), Decl(circularContextualMappedType.ts, 4, 50)) + + name: function () { return 123 } +>name : Symbol(name, Decl(circularContextualMappedType.ts, 15, 11)) + +}); + diff --git a/tests/baselines/reference/circularContextualMappedType.types b/tests/baselines/reference/circularContextualMappedType.types new file mode 100644 index 00000000000..d9439215d28 --- /dev/null +++ b/tests/baselines/reference/circularContextualMappedType.types @@ -0,0 +1,50 @@ +=== tests/cases/compiler/circularContextualMappedType.ts === +type Func = () => T; +>Func : Func + +type Mapped = { [K in keyof T]: Func }; +>Mapped : Mapped + +declare function reproduce(options: number): void; +>reproduce : { (options: number): void; (options: Mapped): T; } +>options : number + +declare function reproduce(options: Mapped): T +>reproduce : { (options: number): void; (options: Mapped): T; } +>options : Mapped + +reproduce({ +>reproduce({ name: () => { return 123 }}) : { name: number; } +>reproduce : { (options: number): void; (options: Mapped): T; } +>{ name: () => { return 123 }} : { name: () => number; } + + name: () => { return 123 } +>name : () => number +>() => { return 123 } : () => number +>123 : 123 + +}); + +reproduce({ +>reproduce({ name() { return 123 }}) : { name: number; } +>reproduce : { (options: number): void; (options: Mapped): T; } +>{ name() { return 123 }} : { name(): number; } + + name() { return 123 } +>name : () => number +>123 : 123 + +}); + +reproduce({ +>reproduce({ name: function () { return 123 }}) : { name: number; } +>reproduce : { (options: number): void; (options: Mapped): T; } +>{ name: function () { return 123 }} : { name: () => number; } + + name: function () { return 123 } +>name : () => number +>function () { return 123 } : () => number +>123 : 123 + +}); + diff --git a/tests/cases/compiler/circularContextualMappedType.ts b/tests/cases/compiler/circularContextualMappedType.ts new file mode 100644 index 00000000000..4c982cd6fca --- /dev/null +++ b/tests/cases/compiler/circularContextualMappedType.ts @@ -0,0 +1,20 @@ +// @strict: true + +type Func = () => T; + +type Mapped = { [K in keyof T]: Func }; + +declare function reproduce(options: number): void; +declare function reproduce(options: Mapped): T + +reproduce({ + name: () => { return 123 } +}); + +reproduce({ + name() { return 123 } +}); + +reproduce({ + name: function () { return 123 } +}); From 7ec467e270699aba9978cad5d672ca5718ee47c2 Mon Sep 17 00:00:00 2001 From: Jack Works Date: Wed, 20 May 2020 05:29:49 +0800 Subject: [PATCH 13/15] fix: extract const in jsx (#37912) * fix: extract const in jsx * Update src/services/refactors/extractSymbol.ts Co-authored-by: Andrew Branch * Update src/services/refactors/extractSymbol.ts Co-authored-by: Andrew Branch Co-authored-by: Andrew Branch --- src/services/refactors/extractSymbol.ts | 21 ++++++++++++++++----- tests/cases/fourslash/extract-const4.ts | 21 +++++++++++++++++++++ 2 files changed, 37 insertions(+), 5 deletions(-) create mode 100644 tests/cases/fourslash/extract-const4.ts diff --git a/src/services/refactors/extractSymbol.ts b/src/services/refactors/extractSymbol.ts index 7858012a0bb..8c6c8f6fc69 100644 --- a/src/services/refactors/extractSymbol.ts +++ b/src/services/refactors/extractSymbol.ts @@ -28,7 +28,7 @@ namespace ts.refactor.extractSymbol { const usedConstantNames: Map = createMap(); let i = 0; - for (const {functionExtraction, constantExtraction} of extractions) { + for (const { functionExtraction, constantExtraction } of extractions) { // Skip these since we don't have a way to report errors yet if (functionExtraction.errors.length === 0) { // Don't issue refactorings with duplicated names. @@ -1103,7 +1103,12 @@ namespace ts.refactor.extractSymbol { changeTracker.delete(context.file, node.parent); } else { - const localReference = createIdentifier(localNameText); + let localReference: Expression = createIdentifier(localNameText); + // When extract to a new variable in JSX content, need to wrap a {} out of the new variable + // or it will become a plain text + if (isInJSXContent(node)) { + localReference = createJsxExpression(/*dotDotDotToken*/ undefined, localReference); + } changeTracker.replaceNode(context.file, node, localReference); } } @@ -1115,6 +1120,12 @@ namespace ts.refactor.extractSymbol { const renameLocation = getRenameLocation(edits, renameFilename, localNameText, /*isDeclaredBeforeUse*/ true); return { renameFilename, renameLocation, edits }; + function isInJSXContent(node: Node) { + if (!isJsxElement(node)) return false; + if (isJsxElement(node.parent)) return true; + return false; + } + function transformFunctionInitializerAndType(variableType: TypeNode | undefined, initializer: Expression): { variableType: TypeNode | undefined, initializer: Expression } { // If no contextual type exists there is nothing to transfer to the function signature if (variableType === undefined) return { variableType, initializer }; @@ -1215,8 +1226,8 @@ namespace ts.refactor.extractSymbol { } function compareTypesByDeclarationOrder( - {type: type1, declaration: declaration1}: {type: Type, declaration?: Declaration}, - {type: type2, declaration: declaration2}: {type: Type, declaration?: Declaration}) { + { type: type1, declaration: declaration1 }: { type: Type, declaration?: Declaration }, + { type: type2, declaration: declaration2 }: { type: Type, declaration?: Declaration }) { return compareProperties(declaration1, declaration2, "pos", compareValues) || compareStringsCaseSensitive( @@ -1621,7 +1632,7 @@ namespace ts.refactor.extractSymbol { // a lot of properties, each of which the walker will visit. Unfortunately, the // solution isn't as trivial as filtering to user types because of (e.g.) Array. const symbolWalker = checker.getSymbolWalker(() => (cancellationToken.throwIfCancellationRequested(), true)); - const {visitedTypes} = symbolWalker.walkType(type); + const { visitedTypes } = symbolWalker.walkType(type); for (const visitedType of visitedTypes) { if (visitedType.isTypeParameter()) { diff --git a/tests/cases/fourslash/extract-const4.ts b/tests/cases/fourslash/extract-const4.ts new file mode 100644 index 00000000000..4130a168fdb --- /dev/null +++ b/tests/cases/fourslash/extract-const4.ts @@ -0,0 +1,21 @@ +/// + +// GH#35372 + +// @jsx: preserve +// @filename: main.tsx +////function foo() { +//// return
/*a*/content/*b*/
; +////} + +goTo.select("a", "b"); +edit.applyRefactor({ + refactorName: "Extract Symbol", + actionName: "constant_scope_0", + actionDescription: "Extract to constant in enclosing scope", + newContent: + `function foo() { + const /*RENAME*/newLocal = content; + return
{newLocal}
; +}` +}); From 0e4f1cb407055143f524162c76ab6cbaffae8f33 Mon Sep 17 00:00:00 2001 From: csigs Date: Tue, 19 May 2020 22:11:18 +0000 Subject: [PATCH 14/15] LEGO: check in for master to temporary branch. --- .../diagnosticMessages.generated.json.lcl | 14 +++++++++++++- .../diagnosticMessages.generated.json.lcl | 12 ++++++++++++ .../diagnosticMessages.generated.json.lcl | 12 ++++++++++++ .../diagnosticMessages.generated.json.lcl | 12 ++++++++++++ 4 files changed, 49 insertions(+), 1 deletion(-) diff --git a/src/loc/lcl/cht/diagnosticMessages/diagnosticMessages.generated.json.lcl b/src/loc/lcl/cht/diagnosticMessages/diagnosticMessages.generated.json.lcl index e1f2c14f0df..d7a5d35ce14 100644 --- a/src/loc/lcl/cht/diagnosticMessages/diagnosticMessages.generated.json.lcl +++ b/src/loc/lcl/cht/diagnosticMessages/diagnosticMessages.generated.json.lcl @@ -51,6 +51,9 @@ + + + @@ -7216,7 +7219,7 @@ - + @@ -8649,6 +8652,9 @@ + + + @@ -8664,6 +8670,9 @@ + + + @@ -10395,6 +10404,9 @@ + + + diff --git a/src/loc/lcl/esn/diagnosticMessages/diagnosticMessages.generated.json.lcl b/src/loc/lcl/esn/diagnosticMessages/diagnosticMessages.generated.json.lcl index 9fcdd9893dc..7f73f4d483c 100644 --- a/src/loc/lcl/esn/diagnosticMessages/diagnosticMessages.generated.json.lcl +++ b/src/loc/lcl/esn/diagnosticMessages/diagnosticMessages.generated.json.lcl @@ -60,6 +60,9 @@ + + + @@ -8661,6 +8664,9 @@ + + + @@ -8676,6 +8682,9 @@ + + + @@ -10407,6 +10416,9 @@ + + + diff --git a/src/loc/lcl/jpn/diagnosticMessages/diagnosticMessages.generated.json.lcl b/src/loc/lcl/jpn/diagnosticMessages/diagnosticMessages.generated.json.lcl index 08ef0b07536..b40ad8e476a 100644 --- a/src/loc/lcl/jpn/diagnosticMessages/diagnosticMessages.generated.json.lcl +++ b/src/loc/lcl/jpn/diagnosticMessages/diagnosticMessages.generated.json.lcl @@ -51,6 +51,9 @@ + + + @@ -8649,6 +8652,9 @@ + + + @@ -8664,6 +8670,9 @@ + + + @@ -10395,6 +10404,9 @@ + + + diff --git a/src/loc/lcl/kor/diagnosticMessages/diagnosticMessages.generated.json.lcl b/src/loc/lcl/kor/diagnosticMessages/diagnosticMessages.generated.json.lcl index 1317b20beac..c0e83463456 100644 --- a/src/loc/lcl/kor/diagnosticMessages/diagnosticMessages.generated.json.lcl +++ b/src/loc/lcl/kor/diagnosticMessages/diagnosticMessages.generated.json.lcl @@ -51,6 +51,9 @@ + + + @@ -8649,6 +8652,9 @@ + + + @@ -8664,6 +8670,9 @@ + + + @@ -10395,6 +10404,9 @@ + + + From 5f597e69b2e3b48d788cb548df40bcb703c8adb1 Mon Sep 17 00:00:00 2001 From: Wesley Wigham Date: Tue, 19 May 2020 15:54:02 -0700 Subject: [PATCH 15/15] Support naming tuple members (#38234) * Initial draft of named tuple members * Show tuple labels and documentation in completions * Swap allowed syntax to parameter-like * Add quickfix for labeled tuple syntax mistakes * Add refactoring to convert list of signatures to single overload * Fix small bug in visitor verification * Signature help for rest parameters which are unions of tuples are displayed as seperate entries now * Expand sanity check test cases in conformance suite * Add tests and code for preserving tuple names through spreads where possible * More refactoring tests, some comment preservation and some fixed formatting of multiline tuples * Handle missing parameter named in isValidDeclarationForTupleLabel * Minor text fixes --- src/compiler/checker.ts | 252 ++++++++++---- src/compiler/diagnosticMessages.json | 24 ++ src/compiler/emitter.ts | 20 +- src/compiler/factoryPublic.ts | 43 ++- src/compiler/parser.ts | 33 +- src/compiler/transformers/declarations.ts | 4 + src/compiler/types.ts | 22 +- src/compiler/visitorPublic.ts | 10 +- .../codefixes/fixIncorrectNamedTupleSyntax.ts | 52 +++ src/services/formatting/smartIndenter.ts | 2 +- .../convertOverloadListToSingleSignature.ts | 219 ++++++++++++ src/services/refactors/extractType.ts | 5 + src/services/services.ts | 9 +- src/services/signatureHelp.ts | 71 +++- src/services/symbolDisplay.ts | 8 + src/services/tsconfig.json | 2 + src/testRunner/unittests/printer.ts | 4 +- ...xpressions.parsesCorrectly.tupleType0.json | 2 +- ...xpressions.parsesCorrectly.tupleType1.json | 2 +- ...xpressions.parsesCorrectly.tupleType2.json | 2 +- ...xpressions.parsesCorrectly.tupleType3.json | 2 +- ...sCorrectly.tupleTypeWithTrailingComma.json | 2 +- .../reference/api/tsserverlibrary.d.ts | 327 +++++++++--------- tests/baselines/reference/api/typescript.d.ts | 327 +++++++++--------- .../reference/genericRestParameters1.types | 4 +- .../reference/genericRestParameters2.types | 8 +- .../genericRestParameters3.errors.txt | 20 +- .../reference/genericRestTypes.errors.txt | 4 +- .../reference/genericRestTypes.types | 2 +- .../getParameterNameAtPosition.types | 2 +- .../instantiateContextualTypes.types | 2 +- ...WithTupleArgsHasCorrectAssignability.types | 4 +- .../baselines/reference/namedTupleMembers.js | 140 ++++++++ .../reference/namedTupleMembers.symbols | 201 +++++++++++ .../reference/namedTupleMembers.types | 204 +++++++++++ .../namedTupleMembersErrors.errors.txt | 55 +++ .../reference/namedTupleMembersErrors.js | 37 ++ .../reference/namedTupleMembersErrors.symbols | 33 ++ .../reference/namedTupleMembersErrors.types | 31 ++ .../reference/parameterListAsTupleType.types | 12 +- ...edFunctionInferenceWithTypeParameter.types | 2 +- .../reference/ramdaToolsNoInfinite.types | 6 +- .../restTuplesFromContextualTypes.errors.txt | 8 +- .../restTuplesFromContextualTypes.types | 18 +- .../reference/strictBindCallApply1.errors.txt | 40 ++- .../types/tuple/named/namedTupleMembers.ts | 79 +++++ .../tuple/named/namedTupleMembersErrors.ts | 20 ++ .../codeFixIncorrectNamedTupleSyntax1.ts | 10 + .../codeFixIncorrectNamedTupleSyntax2.ts | 10 + .../completionsElementAccessNumeric.ts | 30 ++ .../fourslash/contextuallyTypedParameters.ts | 8 +- tests/cases/fourslash/namedTupleMembers.ts | 5 + .../refactorOverloadListToSingleSignature1.ts | 14 + .../refactorOverloadListToSingleSignature2.ts | 49 +++ .../refactorOverloadListToSingleSignature3.ts | 19 + .../refactorOverloadListToSingleSignature4.ts | 23 ++ .../refactorOverloadListToSingleSignature5.ts | 23 ++ .../refactorOverloadListToSingleSignature6.ts | 18 + .../refactorOverloadListToSingleSignature7.ts | 18 + .../refactorOverloadListToSingleSignature8.ts | 18 + tests/cases/fourslash/restArgType.ts | 6 +- .../signatureHelpExpandedRestTuples.ts | 36 ++ 62 files changed, 2175 insertions(+), 488 deletions(-) create mode 100644 src/services/codefixes/fixIncorrectNamedTupleSyntax.ts create mode 100644 src/services/refactors/convertOverloadListToSingleSignature.ts create mode 100644 tests/baselines/reference/namedTupleMembers.js create mode 100644 tests/baselines/reference/namedTupleMembers.symbols create mode 100644 tests/baselines/reference/namedTupleMembers.types create mode 100644 tests/baselines/reference/namedTupleMembersErrors.errors.txt create mode 100644 tests/baselines/reference/namedTupleMembersErrors.js create mode 100644 tests/baselines/reference/namedTupleMembersErrors.symbols create mode 100644 tests/baselines/reference/namedTupleMembersErrors.types create mode 100644 tests/cases/conformance/types/tuple/named/namedTupleMembers.ts create mode 100644 tests/cases/conformance/types/tuple/named/namedTupleMembersErrors.ts create mode 100644 tests/cases/fourslash/codeFixIncorrectNamedTupleSyntax1.ts create mode 100644 tests/cases/fourslash/codeFixIncorrectNamedTupleSyntax2.ts create mode 100644 tests/cases/fourslash/completionsElementAccessNumeric.ts create mode 100644 tests/cases/fourslash/namedTupleMembers.ts create mode 100644 tests/cases/fourslash/refactorOverloadListToSingleSignature1.ts create mode 100644 tests/cases/fourslash/refactorOverloadListToSingleSignature2.ts create mode 100644 tests/cases/fourslash/refactorOverloadListToSingleSignature3.ts create mode 100644 tests/cases/fourslash/refactorOverloadListToSingleSignature4.ts create mode 100644 tests/cases/fourslash/refactorOverloadListToSingleSignature5.ts create mode 100644 tests/cases/fourslash/refactorOverloadListToSingleSignature6.ts create mode 100644 tests/cases/fourslash/refactorOverloadListToSingleSignature7.ts create mode 100644 tests/cases/fourslash/refactorOverloadListToSingleSignature8.ts create mode 100644 tests/cases/fourslash/signatureHelpExpandedRestTuples.ts diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts index 8b8a12fa723..7bd58c379ea 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] + ); + } } - const tupleTypeNode = createTupleTypeNode(tupleConstituentNodes); + 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 = 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; + 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); + } } 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 2dfabe540ad..df3192652ac 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 dc4b9ad5f2f..b2325d2e3e6 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 ac1dcbb0435..030b527b30b 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 fdc1e8246ac..9754cdf64d3 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 1e9aa130f68..00d01ec9508 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 aef4364a6b5..0c45dca9529 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 b21af6186db..544be6d6b4d 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 00000000000..f1c3d351606 --- /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 5539a8e30cb..23011643811 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 00000000000..3c747fb3736 --- /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 813ee186f0f..560fc5deb68 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 6668ee14f37..28cf22ec473 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 0f168d65e7b..d2244e3f894 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 138ed53c50d..11f20195131 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 bbe3956e173..f3e6e5ce456 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 d04bf65603c..e96aba36749 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 61631cabce4..8bce1081376 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 c8373fe5e87..dc98f9164e7 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 78875855840..f6da4118779 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 c1b537d2945..08c3a7dbede 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 b859519b8da..da597813899 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 6ea68e933ab..e89d9461ff3 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 d2c5d5ce805..2213fd4be6a 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 c9067b38c97..1503f118459 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 16798357a92..ec17e786252 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 9e3e9d97de4..4b7032bb13b 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 c0fcb85e492..0df6490b6a2 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 8d06f4a0773..d46f3035481 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 f722d7e5f95..1e0c9212901 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 b5317b6f756..d6c380cb7ac 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 27d8e5a4cb4..435bdc4c4cf 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 00000000000..9095259eec9 --- /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 00000000000..a7d40391c8f --- /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 00000000000..14badf44552 --- /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 00000000000..19e40ba9371 --- /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 00000000000..5b277b3efe0 --- /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 00000000000..613bf86cddd --- /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 00000000000..3285a453592 --- /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 3bb861f5a1d..0412ab7f75f 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 94eabc48b8f..3f49d1ac95a 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 229bdfe4c40..d6ac7f2da1e 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 5f2c299735b..5c3d13b87e4 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 6dd2a6d90cb..b43299fc6dd 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 cd30931bcfe..ee1718db34c 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 00000000000..9846c4f5b0f --- /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 00000000000..75eb3d3deca --- /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 00000000000..08c8234e634 --- /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 00000000000..9a7f7590d96 --- /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 00000000000..dbb330a7ae9 --- /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 f600180c087..b19ec282eb6 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 00000000000..034570e715f --- /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 00000000000..b2be8adb43d --- /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 00000000000..8259dfb79b8 --- /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 00000000000..1de08f5852e --- /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 00000000000..d42130fc0f6 --- /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 00000000000..d8aabb038fd --- /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 00000000000..0c3c0143f26 --- /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 00000000000..90a638be021 --- /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 00000000000..a540e8544a5 --- /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 69601c14ccf..057786489bf 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 00000000000..2808a8eb88e --- /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, + }, +);