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

@@ -4564,17 +4564,32 @@ namespace ts {
                             const tupleConstituentNodes = mapToTypeNodes(typeArguments.slice(0, arity), context);
                             const hasRestElement = (<TupleType>type.target).hasRestElement;
                             if (tupleConstituentNodes) {
-                                for (let i = (<TupleType>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 >= (<TupleType>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 = (<TupleType>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 (<TupleType>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 (<TupleType>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 && (<TupleTypeNode>node).elementTypes.length === 1;
+            return node.kind === SyntaxKind.TupleType && (<TupleTypeNode>node).elements.length === 1;
         }
 
         function getImpliedConstraint(type: Type, checkNode: TypeNode, extendsNode: TypeNode): Type | undefined {
-            return isUnaryTupleTypeNode(checkNode) && isUnaryTupleTypeNode(extendsNode) ? getImpliedConstraint(type, (<TupleTypeNode>checkNode).elementTypes[0], (<TupleTypeNode>extendsNode).elementTypes[0]) :
+            return isUnaryTupleTypeNode(checkNode) && isUnaryTupleTypeNode(extendsNode) ? getImpliedConstraint(type, (<TupleTypeNode>checkNode).elements[0], (<TupleTypeNode>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 (<TypeOperatorNode>node).operator !== SyntaxKind.UniqueKeyword && mayResolveTypeAlias((<TypeOperatorNode>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((<ParenthesizedTypeNode | OptionalTypeNode | JSDocTypeReferencingNode>node).type);
+                    return mayResolveTypeAlias((<ParenthesizedTypeNode | OptionalTypeNode | JSDocTypeReferencingNode | NamedTupleMember>node).type);
                 case SyntaxKind.RestType:
                     return (<RestTypeNode>node).type.kind !== SyntaxKind.ArrayType || mayResolveTypeAlias((<ArrayTypeNode>(<RestTypeNode>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(<JSDocNullableType>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((<ParenthesizedTypeNode | JSDocTypeReferencingNode | JSDocTypeExpression>node).type);
+                    return getTypeFromTypeNode((<ParenthesizedTypeNode | JSDocTypeReferencingNode | JSDocTypeExpression | NamedTupleMember>node).type);
                 case SyntaxKind.RestType:
                     return getElementTypeOfArrayType(getTypeFromTypeNode((<RestTypeNode>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 = <SyntheticExpression>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(<TypeReference>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 = (<TupleType>(<TypeReference>restType).target).associatedNames;
+                const associatedNames = (<TupleType>(<TypeReference>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 = (<TupleType>(<TypeReference>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([(<ConditionalTypeNode>node).trueType, (<ConditionalTypeNode>node).falseType]);
 
                     case SyntaxKind.ParenthesizedType:
+                    case SyntaxKind.NamedTupleMember:
                         return getEntityNameForDecoratorMetadata((<ParenthesizedTypeNode>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(<InferTypeNode>node);
                 case SyntaxKind.ImportType:
                     return checkImportType(<ImportTypeNode>node);
+                case SyntaxKind.NamedTupleMember:
+                    return checkNamedTupleMember(<NamedTupleMember>node);
                 case SyntaxKind.JSDocAugmentsTag:
                     return checkJSDocAugmentsTag(node as JSDocAugmentsTag);
                 case SyntaxKind.JSDocImplementsTag:

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",

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);

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<SyntaxKind.DotDotDotToken> | undefined, name: Identifier, questionToken: Token<SyntaxKind.QuestionToken> | undefined, type: TypeNode) {
+        const node = <NamedTupleMember>createSynthesizedNode(SyntaxKind.NamedTupleMember);
+        node.dotDotDotToken = dotDotDotToken;
+        node.name = name;
+        node.questionToken = questionToken;
+        node.type = type;
+        return node;
+    }
+
+    export function updateNamedTupleMember(node: NamedTupleMember, dotDotDotToken: Token<SyntaxKind.DotDotDotToken> | undefined, name: Identifier, questionToken: Token<SyntaxKind.QuestionToken> | 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 <ThisTypeNode>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) {

src/compiler/parser.ts

@@ -179,7 +179,7 @@ namespace ts {
             case SyntaxKind.ArrayType:
                 return visitNode(cbNode, (<ArrayTypeNode>node).elementType);
             case SyntaxKind.TupleType:
-                return visitNodes(cbNode, cbNodes, (<TupleTypeNode>node).elementTypes);
+                return visitNodes(cbNode, cbNodes, (<TupleTypeNode>node).elements);
             case SyntaxKind.UnionType:
             case SyntaxKind.IntersectionType:
                 return visitNodes(cbNode, cbNodes, (<UnionOrIntersectionTypeNode>node).types);
@@ -207,6 +207,11 @@ namespace ts {
                     visitNode(cbNode, (<MappedTypeNode>node).type);
             case SyntaxKind.LiteralType:
                 return visitNode(cbNode, (<LiteralTypeNode>node).literal);
+            case SyntaxKind.NamedTupleMember:
+                return visitNode(cbNode, (<NamedTupleMember>node).dotDotDotToken) ||
+                    visitNode(cbNode, (<NamedTupleMember>node).name) ||
+                    visitNode(cbNode, (<NamedTupleMember>node).questionToken) ||
+                    visitNode(cbNode, (<NamedTupleMember>node).type);
             case SyntaxKind.ObjectBindingPattern:
             case SyntaxKind.ArrayBindingPattern:
                 return visitNodes(cbNode, cbNodes, (<BindingPattern>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 = <NamedTupleMember>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 = <TupleTypeNode>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);
         }
 

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<T extends Node>(returnValue: T | undefined): T | undefined {

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<TypeNode>;
+        elements: NodeArray<TypeNode | NamedTupleMember>;
+    }
+
+    export interface NamedTupleMember extends TypeNode, JSDocContainer, Declaration {
+        kind: SyntaxKind.NamedTupleMember;
+        dotDotDotToken?: Token<SyntaxKind.DotDotDotToken>;
+        name: Identifier;
+        questionToken?: Token<SyntaxKind.QuestionToken>;
+        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,

src/compiler/visitorPublic.ts

@@ -480,7 +480,7 @@ namespace ts {
 
             case SyntaxKind.TupleType:
                 return updateTupleTypeNode((<TupleTypeNode>node),
-                    nodesVisitor((<TupleTypeNode>node).elementTypes, visitor, isTypeNode));
+                    nodesVisitor((<TupleTypeNode>node).elements, visitor, isTypeNode));
 
             case SyntaxKind.OptionalType:
                 return updateOptionalTypeNode((<OptionalTypeNode>node),
@@ -517,6 +517,14 @@ namespace ts {
                     (<ImportTypeNode>node).isTypeOf
                 );
 
+            case SyntaxKind.NamedTupleMember:
+                return updateNamedTupleMember(<NamedTupleMember>node,
+                    visitNode((<NamedTupleMember>node).dotDotDotToken, visitor, isToken),
+                    visitNode((<NamedTupleMember>node).name, visitor, isIdentifier),
+                    visitNode((<NamedTupleMember>node).questionToken, visitor, isToken),
+                    visitNode((<NamedTupleMember>node).type, visitor, isTypeNode),
+                );
+
             case SyntaxKind.ParenthesizedType:
                 return updateParenthesizedType(<ParenthesizedTypeNode>node,
                     visitNode((<ParenthesizedTypeNode>node).type, visitor, isTypeNode));

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);
+    }
+}

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

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<ParameterDeclaration> {
+            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;
+    }
+}

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);
         }
     }

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;
         }

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 {

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 ||

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",

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)
             ));
         });

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

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,

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,

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,

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,

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<TypeNode>;
+        elements: NodeArray<TypeNode | NamedTupleMember>;
+    }
+    export interface NamedTupleMember extends TypeNode, JSDocContainer, Declaration {
+        kind: SyntaxKind.NamedTupleMember;
+        dotDotDotToken?: Token<SyntaxKind.DotDotDotToken>;
+        name: Identifier;
+        questionToken?: Token<SyntaxKind.QuestionToken>;
+        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<TypeElement>): 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<SyntaxKind.DotDotDotToken> | undefined, name: Identifier, questionToken: Token<SyntaxKind.QuestionToken> | undefined, type: TypeNode): NamedTupleMember;
+    function updateNamedTupleMember(node: NamedTupleMember, dotDotDotToken: Token<SyntaxKind.DotDotDotToken> | undefined, name: Identifier, questionToken: Token<SyntaxKind.QuestionToken> | undefined, type: TypeNode): NamedTupleMember;
     function createThisTypeNode(): ThisTypeNode;
     function createTypeOperatorNode(type: TypeNode): TypeOperatorNode;
     function createTypeOperatorNode(operator: SyntaxKind.KeyOfKeyword | SyntaxKind.UniqueKeyword | SyntaxKind.ReadonlyKeyword, type: TypeNode): TypeOperatorNode;

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<TypeNode>;
+        elements: NodeArray<TypeNode | NamedTupleMember>;
+    }
+    export interface NamedTupleMember extends TypeNode, JSDocContainer, Declaration {
+        kind: SyntaxKind.NamedTupleMember;
+        dotDotDotToken?: Token<SyntaxKind.DotDotDotToken>;
+        name: Identifier;
+        questionToken?: Token<SyntaxKind.QuestionToken>;
+        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<TypeElement>): 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<SyntaxKind.DotDotDotToken> | undefined, name: Identifier, questionToken: Token<SyntaxKind.QuestionToken> | undefined, type: TypeNode): NamedTupleMember;
+    function updateNamedTupleMember(node: NamedTupleMember, dotDotDotToken: Token<SyntaxKind.DotDotDotToken> | undefined, name: Identifier, questionToken: Token<SyntaxKind.QuestionToken> | undefined, type: TypeNode): NamedTupleMember;
     function createThisTypeNode(): ThisTypeNode;
     function createTypeOperatorNode(type: TypeNode): TypeOperatorNode;
     function createTypeOperatorNode(operator: SyntaxKind.KeyOfKeyword | SyntaxKind.UniqueKeyword | SyntaxKind.ReadonlyKeyword, type: TypeNode): TypeOperatorNode;

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<new (x: number, y: string, z: boolean) => void>;
->T03 : [number, string, boolean]
+>T03 : [x: number, y: string, z: boolean]
 >x : number
 >y : string
 >z : boolean

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<new (x: number, y: string, ...z: boolean[]) => 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 Function> = 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
 

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<any>) => void'.
 tests/cases/conformance/types/rest/genericRestParameters3.ts(37,21): error TS2345: Argument of type '<T extends any[]>(cb: (...args: T) => void) => void' is not assignable to parameter of type '(...args: CoolArray<any>) => void'.
   Types of parameters 'cb' and 'args' are incompatible.
-    Property '0' is missing in type 'CoolArray<any>' but required in type '[(...args: any[]) => void]'.
+    Property '0' is missing in type 'CoolArray<any>' 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<number>'.
   Property 'hello' is missing in type '[10, 20]' but required in type 'CoolArray<number>'.
 tests/cases/conformance/types/rest/genericRestParameters3.ts(49,1): error TS2345: Argument of type '[]' is not assignable to parameter of type 'CoolArray<unknown>'.
@@ -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 '<T extends any[]>(cb: (...args: T) => void) => void' is not assignable to parameter of type '(...args: CoolArray<any>) => void'.
 !!! error TS2345:   Types of parameters 'cb' and 'args' are incompatible.
-!!! error TS2345:     Property '0' is missing in type 'CoolArray<any>' but required in type '[(...args: any[]) => void]'.
+!!! error TS2345:     Property '0' is missing in type 'CoolArray<any>' but required in type '[cb: (...args: any[]) => void]'.
     
     function bar<T extends any[]>(...args: T): T {
         return args;

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<T extends any[]>() {

tests/baselines/reference/genericRestTypes.types

@@ -16,7 +16,7 @@ type MyFunctionType = (foo: number, bar: string) => boolean;
 
 type Explicit = (...args: Tail<Parameters<MyFunctionType>>) => ReturnType<MyFunctionType>; // (bar: string) => boolean
 >Explicit : Explicit
->args : [string]
+>args : [bar: string]
 
 type Bind1<T extends (head: any, ...tail: any[]) => any> = (...args: Tail<Parameters<T>>) => ReturnType<T>;
 >Bind1 : Bind1<T>

tests/baselines/reference/getParameterNameAtPosition.types

@@ -23,7 +23,7 @@ declare function fn<Y extends any[]>(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 : <Y extends any[]>(implementation?: ((...args: Y) => any) | undefined) => Mock<Y>
 >opts => { } : (opts: any) => void
 >opts : any

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]
 

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 : <T extends MyTuple>(f: GenericFunction<T>) => GenericClass<T>
 >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 : <T extends MyTuple>(f: GenericFunction<T>) => GenericClass<T>
 >(str, _unused_num) => console.log(str.length) : (str: string, _unused_num: boolean) => void
 >str : string

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<T extends any[]> = (...x: T) => void;
+
+export const func = null as any as Func<SegmentAnnotated>;
+
+export function useState<T>(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<typeof readSegment>[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<T extends any[]>(...x: T): T;
+declare function g(elem: object, index: number): object;
+declare function getArgsForInjection<T extends (...args: any[]) => any>(x: T): Parameters<T>;
+
+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<T extends any[]> = (...x: T) => void;
+export declare const func: Func<SegmentAnnotated>;
+export declare function useState<T>(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];

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<T extends any[]> = (...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<SegmentAnnotated>;
+>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<T>(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<typeof readSegment>[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<T extends any[]>(...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<T extends (...args: any[]) => any>(x: T): Parameters<T>;
+>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))
+

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<T extends any[]> = (...x: T) => void;
+>Func : Func<T>
+>x : T
+
+export const func = null as any as Func<SegmentAnnotated>;
+>func : Func<SegmentAnnotated>
+>null as any as Func<SegmentAnnotated> : Func<SegmentAnnotated>
+>null as any : any
+>null : null
+
+export function useState<T>(initial: T): [value: T, setter: (T) => void] {
+>useState : <T>(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<typeof readSegment>[0];
+>val : [number, number]
+>null as any as Parameters<typeof readSegment>[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<T extends any[]>(...x: T): T;
+>f : <T extends any[]>(...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<T extends (...args: any[]) => any>(x: T): Parameters<T>;
+>getArgsForInjection : <T extends (...args: any[]) => any>(x: T) => Parameters<T>
+>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 : <T extends any[]>(...x: T) => T
+>getArgsForInjection(g) : [elem: object, index: number]
+>getArgsForInjection : <T extends (...args: any[]) => any>(x: T) => Parameters<T>
+>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 : <T extends any[]>(...x: T) => T
+>...getArgsForInjection(g) : number | object
+>getArgsForInjection(g) : [elem: object, index: number]
+>getArgsForInjection : <T extends (...args: any[]) => any>(x: T) => Parameters<T>
+>g : (elem: object, index: number) => object
+

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.
+    

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];

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))
+

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
+

tests/baselines/reference/parameterListAsTupleType.types

@@ -8,7 +8,7 @@ function foo(a: number, b: string) {
 >true : true
 }
 type Foops = Parameters<typeof foo>;
->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<typeof x>;
->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<typeof C>; // should not work
 >C : typeof C
 
 type Ccps = ConstructorParameters<typeof C>; // 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<typeof D>; // should be [number, ...string[]]
->Dcps : [number, ...string[]]
+>Dcps : [a: number, ...rest: string[]]
 >D : typeof D
 

tests/baselines/reference/partiallyAnnotatedFunctionInferenceWithTypeParameter.types

@@ -105,7 +105,7 @@ testRest((t2: D, ...t3) => {})
 >testRest : <T extends C>(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

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<T extends any[], U>(f: (...args: T) => U): (...args: T) => U;

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 extends any[]>(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
 

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'.
     

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<T extends any[]> = (...x: T) => void;
+
+export const func = null as any as Func<SegmentAnnotated>;
+
+export function useState<T>(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<typeof readSegment>[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<T extends any[]>(...x: T): T;
+declare function g(elem: object, index: number): object;
+declare function getArgsForInjection<T extends (...args: any[]) => any>(x: T): Parameters<T>;
+
+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

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

tests/cases/fourslash/codeFixIncorrectNamedTupleSyntax1.ts

@@ -0,0 +1,10 @@
+/// <reference path='fourslash.ts' />
+
+////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[]];`
+});

tests/cases/fourslash/codeFixIncorrectNamedTupleSyntax2.ts

@@ -0,0 +1,10 @@
+/// <reference path='fourslash.ts' />
+
+////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[]];`
+});

tests/cases/fourslash/completionsElementAccessNumeric.ts

@@ -0,0 +1,30 @@
+/// <reference path="fourslash.ts" />
+
+// @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,
+        },
+    },
+);

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",

tests/cases/fourslash/namedTupleMembers.ts

@@ -0,0 +1,5 @@
+/// <reference path='fourslash.ts'/>
+
+////export type /*1*/Segment = [length: number, count: number];
+
+verify.quickInfoAt("1", "type Segment = [length: number, count: number]");

tests/cases/fourslash/refactorOverloadListToSingleSignature1.ts

@@ -0,0 +1,14 @@
+/// <reference path='fourslash.ts' />
+
+/////*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;`,
+});

tests/cases/fourslash/refactorOverloadListToSingleSignature2.ts

@@ -0,0 +1,49 @@
+/// <reference path='fourslash.ts' />
+
+/////*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;`,
+});

tests/cases/fourslash/refactorOverloadListToSingleSignature3.ts

@@ -0,0 +1,19 @@
+/// <reference path='fourslash.ts' />
+
+/////*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
+}`,
+});

tests/cases/fourslash/refactorOverloadListToSingleSignature4.ts

@@ -0,0 +1,23 @@
+/// <reference path='fourslash.ts' />
+
+////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
+    }
+}`,
+});

tests/cases/fourslash/refactorOverloadListToSingleSignature5.ts

@@ -0,0 +1,23 @@
+/// <reference path='fourslash.ts' />
+
+////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
+    }
+}`,
+});

tests/cases/fourslash/refactorOverloadListToSingleSignature6.ts

@@ -0,0 +1,18 @@
+/// <reference path='fourslash.ts' />
+
+////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;
+}`,
+});

tests/cases/fourslash/refactorOverloadListToSingleSignature7.ts

@@ -0,0 +1,18 @@
+/// <reference path='fourslash.ts' />
+
+////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;
+}`,
+});

tests/cases/fourslash/refactorOverloadListToSingleSignature8.ts

@@ -0,0 +1,18 @@
+/// <reference path='fourslash.ts' />
+
+////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;
+}`,
+});

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",

tests/cases/fourslash/signatureHelpExpandedRestTuples.ts

@@ -0,0 +1,36 @@
+/// <reference path='fourslash.ts' />
+
+////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,
+    },
+);