Conditional types

src/compiler/binder.ts

@@ -3440,6 +3440,7 @@ namespace ts {
  case SyntaxKind.TupleType:
  case SyntaxKind.UnionType:
  case SyntaxKind.IntersectionType:
+ case SyntaxKind.ConditionalType:
  case SyntaxKind.ParenthesizedType:
  case SyntaxKind.InterfaceDeclaration:
  case SyntaxKind.TypeAliasDeclaration:

src/compiler/core.ts

@@ -439,23 +439,21 @@ namespace ts {
  export function sameMap<T>(array: T[], f: (x: T, i: number) => T): T[];
  export function sameMap<T>(array: ReadonlyArray<T>, f: (x: T, i: number) => T): ReadonlyArray<T>;
  export function sameMap<T>(array: T[], f: (x: T, i: number) => T): T[] {
- let result: T[];
  if (array) {
  for (let i = 0; i < array.length; i++) {
- if (result) {
- result.push(f(array[i], i));
- }
- else {
- const item = array[i];
- const mapped = f(item, i);
- if (item !== mapped) {
- result = array.slice(0, i);
- result.push(mapped);
+ const item = array[i];
+ const mapped = f(item, i);
+ if (item !== mapped) {
+ const result = array.slice(0, i);
+ result.push(mapped);
+ for (i++; i < array.length; i++) {
+ result.push(f(array[i], i));
  }
+ return result;
  }
  }
  }
- return result || array;
+ return array;
  }
 
  /**

src/compiler/declarationEmitter.ts

@@ -450,6 +450,8 @@ namespace ts {
  return emitUnionType(<UnionTypeNode>type);
  case SyntaxKind.IntersectionType:
  return emitIntersectionType(<IntersectionTypeNode>type);
+ case SyntaxKind.ConditionalType:
+ return emitConditionalType(<ConditionalTypeNode>type);
  case SyntaxKind.ParenthesizedType:
  return emitParenType(<ParenthesizedTypeNode>type);
  case SyntaxKind.TypeOperator:
@@ -545,6 +547,16 @@ namespace ts {
  emitSeparatedList(type.types, " & ", emitType);
  }
 
+ function emitConditionalType(node: ConditionalTypeNode) {
+ emitType(node.checkType);
+ write(" extends ");
+ emitType(node.extendsType);
+ write(" ? ");
+ emitType(node.trueType);
+ write(" : ");
+ emitType(node.falseType);
+ }
+
  function emitParenType(type: ParenthesizedTypeNode) {
  write("(");
  emitType(type.type);

src/compiler/emitter.ts

@@ -600,6 +600,8 @@ namespace ts {
  return emitUnionType(<UnionTypeNode>node);
  case SyntaxKind.IntersectionType:
  return emitIntersectionType(<IntersectionTypeNode>node);
+ case SyntaxKind.ConditionalType:
+ return emitConditionalType(<ConditionalTypeNode>node);
  case SyntaxKind.ParenthesizedType:
  return emitParenthesizedType(<ParenthesizedTypeNode>node);
  case SyntaxKind.ExpressionWithTypeArguments:
@@ -1190,6 +1192,16 @@ namespace ts {
  emitList(node, node.types, ListFormat.IntersectionTypeConstituents);
  }
 
+ function emitConditionalType(node: ConditionalTypeNode) {
+ emit(node.checkType);
+ write(" extends ");
+ emit(node.extendsType);
+ write(" ? ");
+ emit(node.trueType);
+ write(" : ");
+ emit(node.falseType);
+ }
+
  function emitParenthesizedType(node: ParenthesizedTypeNode) {
  writePunctuation("(");
  emit(node.type);

src/compiler/factory.ts

@@ -731,6 +731,24 @@ namespace ts {
  : node;
  }
 
+ export function createConditionalTypeNode(checkType: TypeNode, extendsType: TypeNode, trueType: TypeNode, falseType: TypeNode) {
+ const node = createSynthesizedNode(SyntaxKind.ConditionalType) as ConditionalTypeNode;
+ node.checkType = parenthesizeConditionalTypeMember(checkType);
+ node.extendsType = parenthesizeConditionalTypeMember(extendsType);
+ node.trueType = trueType;
+ node.falseType = falseType;
+ return node;
+ }
+
+ export function updateConditionalTypeNode(node: ConditionalTypeNode, checkType: TypeNode, extendsType: TypeNode, trueType: TypeNode, falseType: TypeNode) {
+ return node.checkType !== checkType
+ || node.extendsType !== extendsType
+ || node.trueType !== trueType
+ || node.falseType !== falseType
+ ? updateNode(createConditionalTypeNode(checkType, extendsType, trueType, falseType), node)
+ : node;
+ }
+
  export function createParenthesizedType(type: TypeNode) {
  const node = <ParenthesizedTypeNode>createSynthesizedNode(SyntaxKind.ParenthesizedType);
  node.type = type;
@@ -4094,6 +4112,10 @@ namespace ts {
  return expression;
  }
 
+ export function parenthesizeConditionalTypeMember(member: TypeNode) {
+ return member.kind === SyntaxKind.ConditionalType ? createParenthesizedType(member) : member;
+ }
+
  export function parenthesizeElementTypeMember(member: TypeNode) {
  switch (member.kind) {
  case SyntaxKind.UnionType:
@@ -4102,7 +4124,7 @@ namespace ts {
  case SyntaxKind.ConstructorType:
  return createParenthesizedType(member);
  }
- return member;
+ return parenthesizeConditionalTypeMember(member);
  }
 
  export function parenthesizeArrayTypeMember(member: TypeNode) {

src/compiler/parser.ts

@@ -175,6 +175,11 @@ namespace ts {
  case SyntaxKind.UnionType:
  case SyntaxKind.IntersectionType:
  return visitNodes(cbNode, cbNodes, (<UnionOrIntersectionTypeNode>node).types);
+ case SyntaxKind.ConditionalType:
+ return visitNode(cbNode, (<ConditionalTypeNode>node).checkType) ||
+ visitNode(cbNode, (<ConditionalTypeNode>node).extendsType) ||
+ visitNode(cbNode, (<ConditionalTypeNode>node).trueType) ||
+ visitNode(cbNode, (<ConditionalTypeNode>node).falseType);
  case SyntaxKind.ParenthesizedType:
  case SyntaxKind.TypeOperator:
  return visitNode(cbNode, (<ParenthesizedTypeNode | TypeOperatorNode>node).type);
@@ -1494,6 +1499,11 @@ namespace ts {
  return isStartOfExpression();
  }
 
+ function nextTokenIsStartOfType() {
+ nextToken();
+ return isStartOfType();
+ }
+
  // True if positioned at a list terminator
  function isListTerminator(kind: ParsingContext): boolean {
  if (token() === SyntaxKind.EndOfFileToken) {
@@ -2789,6 +2799,10 @@ namespace ts {
  type = createJSDocPostfixType(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);
  break;
  case SyntaxKind.OpenBracketToken:
@@ -2950,14 +2964,26 @@ namespace ts {
  return doOutsideOfContext(NodeFlags.TypeExcludesFlags, parseTypeWorker);
  }
 
- function parseTypeWorker(): TypeNode {
+ function parseTypeWorker(noConditionalTypes?: boolean): TypeNode {
  if (isStartOfFunctionType()) {
  return parseFunctionOrConstructorType(SyntaxKind.FunctionType);
  }
  if (token() === SyntaxKind.NewKeyword) {
  return parseFunctionOrConstructorType(SyntaxKind.ConstructorType);
  }
- return parseUnionTypeOrHigher();
+ const type = parseUnionTypeOrHigher();
+ if (!noConditionalTypes && parseOptional(SyntaxKind.ExtendsKeyword)) {
+ const node = <ConditionalTypeNode>createNode(SyntaxKind.ConditionalType, type.pos);
+ node.checkType = type;
+ // The type following 'extends' is not permitted to be another conditional type
+ node.extendsType = parseTypeWorker(/*noConditionalTypes*/ true);
+ parseExpected(SyntaxKind.QuestionToken);
+ node.trueType = parseTypeWorker();
+ parseExpected(SyntaxKind.ColonToken);
+ node.falseType = parseTypeWorker();
+ return finishNode(node);
+ }
+ return type;
  }
 
  function parseTypeAnnotation(): TypeNode {

src/compiler/transformers/ts.ts

@@ -385,6 +385,7 @@ namespace ts {
  case SyntaxKind.TypeReference:
  case SyntaxKind.UnionType:
  case SyntaxKind.IntersectionType:
+ case SyntaxKind.ConditionalType:
  case SyntaxKind.ParenthesizedType:
  case SyntaxKind.ThisType:
  case SyntaxKind.TypeOperator:

src/compiler/types.ts

@@ -265,6 +265,7 @@ namespace ts {
  TupleType,
  UnionType,
  IntersectionType,
+ ConditionalType,
  ParenthesizedType,
  ThisType,
  TypeOperator,
@@ -1116,6 +1117,14 @@ namespace ts {
  types: NodeArray<TypeNode>;
  }
 
+ export interface ConditionalTypeNode extends TypeNode {
+ kind: SyntaxKind.ConditionalType;
+ checkType: TypeNode;
+ extendsType: TypeNode;
+ trueType: TypeNode;
+ falseType: TypeNode;
+ }
+
  export interface ParenthesizedTypeNode extends TypeNode {
  kind: SyntaxKind.ParenthesizedType;
  type: TypeNode;
@@ -3484,18 +3493,19 @@ namespace ts {
  Intersection = 1 << 18, // Intersection (T & U)
  Index = 1 << 19, // keyof T
  IndexedAccess = 1 << 20, // T[K]
+ Conditional = 1 << 21, // T extends U ? X : Y
+ Substitution = 1 << 22, // Type parameter substitution
  /* @internal */
- FreshLiteral = 1 << 21, // Fresh literal or unique type
+ FreshLiteral = 1 << 23, // Fresh literal or unique type
  /* @internal */
- ContainsWideningType = 1 << 22, // Type is or contains undefined or null widening type
+ ContainsWideningType = 1 << 24, // Type is or contains undefined or null widening type
  /* @internal */
- ContainsObjectLiteral = 1 << 23, // Type is or contains object literal type
+ ContainsObjectLiteral = 1 << 25, // Type is or contains object literal type
  /* @internal */
- ContainsAnyFunctionType = 1 << 24, // Type is or contains the anyFunctionType
- NonPrimitive = 1 << 25, // intrinsic object type
+ ContainsAnyFunctionType = 1 << 26, // Type is or contains the anyFunctionType
+ NonPrimitive = 1 << 27, // intrinsic object type
  /* @internal */
- JsxAttributes = 1 << 26, // Jsx attributes type
- MarkerType = 1 << 27, // Marker type used for variance probing
+ GenericMappedType = 1 << 29, // Flag used by maybeTypeOfKind
 
  /* @internal */
  Nullable = Undefined | Null,
@@ -3518,17 +3528,21 @@ namespace ts {
  ESSymbolLike = ESSymbol | UniqueESSymbol,
  UnionOrIntersection = Union | Intersection,
  StructuredType = Object | Union | Intersection,
- StructuredOrTypeVariable = StructuredType | TypeParameter | Index | IndexedAccess,
  TypeVariable = TypeParameter | IndexedAccess,
+ InstantiableNonPrimitive = TypeVariable | Conditional | Substitution,
+ InstantiablePrimitive = Index,
+ Instantiable = InstantiableNonPrimitive | InstantiablePrimitive,
+ StructuredOrInstantiable = StructuredType | Instantiable,
 
  // 'Narrowable' types are types where narrowing actually narrows.
  // This *should* be every type other than null, undefined, void, and never
- Narrowable = Any | StructuredType | TypeParameter | Index | IndexedAccess | StringLike | NumberLike | BooleanLike | ESSymbol | UniqueESSymbol | NonPrimitive,
+ Narrowable = Any | StructuredOrInstantiable | StringLike | NumberLike | BooleanLike | ESSymbol | UniqueESSymbol | NonPrimitive,
  NotUnionOrUnit = Any | ESSymbol | Object | NonPrimitive,
  /* @internal */
  RequiresWidening = ContainsWideningType | ContainsObjectLiteral,
  /* @internal */
  PropagatingFlags = ContainsWideningType | ContainsObjectLiteral | ContainsAnyFunctionType,
+ /* @internal */
  }
 
  export type DestructuringPattern = BindingPattern | ObjectLiteralExpression | ArrayLiteralExpression;
@@ -3587,7 +3601,9 @@ namespace ts {
  EvolvingArray = 1 << 8, // Evolving array type
  ObjectLiteralPatternWithComputedProperties = 1 << 9, // Object literal pattern with computed properties
  ContainsSpread = 1 << 10, // Object literal contains spread operation
- ReverseMapped = 1 << 11, // Object contains a property from a reverse-mapped type
+ ReverseMapped = 1 << 11, // Object contains a property from a reverse-mapped type
+ JsxAttributes = 1 << 12, // Jsx attributes type
+ MarkerType = 1 << 13, // Marker type used for variance probing
  ClassOrInterface = Class | Interface
  }
 
@@ -3741,15 +3757,15 @@ namespace ts {
  syntheticType?: Type;
  }
 
- export interface TypeVariable extends Type {
+ export interface InstantiableType extends Type {
  /* @internal */
  resolvedBaseConstraint?: Type;
  /* @internal */
  resolvedIndexType?: IndexType;
  }
 
  // Type parameters (TypeFlags.TypeParameter)
- export interface TypeParameter extends TypeVariable {
+ export interface TypeParameter extends InstantiableType {
  /** Retrieve using getConstraintFromTypeParameter */
  /* @internal */
  constraint?: Type; // Constraint
@@ -3767,15 +3783,38 @@ namespace ts {
 
  // Indexed access types (TypeFlags.IndexedAccess)
  // Possible forms are T[xxx], xxx[T], or xxx[keyof T], where T is a type variable
- export interface IndexedAccessType extends TypeVariable {
+ export interface IndexedAccessType extends InstantiableType {
  objectType: Type;
  indexType: Type;
  constraint?: Type;
  }
 
  // keyof T types (TypeFlags.Index)
- export interface IndexType extends Type {
- type: TypeVariable | UnionOrIntersectionType;
+ export interface IndexType extends InstantiableType {
+ type: InstantiableType | UnionOrIntersectionType;
+ }
+
+ // T extends U ? X : Y (TypeFlags.Conditional)
+ export interface ConditionalType extends InstantiableType {
+ checkType: Type;
+ extendsType: Type;
+ trueType: Type;
+ falseType: Type;
+ /* @internal */
+ target?: ConditionalType;
+ /* @internal */
+ mapper?: TypeMapper;
+ }
+
+ // Type parameter substitution (TypeFlags.Substitution)
+ // Substitution types are created for type parameter references that occur in the true branch
+ // of a conditional type. For example, in 'T extends string ? Foo<T> : Bar<T>', the reference to
+ // T in Foo<T> is resolved as a substitution type that substitutes 'string & T' for T. Thus, if
+ // Foo has a 'string' constraint on its type parameter, T will satisfy it. Substitution types
+ // disappear upon instantiation (just like type parameters).
+ export interface SubstitutionType extends InstantiableType {
+ typeParameter: TypeParameter; // Target type parameter
+ substitute: Type; // Type to substitute for type parameter
  }
 
  export const enum SignatureKind {

src/compiler/utilities.ts

@@ -4621,6 +4621,10 @@ namespace ts {
  return node.kind === SyntaxKind.IntersectionType;
  }
 
+ export function isConditionalTypeNode(node: Node): node is ConditionalTypeNode {
+ return node.kind === SyntaxKind.ConditionalType;
+ }
+
  export function isParenthesizedTypeNode(node: Node): node is ParenthesizedTypeNode {
  return node.kind === SyntaxKind.ParenthesizedType;
  }

src/compiler/visitor.ts

@@ -387,6 +387,13 @@ namespace ts {
  return updateIntersectionTypeNode(<IntersectionTypeNode>node,
  nodesVisitor((<IntersectionTypeNode>node).types, visitor, isTypeNode));
 
+ case SyntaxKind.ConditionalType:
+ return updateConditionalTypeNode(<ConditionalTypeNode>node,
+ visitNode((<ConditionalTypeNode>node).checkType, visitor, isTypeNode),
+ visitNode((<ConditionalTypeNode>node).extendsType, visitor, isTypeNode),
+ visitNode((<ConditionalTypeNode>node).trueType, visitor, isTypeNode),
+ visitNode((<ConditionalTypeNode>node).falseType, visitor, isTypeNode));
+
  case SyntaxKind.ParenthesizedType:
  return updateParenthesizedType(<ParenthesizedTypeNode>node,
  visitNode((<ParenthesizedTypeNode>node).type, visitor, isTypeNode));