Support TypeScript 4.5 type-only import/export specifiers

packages/babel-generator/src/generators/modules.ts

@@ -40,6 +40,11 @@ export function ExportDefaultSpecifier(
 }
 
 export function ExportSpecifier(this: Printer, node: t.ExportSpecifier) {
+  if (node.exportKind === "type") {
+    this.word("type");
+    this.space();
+  }
+
   this.print(node.local, node);
   // @ts-expect-error todo(flow-ts) maybe check node type instead of relying on name to be undefined on t.StringLiteral
   if (node.exported && node.local.name !== node.exported.name) {

packages/babel-generator/test/fixtures/typescript/type-only-export-specifier/input.js

@@ -0,0 +1 @@
+export { type foo } from "foo";

packages/babel-generator/test/fixtures/typescript/type-only-export-specifier/output.js

@@ -0,0 +1 @@
+export { type foo } from "foo";

packages/babel-generator/test/fixtures/typescript/type-only-import-specifier/input.js

@@ -0,0 +1 @@
+import { type foo } from "foo";

packages/babel-generator/test/fixtures/typescript/type-only-import-specifier/output.js

@@ -0,0 +1 @@
+import { type foo } from "foo";

packages/babel-parser/src/parser/statement.js

@@ -1872,7 +1872,8 @@ export default class StatementParser extends ExpressionParser {
   maybeParseExportNamedSpecifiers(node: N.Node): boolean {
     if (this.match(tt.braceL)) {
       if (!node.specifiers) node.specifiers = [];
-      node.specifiers.push(...this.parseExportSpecifiers());
+      const isTypeExport = node.exportKind === "type";
+      node.specifiers.push(...this.parseExportSpecifiers(isTypeExport));
 
       node.source = null;
       node.declaration = null;
@@ -2152,7 +2153,7 @@ export default class StatementParser extends ExpressionParser {
 
   // Parses a comma-separated list of module exports.
 
-  parseExportSpecifiers(): Array<N.ExportSpecifier> {
+  parseExportSpecifiers(isInTypeExport: boolean): Array<N.ExportSpecifier> {
     const nodes = [];
     let first = true;
 
@@ -2168,15 +2169,22 @@ export default class StatementParser extends ExpressionParser {
       }
 
       const node = this.startNode();
+      const isMaybeTypeOnly = this.isContextual(tt._type);
       const isString = this.match(tt.string);
-      const local = this.parseModuleExportName();
-      node.local = local;
-      if (this.eatContextual(tt._as)) {
+      node.local = this.parseModuleExportName();
+      const canParseAsKeyword = this.parseTypeOnlyImportExportSpecifier(
+        node,
+        /* isImport */ false,
+        isString,
+        isInTypeExport,
+        isMaybeTypeOnly,
+      );
+      if (canParseAsKeyword && this.eatContextual(tt._as)) {
         node.exported = this.parseModuleExportName();
       } else if (isString) {
-        node.exported = cloneStringLiteral(local);
-      } else {
-        node.exported = cloneIdentifier(local);
+        node.exported = cloneStringLiteral(node.local);
+      } else if (!node.exported) {
+        node.exported = cloneIdentifier(node.local);
       }
       nodes.push(this.finishNode(node, "ExportSpecifier"));
     }
@@ -2436,12 +2444,32 @@ export default class StatementParser extends ExpressionParser {
     }
   }
 
+  parseTypeOnlyImportExportSpecifier(
+    /* eslint-disable no-unused-vars -- used in typescript plugin */
+    node: any,
+    isImport: boolean,
+    isStringSpecifier: boolean,
+    isInTypeOnlyImportExport: boolean,
+    isMaybeTypeOnly: boolean,
+    /* eslint-enable no-unused-vars */
+  ): boolean {
+    return true;
+  }
+
   // https://tc39.es/ecma262/#prod-ImportSpecifier
   parseImportSpecifier(node: N.ImportDeclaration): void {
     const specifier = this.startNode();
     const importedIsString = this.match(tt.string);
+    const isMaybeTypeOnly = this.isContextual(tt._type);
     specifier.imported = this.parseModuleExportName();
-    if (this.eatContextual(tt._as)) {
+    const canParseAsKeyword = this.parseTypeOnlyImportExportSpecifier(
+      specifier,
+      /* isImport */ true,
+      importedIsString,
+      /* isInTypeOnlyImportExport */ node.importKind === "type",
+      isMaybeTypeOnly,
+    );
+    if (canParseAsKeyword && this.eatContextual(tt._as)) {
       specifier.local = this.parseIdentifier();
     } else {
       const { imported } = specifier;
@@ -2453,7 +2481,9 @@ export default class StatementParser extends ExpressionParser {
         );
       }
       this.checkReservedWord(imported.name, specifier.start, true, true);
-      specifier.local = cloneIdentifier(imported);
+      if (!specifier.local) {
+        specifier.local = cloneIdentifier(imported);
+      }
     }
     this.checkLVal(specifier.local, "import specifier", BIND_LEXICAL);
     node.specifiers.push(this.finishNode(specifier, "ImportSpecifier"));

packages/babel-parser/src/plugins/flow/index.js

@@ -2123,7 +2123,9 @@ export default (superClass: Class<Parser>): Class<Parser> =>
 
         if (this.match(tt.braceL)) {
           // export type { foo, bar };
-          node.specifiers = this.parseExportSpecifiers();
+          node.specifiers = this.parseExportSpecifiers(
+            /* isInTypeExport */ true,
+          );
           this.parseExportFrom(node);
           return null;
         } else {

packages/babel-parser/src/plugins/typescript/index.js

@@ -11,6 +11,7 @@ import {
   tokenIsTSDeclarationStart,
   tokenIsTSTypeOperator,
   tokenOperatorPrecedence,
+  tokenIsKeywordOrIdentifier,
   tt,
   type TokenType,
 } from "../../tokenizer/types";
@@ -147,6 +148,10 @@ const TSErrors = makeErrorTemplates(
       "Type annotations must come before default assignments, e.g. instead of `age = 25: number` use `age: number = 25`.",
     TypeImportCannotSpecifyDefaultAndNamed:
       "A type-only import can specify a default import or named bindings, but not both.",
+    TypeModifierIsUsedInTypeExports:
+      "The 'type' modifier cannot be used on a named export when 'export type' is used on its export statement.",
+    TypeModifierIsUsedInTypeImports:
+      "The 'type' modifier cannot be used on a named import when 'import type' is used on its import statement.",
     UnexpectedParameterModifier:
       "A parameter property is only allowed in a constructor implementation.",
     UnexpectedReadonly:
@@ -3311,4 +3316,78 @@ export default (superClass: Class<Parser>): Class<Parser> =>
       }
       return super.getExpression();
     }
+
+    parseTypeOnlyImportExportSpecifier(
+      node: any,
+      isImport: boolean,
+      isStringSpecifier: boolean,
+      isInTypeOnlyImportExport: boolean,
+      isMaybeTypeOnly: boolean,
+    ): boolean {
+      const leftOfAsKey = isImport ? "imported" : "local";
+      const rightOfAsKey = isImport ? "local" : "exported";
+
+      let leftOfAs = node[leftOfAsKey];
+      let rightOfAs;
+
+      let hasTypeSpecifier = false;
+      let canParseAsKeyword = true;
+
+      const pos = leftOfAs.start;
+
+      // https://github.com/microsoft/TypeScript/blob/fc4f9d83d5939047aa6bb2a43965c6e9bbfbc35b/src/compiler/parser.ts#L7411-L7456
+      if (!isStringSpecifier && isMaybeTypeOnly) {
+        // import { type } from "mod";          - hasTypeSpecifier: false, leftOfAs: type
+        // import { type as } from "mod";       - hasTypeSpecifier: true,  leftOfAs: as
+        // import { type as as } from "mod";    - hasTypeSpecifier: false, leftOfAs: type, rightOfAs: as
+        // import { type as as as } from "mod"; - hasTypeSpecifier: true,  leftOfAs: as,   rightOfAs: as
+        if (this.isContextual(tt._as)) {
+          // { type as ...? }
+          const firstAs = this.parseIdentifier();
+          if (this.isContextual(tt._as)) {
+            // { type as as ...? }
+            const secondAs = this.parseIdentifier();
+            if (tokenIsKeywordOrIdentifier(this.state.type)) {
+              // { type as as something }
+              hasTypeSpecifier = true;
+              leftOfAs = firstAs;
+              rightOfAs = this.parseIdentifier();
+              canParseAsKeyword = false;
+            } else {
+              // { type as as }
+              rightOfAs = secondAs;
+              canParseAsKeyword = false;
+            }
+          } else if (tokenIsKeywordOrIdentifier(this.state.type)) {
+            // { type as something }
+            canParseAsKeyword = false;
+            rightOfAs = this.parseIdentifier();
+          } else {
+            // { type as }
+            hasTypeSpecifier = true;
+            leftOfAs = firstAs;
+          }
+        } else if (tokenIsKeywordOrIdentifier(this.state.type)) {
+          // { type something ...? }
+          hasTypeSpecifier = true;
+          leftOfAs = this.parseIdentifier();
+        }
+      }
+      node[leftOfAsKey] = leftOfAs;
+      node[rightOfAsKey] = rightOfAs;
+
+      const kindKey = isImport ? "importKind" : "exportKind";
+      node[kindKey] = hasTypeSpecifier ? "type" : "value";
+
+      if (hasTypeSpecifier && isInTypeOnlyImportExport) {
+        this.raise(
+          pos,
+          isImport
+            ? TSErrors.TypeModifierIsUsedInTypeImports
+            : TSErrors.TypeModifierIsUsedInTypeExports,
+        );
+      }
+
+      return canParseAsKeyword;
+    }
   };

packages/babel-parser/test/fixtures/typescript/export/export-type-from/output.json

@@ -20,6 +20,7 @@
               "start":14,"end":15,"loc":{"start":{"line":1,"column":14},"end":{"line":1,"column":15},"identifierName":"T"},
               "name": "T"
             },
+            "exportKind": "value",
             "exported": {
               "type": "Identifier",
               "start":14,"end":15,"loc":{"start":{"line":1,"column":14},"end":{"line":1,"column":15},"identifierName":"T"},

packages/babel-parser/test/fixtures/typescript/export/export-type/output.json

@@ -42,6 +42,7 @@
               "start":26,"end":27,"loc":{"start":{"line":2,"column":14},"end":{"line":2,"column":15},"identifierName":"A"},
               "name": "A"
             },
+            "exportKind": "value",
             "exported": {
               "type": "Identifier",
               "start":26,"end":27,"loc":{"start":{"line":2,"column":14},"end":{"line":2,"column":15},"identifierName":"A"},