Tuples in rest parameters and spread expressions

src/compiler/binder.ts

@@ -3606,6 +3606,8 @@ namespace ts {
  case SyntaxKind.TypeLiteral:
  case SyntaxKind.ArrayType:
  case SyntaxKind.TupleType:
+ case SyntaxKind.OptionalType:
+ case SyntaxKind.RestType:
  case SyntaxKind.UnionType:
  case SyntaxKind.IntersectionType:
  case SyntaxKind.ConditionalType:

src/compiler/diagnosticMessages.json

@@ -367,10 +367,6 @@
  "category": "Error",
  "code": 1121
  },
- "A tuple type element list cannot be empty.": {
- "category": "Error",
- "code": 1122
- },
  "Variable declaration list cannot be empty.": {
  "category": "Error",
  "code": 1123
@@ -847,6 +843,14 @@
  "category": "Error",
  "code": 1255
  },
+ "A rest element must be last in a tuple type.": {
+ "category": "Error",
+ "code": 1256
+ },
+ "A required element cannot follow an optional element.": {
+ "category": "Error",
+ "code": 1257
+ },
  "'with' statements are not allowed in an async function block.": {
  "category": "Error",
  "code": 1300
@@ -2032,6 +2036,18 @@
  "category": "Error",
  "code": 2571
  },
+ "Rest signatures are incompatible.": {
+ "category": "Error",
+ "code": 2572
+ },
+ "Property '{0}' is incompatible with rest element type.": {
+ "category": "Error",
+ "code": 2573
+ },
+ "A rest element type must be an array type.": {
+ "category": "Error",
+ "code": 2574
+ },
  "JSX element attributes type '{0}' may not be a union type.": {
  "category": "Error",
  "code": 2600

src/compiler/emitter.ts

@@ -659,6 +659,8 @@ namespace ts {
  return emitArrayType(<ArrayTypeNode>node);
  case SyntaxKind.TupleType:
  return emitTupleType(<TupleTypeNode>node);
+ case SyntaxKind.OptionalType:
+ return emitOptionalType(<OptionalTypeNode>node);
  case SyntaxKind.UnionType:
  return emitUnionType(<UnionTypeNode>node);
  case SyntaxKind.IntersectionType:
@@ -695,8 +697,9 @@ namespace ts {
  return emitJSDocNonNullableType(node as JSDocNonNullableType);
  case SyntaxKind.JSDocOptionalType:
  return emitJSDocOptionalType(node as JSDocOptionalType);
+ case SyntaxKind.RestType:
  case SyntaxKind.JSDocVariadicType:
- return emitJSDocVariadicType(node as JSDocVariadicType);
+ return emitRestOrJSDocVariadicType(node as RestTypeNode | JSDocVariadicType);
 
  // Binding patterns
  case SyntaxKind.ObjectBindingPattern:
@@ -1304,7 +1307,7 @@ namespace ts {
  writePunctuation("]");
  }
 
- function emitJSDocVariadicType(node: JSDocVariadicType) {
+ function emitRestOrJSDocVariadicType(node: RestTypeNode | JSDocVariadicType) {
  write("...");
  emit(node.type);
  }
@@ -1315,6 +1318,11 @@ namespace ts {
  writePunctuation("]");
  }
 
+ function emitOptionalType(node: OptionalTypeNode) {
+ emit(node.type);
+ write("?");
+ }
+
  function emitUnionType(node: UnionTypeNode) {
  emitList(node, node.types, ListFormat.UnionTypeConstituents);
  }

src/compiler/factory.ts

@@ -745,12 +745,36 @@ namespace ts {
  return node;
  }
 
- export function updateTypleTypeNode(node: TupleTypeNode, elementTypes: ReadonlyArray<TypeNode>) {
+ export function updateTupleTypeNode(node: TupleTypeNode, elementTypes: ReadonlyArray<TypeNode>) {
  return node.elementTypes !== elementTypes
  ? updateNode(createTupleTypeNode(elementTypes), node)
  : node;
  }
 
+ export function createOptionalTypeNode(type: TypeNode) {
+ const node = createSynthesizedNode(SyntaxKind.OptionalType) as OptionalTypeNode;
+ node.type = parenthesizeArrayTypeMember(type);
+ return node;
+ }
+
+ export function updateOptionalTypeNode(node: OptionalTypeNode, type: TypeNode): OptionalTypeNode {
+ return node.type !== type
+ ? updateNode(createOptionalTypeNode(type), node)
+ : node;
+ }
+
+ export function createRestTypeNode(type: TypeNode) {
+ const node = createSynthesizedNode(SyntaxKind.RestType) as RestTypeNode;
+ node.type = type;
+ return node;
+ }
+
+ export function updateRestTypeNode(node: RestTypeNode, type: TypeNode): RestTypeNode {
+ return node.type !== type
+ ? updateNode(createRestTypeNode(type), node)
+ : node;
+ }
+
  export function createUnionTypeNode(types: ReadonlyArray<TypeNode>): UnionTypeNode {
  return <UnionTypeNode>createUnionOrIntersectionTypeNode(SyntaxKind.UnionType, types);
  }

src/compiler/parser.ts

@@ -445,19 +445,17 @@ namespace ts {
  case SyntaxKind.JsxClosingElement:
  return visitNode(cbNode, (<JsxClosingElement>node).tagName);
 
+ case SyntaxKind.OptionalType:
+ case SyntaxKind.RestType:
  case SyntaxKind.JSDocTypeExpression:
- return visitNode(cbNode, (<JSDocTypeExpression>node).type);
  case SyntaxKind.JSDocNonNullableType:
- return visitNode(cbNode, (<JSDocNonNullableType>node).type);
  case SyntaxKind.JSDocNullableType:
- return visitNode(cbNode, (<JSDocNullableType>node).type);
  case SyntaxKind.JSDocOptionalType:
- return visitNode(cbNode, (<JSDocOptionalType>node).type);
+ case SyntaxKind.JSDocVariadicType:
+ return visitNode(cbNode, (<OptionalTypeNode | RestTypeNode | JSDocTypeExpression | JSDocTypeReferencingNode>node).type);
  case SyntaxKind.JSDocFunctionType:
  return visitNodes(cbNode, cbNodes, (<JSDocFunctionType>node).parameters) ||
  visitNode(cbNode, (<JSDocFunctionType>node).type);
- case SyntaxKind.JSDocVariadicType:
- return visitNode(cbNode, (<JSDocVariadicType>node).type);
  case SyntaxKind.JSDocComment:
  return visitNodes(cbNode, cbNodes, (<JSDoc>node).tags);
  case SyntaxKind.JSDocParameterTag:
@@ -2293,7 +2291,7 @@ namespace ts {
  function parseJSDocAllType(postFixEquals: boolean): JSDocAllType | JSDocOptionalType {
  const result = createNode(SyntaxKind.JSDocAllType) as JSDocAllType;
  if (postFixEquals) {
- return createJSDocPostfixType(SyntaxKind.JSDocOptionalType, result) as JSDocOptionalType;
+ return createPostfixType(SyntaxKind.JSDocOptionalType, result) as JSDocOptionalType;
  }
  else {
  nextToken();
@@ -2371,7 +2369,7 @@ namespace ts {
  type = finishNode(variadic);
  }
  if (token() === SyntaxKind.EqualsToken) {
- return createJSDocPostfixType(SyntaxKind.JSDocOptionalType, type);
+ return createPostfixType(SyntaxKind.JSDocOptionalType, type);
  }
  return type;
  }
@@ -2779,9 +2777,23 @@ namespace ts {
  return finishNode(node);
  }
 
+ function parseTupleElementType() {
+ const pos = getNodePos();
+ if (parseOptional(SyntaxKind.DotDotDotToken)) {
+ const node = <RestTypeNode>createNode(SyntaxKind.RestType, pos);
+ node.type = parseType();
+ return finishNode(node);
+ }
+ const type = parseType();
+ if (!(contextFlags & NodeFlags.JSDoc) && type.kind === SyntaxKind.JSDocNullableType && type.pos === (<JSDocNullableType>type).type.pos) {
+ type.kind = SyntaxKind.OptionalType;
+ }
+ return type;
+ }
+
  function parseTupleType(): TupleTypeNode {
  const node = <TupleTypeNode>createNode(SyntaxKind.TupleType);
- node.elementTypes = parseBracketedList(ParsingContext.TupleElementTypes, parseType, SyntaxKind.OpenBracketToken, SyntaxKind.CloseBracketToken);
+ node.elementTypes = parseBracketedList(ParsingContext.TupleElementTypes, parseTupleElementType, SyntaxKind.OpenBracketToken, SyntaxKind.CloseBracketToken);
  return finishNode(node);
  }
 
@@ -2964,14 +2976,14 @@ namespace ts {
  while (!scanner.hasPrecedingLineBreak()) {
  switch (token()) {
  case SyntaxKind.ExclamationToken:
- type = createJSDocPostfixType(SyntaxKind.JSDocNonNullableType, type);
+ type = createPostfixType(SyntaxKind.JSDocNonNullableType, type);
  break;
  case SyntaxKind.QuestionToken:
  // If not in JSDoc and next token is start of a type we have a conditional type
  if (!(contextFlags & NodeFlags.JSDoc) && lookAhead(nextTokenIsStartOfType)) {
  return type;
  }
- type = createJSDocPostfixType(SyntaxKind.JSDocNullableType, type);
+ type = createPostfixType(SyntaxKind.JSDocNullableType, type);
  break;
  case SyntaxKind.OpenBracketToken:
  parseExpected(SyntaxKind.OpenBracketToken);
@@ -2996,9 +3008,9 @@ namespace ts {
  return type;
  }
 
- function createJSDocPostfixType(kind: SyntaxKind, type: TypeNode) {
+ function createPostfixType(kind: SyntaxKind, type: TypeNode) {
  nextToken();
- const postfix = createNode(kind, type.pos) as JSDocOptionalType | JSDocNonNullableType | JSDocNullableType;
+ const postfix = createNode(kind, type.pos) as OptionalTypeNode | JSDocOptionalType | JSDocNonNullableType | JSDocNullableType;
  postfix.type = type;
  return finishNode(postfix);
  }

src/compiler/transformers/ts.ts

@@ -380,6 +380,8 @@ namespace ts {
 
  case SyntaxKind.ArrayType:
  case SyntaxKind.TupleType:
+ case SyntaxKind.OptionalType:
+ case SyntaxKind.RestType:
  case SyntaxKind.TypeLiteral:
  case SyntaxKind.TypePredicate:
  case SyntaxKind.TypeParameter:

src/compiler/types.ts

@@ -225,6 +225,8 @@ namespace ts {
  TypeLiteral,
  ArrayType,
  TupleType,
+ OptionalType,
+ RestType,
  UnionType,
  IntersectionType,
  ConditionalType,
@@ -269,6 +271,7 @@ namespace ts {
  AsExpression,
  NonNullExpression,
  MetaProperty,
+ SyntheticExpression,
 
  // Misc
  TemplateSpan,
@@ -1101,6 +1104,16 @@ namespace ts {
  elementTypes: NodeArray<TypeNode>;
  }
 
+ export interface OptionalTypeNode extends TypeNode {
+ kind: SyntaxKind.OptionalType;
+ type: TypeNode;
+ }
+
+ export interface RestTypeNode extends TypeNode {
+ kind: SyntaxKind.RestType;
+ type: TypeNode;
+ }
+
  export type UnionOrIntersectionTypeNode = UnionTypeNode | IntersectionTypeNode;
 
  export interface UnionTypeNode extends TypeNode {
@@ -1288,6 +1301,12 @@ namespace ts {
  expression?: Expression;
  }
 
+ export interface SyntheticExpression extends Expression {
+ kind: SyntaxKind.SyntheticExpression;
+ isSpread: boolean;
+ type: Type;
+ }
+
  // see: https://tc39.github.io/ecma262/#prod-ExponentiationExpression
  export type ExponentiationOperator
  = SyntaxKind.AsteriskAsteriskToken
@@ -3520,14 +3539,15 @@ namespace ts {
  ContainsPrivate = 1 << 8, // Synthetic property with private constituent(s)
  ContainsStatic = 1 << 9, // Synthetic property with static constituent(s)
  Late = 1 << 10, // Late-bound symbol for a computed property with a dynamic name
- ReverseMapped = 1 << 11, // property of reverse-inferred homomorphic mapped type.
+ ReverseMapped = 1 << 11, // Property of reverse-inferred homomorphic mapped type
+ OptionalParameter = 1 << 12, // Optional parameter
+ RestParameter = 1 << 13, // Rest parameter
  Synthetic = SyntheticProperty | SyntheticMethod
  }
 
  /* @internal */
  export interface TransientSymbol extends Symbol, SymbolLinks {
  checkFlags: CheckFlags;
- isRestParameter?: boolean;
  }
 
  /* @internal */
@@ -3856,6 +3876,16 @@ namespace ts {
  variances?: Variance[]; // Variance of each type parameter
  }
 
+ export interface TupleType extends GenericType {
+ minLength: number;
+ hasRestElement: boolean;
+ associatedNames?: __String[];
+ }
+
+ export interface TupleTypeReference extends TypeReference {
+ target: TupleType;
+ }
+
  export interface UnionOrIntersectionType extends Type {
  types: Type[]; // Constituent types
  /* @internal */

src/compiler/visitor.ts

@@ -372,9 +372,17 @@ namespace ts {
  visitNode((<ArrayTypeNode>node).elementType, visitor, isTypeNode));
 
  case SyntaxKind.TupleType:
- return updateTypleTypeNode((<TupleTypeNode>node),
+ return updateTupleTypeNode((<TupleTypeNode>node),
  nodesVisitor((<TupleTypeNode>node).elementTypes, visitor, isTypeNode));
 
+ case SyntaxKind.OptionalType:
+ return updateOptionalTypeNode((<OptionalTypeNode>node),
+ visitNode((<OptionalTypeNode>node).type, visitor, isTypeNode));
+
+ case SyntaxKind.RestType:
+ return updateRestTypeNode((<RestTypeNode>node),
+ visitNode((<RestTypeNode>node).type, visitor, isTypeNode));
+
  case SyntaxKind.UnionType:
  return updateUnionTypeNode(<UnionTypeNode>node,
  nodesVisitor((<UnionTypeNode>node).types, visitor, isTypeNode));

tests/baselines/reference/anyIndexedAccessArrayNoException.errors.txt

@@ -1,11 +1,8 @@
-tests/cases/compiler/anyIndexedAccessArrayNoException.ts(1,12): error TS1122: A tuple type element list cannot be empty.
 tests/cases/compiler/anyIndexedAccessArrayNoException.ts(1,12): error TS2538: Type '[]' cannot be used as an index type.
 
 
-==== tests/cases/compiler/anyIndexedAccessArrayNoException.ts (2 errors) ====
+==== tests/cases/compiler/anyIndexedAccessArrayNoException.ts (1 errors) ====
  var x: any[[]];
  ~~
-!!! error TS1122: A tuple type element list cannot be empty.
- ~~
 !!! error TS2538: Type '[]' cannot be used as an index type.