TypeScript: Support conditional types syntax (babel#7404)

microsoft/TypeScript#21316 and microsoft/TypeScript#21496

Author: Andy

packages/babel-generator/src/generators/typescript.js

@@ -256,6 +256,28 @@ export function tsPrintUnionOrIntersectionType(node, sep) {
   });
 }
 
+export function TSConditionalType(node) {
+  this.print(node.checkType);
+  this.space();
+  this.word("extends");
+  this.space();
+  this.print(node.extendsType);
+  this.space();
+  this.token("?");
+  this.space();
+  this.print(node.trueType);
+  this.space();
+  this.token(":");
+  this.space();
+  this.print(node.falseType);
+}
+
+export function TSInferType(node) {
+  this.token("infer");
+  this.space();
+  this.print(node.typeParameter);
+}
+
 export function TSParenthesizedType(node) {
   this.token("(");
   this.print(node.typeAnnotation, node);

packages/babel-generator/test/fixtures/typescript/types-conditional-infer/input.js

@@ -0,0 +1 @@
+type Element<T> = T extends (infer U)[] ? U : T;

packages/babel-generator/test/fixtures/typescript/types-conditional-infer/output.js

@@ -0,0 +1 @@
+type Element<T> = T extends (infer U)[] ? U : T;

packages/babel-generator/test/fixtures/typescript/types-conditional/input.js

@@ -0,0 +1 @@
+let x: number extends string ? boolean : null;

packages/babel-generator/test/fixtures/typescript/types-conditional/output.js

@@ -0,0 +1 @@
+let x: number extends string ? boolean : null;

packages/babel-types/README.md

@@ -1875,6 +1875,22 @@ Aliases: `TSTypeElement`
 
 ---
 
+### tSConditionalType
+```javascript
+t.tsConditionalType(checkType, extendsType, trueType, falseType)
+```
+
+See also `t.isTSConditionalType(node, opts)` and `t.assertTSConditionalType(node, opts)`.
+
+Aliases: `TSType`
+
+ - `checkType`: `TSType` (required)
+ - `extendsType`: `TSType` (required)
+ - `trueType`: `TSType` (required)
+ - `falseType`: `TSType` (required)
+
+---
+
 ### tSConstructSignatureDeclaration
 ```javascript
 t.tsConstructSignatureDeclaration(typeParameters, parameters, typeAnnotation)
@@ -2074,6 +2090,19 @@ Aliases: `TSType`
 
 ---
 
+### tSInferType
+```javascript
+t.tsInferType(typeParameter)
+```
+
+See also `t.isTSInferType(node, opts)` and `t.assertTSInferType(node, opts)`.
+
+Aliases: `TSType`
+
+ - `typeParameter`: `TSType` (required)
+
+---
+
 ### tSInterfaceBody
 ```javascript
 t.tsInterfaceBody(body)

packages/babel-types/src/asserts/generated/index.js

@@ -801,6 +801,15 @@ export function assertTSIntersectionType(
 ): void {
   assert("TSIntersectionType", node, opts);
 }
+export function assertTSConditionalType(
+  node: Object,
+  opts?: Object = {},
+): void {
+  assert("TSConditionalType", node, opts);
+}
+export function assertTSInferType(node: Object, opts?: Object = {}): void {
+  assert("TSInferType", node, opts);
+}
 export function assertTSParenthesizedType(
   node: Object,
   opts?: Object = {},

packages/babel-types/src/builders/generated/index.js

@@ -774,6 +774,16 @@ export function TSIntersectionType(...args: Array<any>): Object {
 }
 export { TSIntersectionType as tsIntersectionType };
 export { TSIntersectionType as tSIntersectionType };
+export function TSConditionalType(...args: Array<any>): Object {
+  return builder("TSConditionalType", ...args);
+}
+export { TSConditionalType as tsConditionalType };
+export { TSConditionalType as tSConditionalType };
+export function TSInferType(...args: Array<any>): Object {
+  return builder("TSInferType", ...args);
+}
+export { TSInferType as tsInferType };
+export { TSInferType as tSInferType };
 export function TSParenthesizedType(...args: Array<any>): Object {
   return builder("TSParenthesizedType", ...args);
 }

packages/babel-types/src/definitions/typescript.js

@@ -223,6 +223,25 @@ const unionOrIntersection = {
 defineType("TSUnionType", unionOrIntersection);
 defineType("TSIntersectionType", unionOrIntersection);
 
+defineType("TSConditionalType", {
+  aliases: ["TSType"],
+  visitor: ["checkType", "extendsType", "trueType", "falseType"],
+  fields: {
+    checkType: validateType("TSType"),
+    extendsType: validateType("TSType"),
+    trueType: validateType("TSType"),
+    falseType: validateType("TSType"),
+  },
+});
+
+defineType("TSInferType", {
+  aliases: ["TSType"],
+  visitor: ["typeParameter"],
+  fields: {
+    typeParameter: validateType("TSType"),
+  },
+});
+
 defineType("TSParenthesizedType", {
   aliases: ["TSType"],
   visitor: ["typeAnnotation"],

packages/babel-types/src/validators/generated/index.js

@@ -608,6 +608,12 @@ export function isTSUnionType(node: Object, opts?: Object): boolean {
 export function isTSIntersectionType(node: Object, opts?: Object): boolean {
   return is("TSIntersectionType", node, opts);
 }
+export function isTSConditionalType(node: Object, opts?: Object): boolean {
+  return is("TSConditionalType", node, opts);
+}
+export function isTSInferType(node: Object, opts?: Object): boolean {
+  return is("TSInferType", node, opts);
+}
 export function isTSParenthesizedType(node: Object, opts?: Object): boolean {
   return is("TSParenthesizedType", node, opts);
 }

packages/babylon/src/plugins/typescript.js

@@ -617,11 +617,22 @@ export default (superClass: Class<Parser>): Class<Parser> =>
       return this.finishNode(node, "TSTypeOperator");
     }
 
+    tsParseInferType(): N.TsInferType {
+      const node = this.startNode();
+      this.expectContextual("infer");
+      const typeParameter = this.startNode();
+      typeParameter.name = this.parseIdentifierName(typeParameter.start);
+      node.typeParameter = this.finishNode(typeParameter, "TypeParameter");
+      return this.finishNode(node, "TSInferType");
+    }
+
     tsParseTypeOperatorOrHigher(): N.TsType {
       const operator = ["keyof", "unique"].find(kw => this.isContextual(kw));
       return operator
         ? this.tsParseTypeOperator(operator)
-        : this.tsParseArrayTypeOrHigher();
+        : this.isContextual("infer")
+          ? this.tsParseInferType()
+          : this.tsParseArrayTypeOrHigher();
     }
 
     tsParseUnionOrIntersectionType(
@@ -774,6 +785,21 @@ export default (superClass: Class<Parser>): Class<Parser> =>
     tsParseType(): N.TsType {
       // Need to set `state.inType` so that we don't parse JSX in a type context.
       assert(this.state.inType);
+      const type = this.tsParseNonConditionalType();
+      if (this.hasPrecedingLineBreak() || !this.eat(tt._extends)) {
+        return type;
+      }
+      const node: N.TsConditionalType = this.startNodeAtNode(type);
+      node.checkType = type;
+      node.extendsType = this.tsParseNonConditionalType();
+      this.expect(tt.question);
+      node.trueType = this.tsParseType();
+      this.expect(tt.colon);
+      node.falseType = this.tsParseType();
+      return this.finishNode(node, "TSConditionalType");
+    }
+
+    tsParseNonConditionalType(): N.TsType {
       if (this.tsIsStartOfFunctionType()) {
         return this.tsParseFunctionOrConstructorType("TSFunctionType");
       }

packages/babylon/src/types.js

@@ -1154,6 +1154,19 @@ export type TsIntersectionType = TsUnionOrIntersectionTypeBase & {
   type: "TSIntersectionType",
 };
 
+export type TsConditionalType = TsTypeBase & {
+  type: "TSConditionalType",
+  checkType: TsType,
+  extendsType: TsType,
+  trueType: TsType,
+  falseType: tsType,
+};
+
+export type InferType = TsTypeBase & {
+  type: "TSInferType",
+  typeParameter: TypeParameter,
+};
+
 export type TsParenthesizedType = TsTypeBase & {
   type: "TSParenthesizedType",
   typeAnnotation: TsType,

packages/babylon/test/fixtures/typescript/types/conditional-infer/input.js

@@ -0,0 +1 @@
+type Element<T> = T extends (infer U)[] ? U : T;