Transform mixed type/value imports to type-only imports (Khan#273)

* Transform mixed type/value imports to type-only imports

```ts
import { type A, B } from "./a"
```
is invalid TypeScript, so we transform it into two statements, one
being a [type-only import](https://www.typescriptlang.org/docs/handbook/modules.html#importing-types).

Also updated `trackComments` to handle multiple nodes, which you
might have passed to `replaceWithMultiple`.

* Fixed type checking errors

Sorry, my editor wasn't configured to shout at me.

Author: dwb

src/transform.ts

@@ -1,11 +1,12 @@
-import * as t from "../babel/packages/babel-types/src/index";
+import * as t from "@babel/types";
+import { ImportSpecifier, ImportDeclaration } from "@babel/types";
 
 import * as declare from "./transforms/declare";
 import * as reactTypes from "./transforms/react-types";
 import * as objectType from "./transforms/object-type";
 import * as utilityTypes from "./transforms/utility-types";
 
-import { trackComments } from "./util";
+import { trackComments, partition, returning } from "./util";
 
 const locToString = (loc) =>
   `${loc.start.line}:${loc.start.column}-${loc.end.line}:${loc.end.column}`;
@@ -575,31 +576,89 @@ export const transform = {
   ImportDeclaration: {
     exit(path, state) {
       stripSuffixFromImportSource(path);
+      let replacementNode = null;
+
+      const {
+        importKind,
+        specifiers,
+        source,
+        leadingComments,
+        trailingComments,
+        loc,
+      } = path.node as ImportDeclaration;
+
       if (
-        path.node.importKind === "typeof" &&
-        t.isImportDefaultSpecifier(path.node.specifiers[0])
+        importKind === "typeof" &&
+        t.isImportDefaultSpecifier(specifiers[0])
       ) {
-        const {
-          specifiers,
-          source,
-          leadingComments,
-          trailingComments,
-          loc,
-        } = path.node;
-        const replacementNode = t.tsTypeAliasDeclaration(
+        replacementNode = t.tsTypeAliasDeclaration(
           specifiers[0].local,
           undefined,
           t.tsTypeQuery(t.tsImportType(source, t.identifier("default")))
         );
         replacementNode.leadingComments = leadingComments;
         replacementNode.trailingComments = trailingComments;
         replacementNode.loc = loc;
+      } else if (importKind === "value") {
+        // find any "type" imports within the ImportSpecifier list
+        // and pull them out to separate ImportDeclarations
 
-        trackComments(replacementNode, state);
+        const [valSpecs, typeSpecs] = partition(
+          specifiers,
+          (s): s is ImportSpecifier =>
+            s.type === "ImportSpecifier" && s.importKind === "type"
+        );
 
-        path.replaceWith(replacementNode);
-      } else {
-        trackComments(path.node, state);
+        if (typeSpecs.length > 0) {
+          const typeNode = t.importDeclaration(
+            typeSpecs.map((s) =>
+              t.importSpecifier(
+                returning(t.identifier(s.local.name), (n) => {
+                  n.loc = s.local.loc;
+                }),
+                returning(
+                  t.identifier(
+                    s.imported.type === "Identifier"
+                      ? s.imported.name
+                      : s.imported.value
+                  ),
+                  (n) => {
+                    n.loc = s.imported.loc;
+                  }
+                )
+              )
+            ),
+            source
+          );
+          typeNode.leadingComments = leadingComments;
+          typeNode.importKind = "type";
+          typeNode.loc = loc;
+
+          const valNode = t.importDeclaration(valSpecs, source);
+          valNode.trailingComments = trailingComments;
+          valNode.loc = {
+            start: {
+              line: loc.start.line + 1,
+              column: 0,
+            },
+            end: {
+              line: loc.start.line + 1,
+              column: 0,
+            },
+          };
+
+          replacementNode = [typeNode, valNode];
+        }
+      }
+
+      trackComments(replacementNode ?? path.node, state);
+
+      if (replacementNode != null) {
+        if (Array.isArray(replacementNode)) {
+          path.replaceWithMultiple(replacementNode);
+        } else {
+          path.replaceWith(replacementNode);
+        }
       }
     },
   },

src/util.ts

@@ -20,28 +20,53 @@
  * @param {*} state
  */
 export const trackComments = (node, state) => {
-  if (node.leadingComments) {
-    for (const comment of node.leadingComments) {
+  let leadingNode = node,
+    trailingNode = node;
+
+  if (Array.isArray(node)) {
+    leadingNode = node[0];
+    trailingNode = node[node.length - 1];
+  }
+
+  if (leadingNode.leadingComments) {
+    for (const comment of leadingNode.leadingComments) {
       const { start, end } = comment;
       const key = `${start}:${end}`;
 
       if (state.commentsToNodesMap.has(key)) {
-        state.commentsToNodesMap.get(key).leading = node;
+        state.commentsToNodesMap.get(key).leading = leadingNode;
       } else {
-        state.commentsToNodesMap.set(key, { leading: node });
+        state.commentsToNodesMap.set(key, { leading: leadingNode });
       }
     }
   }
-  if (node.trailingComments) {
-    for (const comment of node.trailingComments) {
+  if (trailingNode.trailingComments) {
+    for (const comment of trailingNode.trailingComments) {
       const { start, end } = comment;
       const key = `${start}:${end}`;
 
       if (state.commentsToNodesMap.has(key)) {
-        state.commentsToNodesMap.get(key).trailing = node;
+        state.commentsToNodesMap.get(key).trailing = trailingNode;
       } else {
-        state.commentsToNodesMap.set(key, { trailing: node });
+        state.commentsToNodesMap.set(key, { trailing: trailingNode });
       }
     }
   }
 };
+
+export function partition<T, U extends T>(
+  iter: Iterable<T>,
+  fn: (val: T) => val is U
+): [T[], U[]] {
+  const l = [],
+    r = [];
+  for (const v of iter) {
+    (fn(v) ? r : l).push(v);
+  }
+  return [l, r];
+}
+
+export function returning<T>(v: T, fn: (arg: T) => unknown): T {
+  fn(v);
+  return v;
+}

test/fixtures/convert/imports/import_type_within_braces/flow.js

@@ -0,0 +1,3 @@
+// comment before
+import { type A, B } from "./a.js";
+// comment after

test/fixtures/convert/imports/import_type_within_braces/ts.js

@@ -0,0 +1,3 @@
+// comment before
+import type { A } from "./a";
+import { B } from "./a"; // comment after

test/fixtures/convert/imports/named_import_specifier_kind/ts.js

@@ -1,2 +1,4 @@
-import { type A, type B, C } from "./depA";
-import { type D, type E, F } from "../depB";
+import type { A, B } from "./depA";
+import { C } from "./depA";
+import type { D, E } from "../depB";
+import { F } from "../depB";