transform-spread: create TS types (not Flow) when using TS

packages/babel-traverse/src/path/inference/inferer-reference.js

@@ -91,9 +91,15 @@ function getTypeAnnotationBindingConstantViolations(binding, path, name) {
     }
   }
 
-  if (types.length) {
-    return t.createUnionTypeAnnotation(types);
+  if (!types.length) {
+    return;
+  }
+
+  if (types.every(t.isTSTypeAnnotation)) {
+    return t.createTSUnionType(types);
   }
+
+  return t.createUnionTypeAnnotation(types);
 }
 
 function getConstantViolationsBefore(binding, path, functions) {
@@ -201,6 +207,13 @@ function getConditionalAnnotation(binding, path, name) {
   }
 
   if (types.length) {
+    if (types.every(t.isTSTypeAnnotation)) {
+      return {
+        typeAnnotation: t.createTSUnionType(types),
+        ifStatement,
+      };
+    }
+
     return {
       typeAnnotation: t.createUnionTypeAnnotation(types),
       ifStatement,

packages/babel-traverse/src/path/inference/inferers.js

@@ -83,17 +83,29 @@ export function BinaryExpression(node) {
 }
 
 export function LogicalExpression() {
-  return t.createUnionTypeAnnotation([
+  const argumentTypes = [
     this.get("left").getTypeAnnotation(),
     this.get("right").getTypeAnnotation(),
-  ]);
+  ];
+
+  if (argumentTypes.every(t.isTSTypeAnnotation)) {
+    return t.createTSUnionType(argumentTypes);
+  }
+
+  return t.createUnionTypeAnnotation(argumentTypes);
 }
 
 export function ConditionalExpression() {
-  return t.createUnionTypeAnnotation([
+  const argumentTypes = [
     this.get("consequent").getTypeAnnotation(),
     this.get("alternate").getTypeAnnotation(),
-  ]);
+  ];
+
+  if (argumentTypes.every(t.isTSTypeAnnotation)) {
+    return t.createTSUnionType(argumentTypes);
+  }
+
+  return t.createUnionTypeAnnotation(argumentTypes);
 }
 
 export function SequenceExpression() {

packages/babel-traverse/test/fixtures/type-reference/input.ts

@@ -0,0 +1,13 @@
+function bug() {
+  const x = 1 ? a() : b();
+
+  return [...x];
+}
+
+function a(): number[] {
+  return [];
+}
+
+function b(): number[] {
+  return [];
+}

packages/babel-traverse/test/fixtures/type-reference/options.json

@@ -0,0 +1,4 @@
+{
+  "plugins": ["transform-spread"],
+  "presets": ["typescript"]
+}

packages/babel-types/src/builders/typescript/createTSUnionType.js

@@ -0,0 +1,19 @@
+import { TSUnionType } from "../generated";
+import removeTypeDuplicates from "../../modifications/typescript/removeTypeDuplicates";
+
+/**
+ * Takes an array of `types` and flattens them, removing duplicates and
+ * returns a `UnionTypeAnnotation` node containg them.
+ */
+export default function createTSUnionType(
+  typeAnnotations: Array<Object>,
+): Object {
+  const types = typeAnnotations.map(type => type.typeAnnotations);
+  const flattened = removeTypeDuplicates(types);
+
+  if (flattened.length === 1) {
+    return flattened[0];
+  } else {
+    return TSUnionType(flattened);
+  }
+}

packages/babel-types/src/index.js

@@ -10,6 +10,7 @@ export * from "./asserts/generated";
 // builders
 export { default as createTypeAnnotationBasedOnTypeof } from "./builders/flow/createTypeAnnotationBasedOnTypeof";
 export { default as createUnionTypeAnnotation } from "./builders/flow/createUnionTypeAnnotation";
+export { default as createTSUnionType } from "./builders/typescript/createTSUnionType";
 export * from "./builders/generated";
 
 // clone

packages/babel-types/src/modifications/typescript/removeTypeDuplicates.js

@@ -0,0 +1,89 @@
+import {
+  isTSAnyKeyword,
+  isTSUnionType,
+  isTSBooleanKeyword,
+  isTSBigIntKeyword,
+  isTSNeverKeyword,
+  isTSNullKeyword,
+  isTSNumberKeyword,
+  isTSObjectKeyword,
+  isTSStringKeyword,
+  isTSUnknownKeyword,
+  isTSVoidKeyword,
+  isTSUndefinedKeyword,
+  isTSLiteralType,
+  isTSThisType,
+} from "../../validators/generated";
+
+/**
+ * Dedupe type annotations.
+ */
+export default function removeTypeDuplicates(
+  nodes: Array<Object>,
+): Array<Object> {
+  const generics = {};
+  const bases = {};
+
+  // store union type groups to circular references
+  const typeGroups = [];
+
+  const types = [];
+
+  for (let i = 0; i < nodes.length; i++) {
+    const node = nodes[i];
+    if (!node) continue;
+
+    // detect duplicates
+    if (types.indexOf(node) >= 0) {
+      continue;
+    }
+
+    // this type matches anything
+    if (isTSAnyKeyword(node.type)) {
+      return [node];
+    }
+
+    // Basic TS types, analogue of FlowBaseAnnotation
+    if (
+      isTSBooleanKeyword(node) ||
+      isTSBigIntKeyword(node) ||
+      isTSNeverKeyword(node) ||
+      isTSNullKeyword(node) ||
+      isTSNumberKeyword(node) ||
+      isTSObjectKeyword(node) ||
+      isTSStringKeyword(node) ||
+      isTSUndefinedKeyword(node) ||
+      isTSUnknownKeyword(node) ||
+      isTSVoidKeyword(node) ||
+      isTSThisType(node) ||
+      isTSLiteralType(node)
+    ) {
+      bases[node.type] = node;
+      continue;
+    }
+
+    if (isTSUnionType(node)) {
+      if (typeGroups.indexOf(node.types) < 0) {
+        nodes = nodes.concat(node.types);
+        typeGroups.push(node.types);
+      }
+      continue;
+    }
+
+    // TODO: add generic types
+
+    types.push(node);
+  }
+
+  // add back in bases
+  for (const type of Object.keys(bases)) {
+    types.push(bases[type]);
+  }
+
+  // add back in generics
+  for (const name of Object.keys(generics)) {
+    types.push(generics[name]);
+  }
+
+  return types;
+}