flow-api-translator 0.36.1 → 0.327.0

package/dist/flowDefToTSDef.js

@@ -1,35 +1,17 @@
-/**
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- *
- * 
- * @format
- */
 'use strict';
 
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.flowDefToTSDef = flowDefToTSDef;
-
-var FlowESTree = _interopRequireWildcard(require("hermes-estree"));
-
+var FlowESTree = _interopRequireWildcard(require("flow-estree"));
 var TSESTree = _interopRequireWildcard(require("./utils/ts-estree-ast-types"));
-
-var _hermesTransform = require("hermes-transform");
-
+var _flowTransform = require("flow-transform");
 var _ErrorUtils = require("./utils/ErrorUtils");
-
 var _DocblockUtils = require("./utils/DocblockUtils");
-
+var _TSNodeUtils = require("./utils/TSNodeUtils");
 var _os = require("os");
-
-function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
-
-function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
-
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
 const DUMMY_LOC = {
   start: {
     line: 1,
@@ -40,36 +22,57 @@ const DUMMY_LOC = {
     column: 0
   }
 };
-
 function constructFlowNode(node) {
   return node;
 }
-
-const cloneJSDocCommentsToNewNode = // $FlowExpectedError[incompatible-type] - trust me this re-type is 100% safe
-_hermesTransform.cloneJSDocCommentsToNewNode;
-const makeCommentOwnLine = // $FlowExpectedError[incompatible-type] - trust me this re-type is 100% safe
-_hermesTransform.makeCommentOwnLine;
+const cloneJSDocCommentsToNewNode = _flowTransform.cloneJSDocCommentsToNewNode;
+const makeCommentOwnLine = _flowTransform.makeCommentOwnLine;
+function normalizeDeclareComponentParams(params, rest, onUnexpected) {
+  const normalizedParams = [];
+  let normalizedRest = rest;
+  const toComponentTypeParameter = (name, local, source) => {
+    if (local.type !== 'Identifier' || local.typeAnnotation == null) {
+      throw onUnexpected(source, `DeclareComponent: expected an annotated identifier parameter, got "${local.type}"`);
+    }
+    return constructFlowNode({
+      type: 'ComponentTypeParameter',
+      name,
+      typeAnnotation: local.typeAnnotation.typeAnnotation,
+      optional: local.optional,
+      loc: source.loc,
+      range: source.range
+    });
+  };
+  for (const param of params) {
+    switch (param.type) {
+      case 'ComponentTypeParameter':
+        normalizedParams.push(param);
+        break;
+      case 'ComponentParameter':
+        normalizedParams.push(toComponentTypeParameter(param.name, param.local, param));
+        break;
+      case 'RestElement':
+        normalizedRest = toComponentTypeParameter(null, param.argument, param);
+        break;
+    }
+  }
+  return [normalizedParams, normalizedRest];
+}
 const VALID_REACT_IMPORTS = new Set(['React', 'react']);
-
 function isValidReactImportOrGlobal(id) {
   return VALID_REACT_IMPORTS.has(id.name) || id.name.startsWith('React$');
 }
-
-let shouldAddReactImport = null; // Returns appropriate Identifier for `React` import.
-// If a global is in use, set a flag to indicate that we should add the import.
-
+let shouldAddReactImport = null;
 function getReactIdentifier(hasReactImport) {
   if (shouldAddReactImport !== false) {
     shouldAddReactImport = !hasReactImport;
   }
-
   return {
     type: 'Identifier',
     loc: DUMMY_LOC,
     name: `React`
   };
 }
-
 function flowDefToTSDef(originalCode, ast, scopeManager, opts) {
   const tsBody = [];
   const tsProgram = {
@@ -81,13 +84,9 @@ function flowDefToTSDef(originalCode, ast, scopeManager, opts) {
   };
   shouldAddReactImport = null;
   const [transform, code] = getTransforms(originalCode, scopeManager, opts);
-
   for (const node of ast.body) {
     if (node.type in transform) {
-      const result = transform[// $FlowExpectedError[prop-missing]
-      // $FlowFixMe[incompatible-type]
-      node.type]( // $FlowExpectedError[incompatible-type]
-      node);
+      const result = transform[node.type](node);
       tsBody.push(...(Array.isArray(result) ? result : [result]));
     } else {
       throw (0, _ErrorUtils.unexpectedTranslationError)(node, `Unexpected node type ${node.type}`, {
@@ -95,7 +94,6 @@ function flowDefToTSDef(originalCode, ast, scopeManager, opts) {
       });
     }
   }
-
   if (shouldAddReactImport === true) {
     tsBody.unshift({
       type: 'ImportDeclaration',
@@ -119,36 +117,28 @@ function flowDefToTSDef(originalCode, ast, scopeManager, opts) {
       importKind: 'value'
     });
   }
-
   return [tsProgram, code];
 }
-
 const getTransforms = (originalCode, scopeManager, opts) => {
   let code = originalCode;
-
   function translationError(node, message) {
     return (0, _ErrorUtils.translationError)(node, message, {
       code
     });
   }
-
   function unexpectedTranslationError(node, message) {
     return (0, _ErrorUtils.unexpectedTranslationError)(node, message, {
       code
     });
   }
-
   function unsupportedFeatureMessage(thing) {
     return `Unsupported feature: Translating "${thing}" is currently not supported.`;
   }
-
   function buildCodeFrameForComment(node, message) {
     return (0, _ErrorUtils.buildCodeFrame)(node, message, code, false);
   }
-
   function addErrorComment(node, message) {
     var _node$comments;
-
     const comment = {
       type: 'Block',
       loc: DUMMY_LOC,
@@ -156,17 +146,12 @@ const getTransforms = (originalCode, scopeManager, opts) => {
       leading: true,
       printed: false
     };
-    code = makeCommentOwnLine(code, comment); // $FlowExpectedError[prop-missing]
-    // $FlowExpectedError[cannot-write]
-
-    (_node$comments = node.comments) != null ? _node$comments : node.comments = []; // $FlowExpectedError[incompatible-type]
-
+    code = makeCommentOwnLine(code, comment);
+    (_node$comments = node.comments) != null ? _node$comments : node.comments = [];
     node.comments.push(comment);
   }
-
   function unsupportedAnnotation(node, thing) {
     const message = unsupportedFeatureMessage(thing);
-
     if (opts.recoverFromErrors) {
       const codeFrame = buildCodeFrameForComment(node, message);
       const newNode = {
@@ -176,13 +161,10 @@ const getTransforms = (originalCode, scopeManager, opts) => {
       addErrorComment(newNode, codeFrame);
       return newNode;
     }
-
     throw translationError(node, message);
   }
-
   function unsupportedDeclaration(node, thing, id, declare = false, typeParameters = null) {
     const message = unsupportedFeatureMessage(thing);
-
     if (opts.recoverFromErrors) {
       const codeFrame = buildCodeFrameForComment(node, message);
       const newNode = {
@@ -199,37 +181,28 @@ const getTransforms = (originalCode, scopeManager, opts) => {
       addErrorComment(newNode, codeFrame);
       return newNode;
     }
-
     throw translationError(node, message);
   }
-
   const topScope = (() => {
     const globalScope = scopeManager.globalScope;
-
     if (globalScope.childScopes.length > 0 && globalScope.childScopes[0].type === 'module') {
       return globalScope.childScopes[0];
     }
-
     return globalScope;
   })();
-
   function isReactImport(scopeNode, name) {
     let currentScope = (() => {
       let scope = null;
       let node = scopeNode;
-
       while (!scope && node) {
         scope = scopeManager.acquire(node, true);
         node = node.parent;
       }
-
       return scope;
     })();
-
     if (currentScope == null) {
       throw new Error('unable to resolve scope');
     }
-
     const variableDef = (() => {
       while (currentScope != null) {
         for (const variable of currentScope.variables) {
@@ -237,105 +210,44 @@ const getTransforms = (originalCode, scopeManager, opts) => {
             return variable;
           }
         }
-
         currentScope = currentScope.upper;
       }
-    })(); // No variable found, it is not imported.
-    // It could be a global though if isValidReactImportOrGlobal returns true.
-
-
+    })();
     if (variableDef == null) {
       return false;
     }
-
-    const def = variableDef.defs[0]; // Detect:
-
+    const def = variableDef.defs[0];
     switch (def.type) {
-      // import React from 'react';
-      // import * as React from 'react';
       case 'ImportBinding':
         {
           if (def.node.type === 'ImportDefaultSpecifier' || def.node.type === 'ImportNamespaceSpecifier') {
             return VALID_REACT_IMPORTS.has(def.parent.source.value);
           }
-
           return false;
         }
-      // Globals
-
       case 'ImplicitGlobalVariable':
         {
           return VALID_REACT_IMPORTS.has(name);
         }
-      // TODO Handle:
-      // const React = require('react');
-      // const Something = React;
     }
-
     return false;
   }
-
   function EnumImpl(node) {
     const body = node.body;
-
     if (body.type === 'EnumSymbolBody') {
-      /*
-      There's unfortunately no way for us to support this in a clean way.
-      We can get really close using this code:
-      ```
-      declare namespace SymbolEnum {
-          export const member1: unique symbol;
-          export type member1 = typeof member1;
-           export const member2: unique symbol;
-          export type member2 = typeof member2;
-      }
-      type SymbolEnum = typeof SymbolEnum[keyof typeof SymbolEnum];
-      ```
-       However as explained in https://github.com/microsoft/TypeScript/issues/43657:
-      "A unique symbol type is never transferred from one declaration to another through inference."
-      This intended behaviour in TS means that the usage of the fake-enum would look like this:
-      ```
-      const value: SymbolEnum.member1 = SymbolEnum.member1;
-      //           ^^^^^^^^^^^^^^^^^^ required to force TS to retain the information
-      ```
-      Which is really clunky and shitty. It definitely works, but ofc it's not good.
-      We can go with this design if users are okay with it!
-       Considering how rarely used symbol enums are ATM, let's just put a pin in it for now.
-      */
       return unsupportedDeclaration(node, 'symbol enums', node.id, FlowESTree.isDeclareEnum(node));
     }
-
     if (body.type === 'EnumBooleanBody') {
-      /*
-      TODO - TS enums only allow strings or numbers as their values - not booleans.
-      This means we need a non-ts-enum representation of the enum.
-      We can support boolean enums using a construct like this:
-      ```ts
-      declare namespace BooleanEnum {
-          export const member1: true;
-          export type member1 = typeof member1;
-           export const member2: false;
-          export type member2 = typeof member1;
-      }
-      declare type BooleanEnum = boolean;
-      ```
-       But it's pretty clunky and ugly.
-      Considering how rarely used boolean enums are ATM, let's just put a pin in it for now.
-      */
       return unsupportedDeclaration(node, 'boolean enums', node.id, FlowESTree.isDeclareEnum(node));
     }
-
     const members = [];
-
     for (const member of body.members) {
       switch (member.type) {
         case 'EnumDefaultedMember':
           {
             if (body.type === 'EnumNumberBody') {
-              // this should be impossible!
               throw unexpectedTranslationError(member, 'Unexpected defaulted number enum member');
             }
-
             members.push({
               type: 'TSEnumMember',
               loc: DUMMY_LOC,
@@ -350,7 +262,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
             });
             break;
           }
-
         case 'EnumNumberMember':
         case 'EnumStringMember':
           members.push({
@@ -362,7 +273,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
           });
       }
     }
-
     const bodyRepresentationType = body.type === 'EnumNumberBody' ? {
       type: 'TSNumberKeyword',
       loc: DUMMY_LOC
@@ -383,22 +293,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         loc: DUMMY_LOC
       },
       members
-    }, // flow also exports `.cast`, `.isValid`, `.members` and `.getName` for enums
-    // we can use declaration merging to declare these functions on the enum:
-
-    /*
-    declare enum Foo {
-      A = 1,
-      B = 2,
-    }
-    declare namespace Foo {
-      export function cast(value: number | null | undefined): Foo;
-      export function isValid(value: number | null | undefined): value is Foo;
-      export function members(): IterableIterator<Foo>;
-      export function getName(value: Foo): string;
-    }
-    */
-    {
+    }, {
       type: 'TSModuleDeclaration',
       loc: DUMMY_LOC,
       declare: true,
@@ -407,8 +302,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
       body: {
         type: 'TSModuleBlock',
         loc: DUMMY_LOC,
-        body: [// export function cast(value: number | null | undefined): Foo
-        {
+        body: [{
           type: 'ExportNamedDeclaration',
           loc: DUMMY_LOC,
           declaration: {
@@ -456,8 +350,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
           source: null,
           exportKind: 'value',
           assertions: []
-        }, // export function isValid(value: number | null | undefined): value is Foo;
-        {
+        }, {
           type: 'ExportNamedDeclaration',
           loc: DUMMY_LOC,
           declaration: {
@@ -519,8 +412,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
           source: null,
           exportKind: 'value',
           assertions: []
-        }, // export function members(): IterableIterator<Foo>;
-        {
+        }, {
           type: 'ExportNamedDeclaration',
           loc: DUMMY_LOC,
           declaration: {
@@ -546,7 +438,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                   loc: DUMMY_LOC,
                   name: 'IterableIterator'
                 },
-                typeParameters: {
+                typeArguments: {
                   type: 'TSTypeParameterInstantiation',
                   loc: DUMMY_LOC,
                   params: [{
@@ -562,8 +454,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
           source: null,
           exportKind: 'value',
           assertions: []
-        }, // export function getName(value: Foo): string;
-        {
+        }, {
           type: 'ExportNamedDeclaration',
           loc: DUMMY_LOC,
           declaration: {
@@ -608,133 +499,92 @@ const getTransforms = (originalCode, scopeManager, opts) => {
       }
     }];
   }
-
   const getPlaceholderNameForTypeofImport = (() => {
     let typeof_import_count = 0;
     return () => `$$IMPORT_TYPEOF_${++typeof_import_count}$$`;
   })();
-
   const transformTypeAnnotationType = node => {
     switch (node.type) {
       case 'AnyTypeAnnotation':
         return transform.AnyTypeAnnotation(node);
-
       case 'ArrayTypeAnnotation':
         return transform.ArrayTypeAnnotation(node);
-
       case 'BigIntLiteralTypeAnnotation':
         return transform.BigIntLiteralTypeAnnotation(node);
-
       case 'BigIntTypeAnnotation':
         return transform.BigIntTypeAnnotation(node);
-
       case 'BooleanLiteralTypeAnnotation':
         return transform.BooleanLiteralTypeAnnotation(node);
-
       case 'BooleanTypeAnnotation':
         return transform.BooleanTypeAnnotation(node);
-
       case 'EmptyTypeAnnotation':
         return transform.EmptyTypeAnnotation(node);
-
       case 'ExistsTypeAnnotation':
         return transform.ExistsTypeAnnotation(node);
-
       case 'FunctionTypeAnnotation':
         return transform.FunctionTypeAnnotation(node);
-
       case 'GenericTypeAnnotation':
         return transform.GenericTypeAnnotation(node);
-
       case 'IndexedAccessType':
         return transform.IndexedAccessType(node);
-
       case 'InterfaceTypeAnnotation':
         return transform.InterfaceTypeAnnotation(node);
-
       case 'IntersectionTypeAnnotation':
         return transform.IntersectionTypeAnnotation(node);
-
       case 'MixedTypeAnnotation':
         return transform.MixedTypeAnnotation(node);
-
       case 'NullLiteralTypeAnnotation':
         return transform.NullLiteralTypeAnnotation(node);
-
       case 'NullableTypeAnnotation':
         return transform.NullableTypeAnnotation(node);
-
       case 'NumberLiteralTypeAnnotation':
         return transform.NumberLiteralTypeAnnotation(node);
-
       case 'NumberTypeAnnotation':
         return transform.NumberTypeAnnotation(node);
-
       case 'ObjectTypeAnnotation':
         return transform.ObjectTypeAnnotation(node);
-
       case 'OptionalIndexedAccessType':
         return transform.OptionalIndexedAccessType(node);
-
       case 'QualifiedTypeIdentifier':
         return transform.QualifiedTypeIdentifier(node);
-
       case 'StringLiteralTypeAnnotation':
         return transform.StringLiteralTypeAnnotation(node);
-
       case 'StringTypeAnnotation':
         return transform.StringTypeAnnotation(node);
-
       case 'SymbolTypeAnnotation':
         return transform.SymbolTypeAnnotation(node);
-
       case 'ThisTypeAnnotation':
         return transform.ThisTypeAnnotation(node);
-
       case 'TupleTypeAnnotation':
         return transform.TupleTypeAnnotation(node);
-
       case 'TypeofTypeAnnotation':
         return transform.TypeofTypeAnnotation(node);
-
       case 'UnionTypeAnnotation':
         return transform.UnionTypeAnnotation(node);
-
       case 'VoidTypeAnnotation':
         return transform.VoidTypeAnnotation(node);
-
       case 'TypePredicate':
         return transform.TypePredicateAnnotation(node);
-
       case 'ConditionalTypeAnnotation':
         return transform.ConditionalTypeAnnotation(node);
-
       case 'InferTypeAnnotation':
         return transform.InferTypeAnnotation(node);
-
       case 'KeyofTypeAnnotation':
         return transform.KeyofTypeAnnotation(node);
-
       case 'TypeOperator':
         return transform.TypeOperator(node);
-
       case 'ComponentTypeAnnotation':
         return transform.ComponentTypeAnnotation(node);
-
       case 'NeverTypeAnnotation':
         return transform.NeverTypeAnnotation(node);
-
       case 'UndefinedTypeAnnotation':
         return transform.UndefinedTypeAnnotation(node);
-
       case 'UnknownTypeAnnotation':
         return transform.UnknownTypeAnnotation(node);
-
       default:
         throw unexpectedTranslationError(node, `Unhandled type ${node.type}`);
     }
   };
-
   const wellKnownSymbols = new Set(['iterator', 'asyncIterator', 'dispose', 'asyncDispose']);
   const transform = {
     AnyTypeAnnotation(_node) {
@@ -743,7 +593,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         loc: DUMMY_LOC
       };
     },
-
     ArrayTypeAnnotation(node) {
       return {
         type: 'TSArrayType',
@@ -751,7 +600,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         elementType: transformTypeAnnotationType(node.elementType)
       };
     },
-
     BigIntLiteral(node) {
       return {
         type: 'Literal',
@@ -761,17 +609,9 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         value: node.value
       };
     },
-
     BigIntLiteralTypeAnnotation(node) {
       var _node$bigint;
-
-      // technically hermes doesn't support this yet
-      // but future proofing amirite
-      const bigint = // $FlowExpectedError[prop-missing]
-      (_node$bigint = node.bigint) != null ? _node$bigint : node.raw // estree spec is to not have a trailing `n` on this property
-      // https://github.com/estree/estree/blob/db962bb417a97effcfe9892f87fbb93c81a68584/es2020.md#bigintliteral
-      .replace(/n$/, '') // `BigInt` doesn't accept numeric separator and `bigint` property should not include numeric separator
-      .replace(/_/, '');
+      const bigint = (_node$bigint = node.bigint) != null ? _node$bigint : node.raw.replace(/n$/, '').replace(/_/, '');
       return {
         type: 'TSLiteralType',
         loc: DUMMY_LOC,
@@ -784,14 +624,12 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         }
       };
     },
-
     BigIntTypeAnnotation(_node) {
       return {
         type: 'TSBigIntKeyword',
         loc: DUMMY_LOC
       };
     },
-
     BooleanLiteral(node) {
       return {
         type: 'Literal',
@@ -800,7 +638,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         value: node.value
       };
     },
-
     BooleanLiteralTypeAnnotation(node) {
       return {
         type: 'TSLiteralType',
@@ -813,53 +650,41 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         }
       };
     },
-
     BooleanTypeAnnotation(_node) {
       return {
         type: 'TSBooleanKeyword',
         loc: DUMMY_LOC
       };
     },
-
     ClassImplements(node) {
       return {
         type: 'TSClassImplements',
         loc: DUMMY_LOC,
         expression: transform.Identifier(node.id, false),
-        typeParameters: transform.TypeParameterInstantiation(node.typeParameters)
+        typeArguments: transform.TypeParameterInstantiation(node.typeParameters)
       };
     },
-
     DeclareClass(node) {
       const classMembers = [];
       const transformedBody = transform.ObjectTypeAnnotation(node.body);
-
       if (transformedBody.type !== 'TSTypeLiteral') {
         return unsupportedDeclaration(node.body, 'Spreads in declare class are not allowed', node.id, true, node.typeParameters);
       }
-
       for (const member of transformedBody.members) {
-        // TS uses the real ClassDeclaration AST so we need to
-        // make the signatures real methods/properties
         switch (member.type) {
           case 'TSIndexSignature':
             {
               classMembers.push(member);
               break;
             }
-
           case 'TSMethodSignature':
             {
-              // flow just creates a method signature like any other for a constructor
-              // but the proper AST has `kind = 'constructor'`
               const isConstructor = (() => {
                 if (member.computed === true) {
                   return false;
                 }
-
                 return member.key.type === 'Identifier' && member.key.name === 'constructor' || member.key.type === 'Literal' && member.key.value === 'constructor';
               })();
-
               if (isConstructor) {
                 const newNode = {
                   type: 'MethodDefinition',
@@ -885,7 +710,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                     generator: false,
                     id: null,
                     params: member.params,
-                    // constructors explicitly have no return type
                     returnType: undefined,
                     typeParameters: member.typeParameters
                   }
@@ -894,13 +718,10 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                 classMembers.push(newNode);
               } else {
                 var _member$static;
-
                 const [key, computed] = (() => {
                   const _key = member.key;
-
                   if (_key.type === 'Identifier' && _key.name.startsWith('@@')) {
                     const name = _key.name.slice(2);
-
                     if (wellKnownSymbols.has(name)) {
                       return [{
                         type: 'MemberExpression',
@@ -922,10 +743,8 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                       }, true];
                     }
                   }
-
                   return [member.key, member.computed];
                 })();
-
                 const newNode = {
                   type: 'MethodDefinition',
                   loc: DUMMY_LOC,
@@ -953,14 +772,11 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                 cloneJSDocCommentsToNewNode(member, newNode);
                 classMembers.push(newNode);
               }
-
               break;
             }
-
           case 'TSPropertySignature':
             {
               var _member$computed, _member$static2;
-
               const newNode = {
                 type: 'PropertyDefinition',
                 loc: DUMMY_LOC,
@@ -978,35 +794,15 @@ const getTransforms = (originalCode, scopeManager, opts) => {
               classMembers.push(newNode);
               break;
             }
-
           case 'TSCallSignatureDeclaration':
             {
               var _node$body$callProper;
-
-              /*
-              TODO - callProperties
-              It's not valid to directly declare a call property on a class in TS
-              You can do it, but it's a big complication in the AST:
-              ```ts
-              declare Class {
-                // ...
-              }
-              interface ClassConstructor {
-                new (): Class;
-                // call sigs
-                (): Type;
-              }
-              ```
-              Let's put a pin in it for now and deal with it later if the need arises.
-              */
               return unsupportedDeclaration((_node$body$callProper = node.body.callProperties[0]) != null ? _node$body$callProper : node.body, 'call signatures on classes', node.id, true, node.typeParameters);
             }
-
           default:
             throw unexpectedTranslationError(node.body, `Unexpected member type ${member.type}`);
         }
       }
-
       const superClass = node.extends.length > 0 ? node.extends[0] : undefined;
       return {
         type: 'ClassDeclaration',
@@ -1020,18 +816,14 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         id: transform.Identifier(node.id, false),
         implements: node.implements == null ? undefined : node.implements.map(transform.ClassImplements),
         superClass: superClass == null ? null : superClass.id.type === 'QualifiedTypeIdentifier' ? transform.QualifiedTypeIdentifier(superClass.id) : transform.Identifier(superClass.id, false),
-        superTypeParameters: transform.TypeParameterInstantiation(superClass == null ? void 0 : superClass.typeParameters),
-        typeParameters: node.typeParameters == null ? undefined : transform.TypeParameterDeclaration(node.typeParameters) // TODO - mixins??
-
+        superTypeArguments: transform.TypeParameterInstantiation(superClass == null ? void 0 : superClass.typeParameters),
+        typeParameters: node.typeParameters == null ? undefined : transform.TypeParameterDeclaration(node.typeParameters)
       };
     },
-
     DeclareExportDeclaration(node) {
       if (node.default === true) {
         const declaration = node.declaration;
-
         switch (declaration.type) {
-          // TS doesn't support direct default export for declare'd classes
           case 'DeclareClass':
             {
               const classDecl = transform.DeclareClass(declaration);
@@ -1047,8 +839,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                 exportKind: 'value'
               }];
             }
-          // TS doesn't support direct default export for declare'd functions
-
           case 'DeclareFunction':
             {
               const functionDecl = transform.DeclareFunction(declaration);
@@ -1064,8 +854,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                 exportKind: 'value'
               }];
             }
-          // TS doesn't support direct default export for declare'd functions
-
           case 'DeclareComponent':
             {
               const functionDecl = transform.DeclareComponent(declaration);
@@ -1081,8 +869,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                 exportKind: 'value'
               }];
             }
-          // TS doesn't support direct default export for declare'd functions
-
           case 'DeclareHook':
             {
               const functionDecl = transform.DeclareHook(declaration);
@@ -1098,44 +884,26 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                 exportKind: 'value'
               }];
             }
-          // Flow's declare export default Identifier is ambiguous.
-          // the Identifier might reference a type, or it might reference a value
-          // - If it's a value, then that's all good, TS supports that.
-          // - If it's a type, that's a problem - TS only allows value variables to be exported
-          //   so we need to create an intermediate variable to hold the type.
-
           case 'GenericTypeAnnotation':
             {
-              const referencedId = declaration.id; // QualifiedTypeIdentifiers are types so cannot be handled without the intermediate variable so
-              // only Identifiers can be handled here.
-
+              const referencedId = declaration.id;
               if (referencedId.type === 'Identifier') {
                 const exportedVar = topScope.set.get(referencedId.name);
-
                 if (exportedVar != null && exportedVar.defs.length === 1) {
                   const def = exportedVar.defs[0];
-
                   switch (def.type) {
                     case 'ImportBinding':
                       {
-                        // `import type { Wut } from 'mod'; declare export default Wut;`
-                        // `import { type Wut } from 'mod'; declare export default Wut;`
-                        // these cases should be wrapped in a variable because they're exporting a type, not a value
                         const specifier = def.node;
-
                         if (specifier.importKind === 'type' || specifier.parent.importKind === 'type') {
-                          // fallthrough to the "default" handling
                           break;
-                        } // intentional fallthrough to the "value" handling
-
+                        }
                       }
-
                     case 'ClassName':
                     case 'Enum':
                     case 'FunctionName':
                     case 'ImplicitGlobalVariable':
                     case 'Variable':
-                      // there's already a variable defined to hold the type
                       return {
                         type: 'ExportDefaultDeclaration',
                         loc: DUMMY_LOC,
@@ -1146,30 +914,23 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                         },
                         exportKind: 'value'
                       };
-
                     case 'CatchClause':
                     case 'Parameter':
                     case 'TypeParameter':
                       throw translationError(def.node, `Unexpected variable def type: ${def.type}`);
-
                     case 'Type':
-                      // fallthrough to the "default" handling
                       break;
                   }
                 }
-              } // intentional fallthrough to the "default" handling
-
+              }
             }
-
           case 'TypeofTypeAnnotation':
             {
               if (declaration.type === 'TypeofTypeAnnotation' && declaration.argument.type === 'Identifier') {
                 const name = declaration.argument.name;
                 const exportedVar = topScope.set.get(name);
-
                 if (exportedVar != null && exportedVar.defs.length === 1) {
                   const def = exportedVar.defs[0];
-
                   switch (def.type) {
                     case 'ClassName':
                       {
@@ -1188,24 +949,10 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                       }
                   }
                 }
-              } // intentional fallthrough to the "default" handling
-
+              }
             }
-
           default:
             {
-              /*
-              flow allows syntax like
-              ```
-              declare export default TypeName;
-              ```
-              but TS does not, so we have to declare a temporary variable to
-              reference in the export declaration:
-              ```
-              declare const $$EXPORT_DEFAULT_DECLARATION$$: TypeName;
-              export default $$EXPORT_DEFAULT_DECLARATION$$;
-              ```
-              */
               const SPECIFIER = '$$EXPORT_DEFAULT_DECLARATION$$';
               return [{
                 type: 'VariableDeclaration',
@@ -1262,23 +1009,18 @@ const getTransforms = (originalCode, scopeManager, opts) => {
             }
         }
       } else {
-        // eslint-disable-next-line eqeqeq
         if (node.source === null) {
-          // eslint-disable-next-line eqeqeq
           if (node.declaration === null) {
             return {
               type: 'ExportNamedDeclaration',
               loc: DUMMY_LOC,
-              // flow does not currently support attributes
               assertions: [],
               declaration: null,
-              // flow does not support declared type exports with specifiers
               exportKind: 'value',
               source: null,
               specifiers: node.specifiers.map(transform.ExportSpecifier)
             };
           }
-
           const declarations = (() => {
             switch (node.declaration.type) {
               case 'DeclareClass':
@@ -1286,43 +1028,36 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                   declaration: transform.DeclareClass(node.declaration),
                   exportKind: 'value'
                 }];
-
               case 'DeclareComponent':
                 return [{
                   declaration: transform.DeclareComponent(node.declaration),
                   exportKind: 'value'
                 }];
-
               case 'DeclareHook':
                 return [{
                   declaration: transform.DeclareHook(node.declaration),
                   exportKind: 'value'
                 }];
-
               case 'DeclareFunction':
                 return [{
                   declaration: transform.DeclareFunction(node.declaration),
                   exportKind: 'value'
                 }];
-
               case 'DeclareInterface':
                 return [{
                   declaration: transform.DeclareInterface(node.declaration),
                   exportKind: 'type'
                 }];
-
               case 'DeclareOpaqueType':
                 return [{
                   declaration: transform.DeclareOpaqueType(node.declaration),
                   exportKind: 'type'
                 }];
-
               case 'DeclareVariable':
                 return [{
                   declaration: transform.DeclareVariable(node.declaration),
                   exportKind: 'value'
                 }];
-
               case 'DeclareEnum':
                 {
                   const result = transform.DeclareEnum(node.declaration);
@@ -1339,20 +1074,17 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                 }
             }
           })();
-
           const mappedDeclarations = declarations.map(({
             declaration,
             exportKind
           }) => {
             if (declaration.type === 'VariableDeclaration' && declaration.declarations.length === 1) {
               const ident = declaration.declarations[0].id;
-
               if (ident.type === 'Identifier') {
                 const name = ident.name;
                 return [{
                   type: 'ExportNamedDeclaration',
                   loc: DUMMY_LOC,
-                  // flow does not currently support attributes
                   assertions: [],
                   declaration,
                   exportKind,
@@ -1387,16 +1119,13 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                   loc: DUMMY_LOC,
                   specifiers: [],
                   exportKind: 'type',
-                  // flow does not currently support attributes
                   assertions: []
                 }];
               }
             }
-
             const exportNamedDeclaration = {
               type: 'ExportNamedDeclaration',
               loc: DUMMY_LOC,
-              // flow does not currently support attributes
               assertions: [],
               declaration,
               exportKind,
@@ -1410,10 +1139,8 @@ const getTransforms = (originalCode, scopeManager, opts) => {
           return {
             type: 'ExportNamedDeclaration',
             loc: DUMMY_LOC,
-            // flow does not currently support attributes
             assertions: [],
             declaration: null,
-            // flow does not support declared type exports with a source
             exportKind: 'value',
             source: transform.StringLiteral(node.source),
             specifiers: node.specifiers.map(transform.ExportSpecifier)
@@ -1421,17 +1148,15 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         }
       }
     },
-
     DeclareComponent(node) {
       const id = transform.Identifier(node.id, false);
       const typeParameters = node.typeParameters == null ? undefined : transform.TypeParameterDeclaration(node.typeParameters);
-      const params = transform.ComponentTypeParameters(node.params, node.rest); // TS cannot support `renderType` so we always use ReactNode as the return type.
-
+      const [declaredParams, declaredRest] = normalizeDeclareComponentParams(node.params, node.rest, unexpectedTranslationError);
+      const params = transform.ComponentTypeParameters(declaredParams, declaredRest);
       const hasReactImport = isReactImport(node, 'React');
       const returnType = {
         type: 'TSTypeAnnotation',
         loc: DUMMY_LOC,
-        // If no rendersType we assume its ReactNode type.
         typeAnnotation: {
           type: 'TSTypeReference',
           loc: DUMMY_LOC,
@@ -1445,7 +1170,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
               name: `ReactNode`
             }
           },
-          typeParameters: undefined
+          typeArguments: undefined
         }
       };
       return {
@@ -1466,7 +1191,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         typeParameters: typeParameters
       };
     },
-
     ComponentTypeParameters(params, rest) {
       if (params.length === 0 && rest != null) {
         return [{
@@ -1481,9 +1205,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
           optional: false
         }];
       }
-
       const flowPropsType = [];
-
       if (rest != null) {
         flowPropsType.push(constructFlowNode({
           type: 'ObjectTypeSpreadProperty',
@@ -1492,10 +1214,8 @@ const getTransforms = (originalCode, scopeManager, opts) => {
           loc: rest.loc
         }));
       }
-
       for (let i = 0; i < params.length; i++) {
         var _param$name;
-
         const param = params[i];
         flowPropsType.push(constructFlowNode({
           type: 'ObjectTypeProperty',
@@ -1516,7 +1236,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
           loc: param.loc
         }));
       }
-
       const tsPropsObjectType = transform.ObjectTypeAnnotation(constructFlowNode({
         type: 'ObjectTypeAnnotation',
         inexact: false,
@@ -1538,9 +1257,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         optional: false
       }];
     },
-
     DeclareHook(node) {
-      // the hook params/returnType are stored as an annotation on the ID...
       const id = transform.Identifier(node.id, false);
       const functionInfo = transform.FunctionTypeAnnotation(node.id.typeAnnotation.typeAnnotation);
       return {
@@ -1561,9 +1278,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         typeParameters: functionInfo.typeParameters
       };
     },
-
     DeclareFunction(node) {
-      // the function information is stored as an annotation on the ID...
       const id = transform.Identifier(node.id, false);
       const functionInfo = transform.FunctionTypeAnnotation(node.id.typeAnnotation.typeAnnotation);
       return {
@@ -1584,14 +1299,11 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         typeParameters: functionInfo.typeParameters
       };
     },
-
     DeclareInterface(node) {
       const transformedBody = transform.ObjectTypeAnnotation(node.body);
-
       if (transformedBody.type !== 'TSTypeLiteral') {
         throw translationError(node.body, 'Spreads in interfaces are not allowed');
       }
-
       return {
         type: 'TSInterfaceDeclaration',
         loc: DUMMY_LOC,
@@ -1606,7 +1318,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         typeParameters: node.typeParameters == null ? undefined : transform.TypeParameterDeclaration(node.typeParameters)
       };
     },
-
     DeclareTypeAlias(node) {
       return {
         type: 'TSTypeAliasDeclaration',
@@ -1617,11 +1328,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         typeParameters: node.typeParameters == null ? undefined : transform.TypeParameterDeclaration(node.typeParameters)
       };
     },
-
     DeclareOpaqueType(node) {
-      // TS doesn't currently have nominal types - https://github.com/Microsoft/Typescript/issues/202
-      // TODO - we could simulate this in a variety of ways
-      // Examples - https://basarat.gitbook.io/typescript/main-1/nominaltyping
       if (node.supertype == null && node.typeParameters == null) {
         const name = `__${node.id.name}__`;
         return {
@@ -1660,7 +1367,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
           }
         };
       }
-
       return {
         type: 'TSTypeAliasDeclaration',
         loc: DUMMY_LOC,
@@ -1673,68 +1379,56 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         typeParameters: node.typeParameters == null ? undefined : transform.TypeParameterDeclaration(node.typeParameters)
       };
     },
-
     DeclareVariable(node) {
       return {
         type: 'VariableDeclaration',
         loc: DUMMY_LOC,
         declare: true,
-        declarations: [{
-          type: 'VariableDeclarator',
-          loc: DUMMY_LOC,
-          declare: true,
-          id: transform.Identifier(node.id, true),
-          init: null
-        }],
+        declarations: node.declarations.map(declaration => {
+          if (declaration.id.type !== 'Identifier') {
+            throw translationError(declaration.id, `DeclareVariable: unsupported declarator of type "${declaration.id.type}"`);
+          }
+          return {
+            type: 'VariableDeclarator',
+            loc: DUMMY_LOC,
+            declare: true,
+            id: transform.Identifier(declaration.id, true),
+            init: null
+          };
+        }),
         kind: node.kind
       };
     },
-
     DeclareEnum(node) {
       return EnumImpl(node);
     },
-
     EmptyTypeAnnotation(node) {
-      // Flow's `empty` type doesn't map well to any types in TS.
-      // The closest is `never`, but `never` has a number of different semantics
-      // In reality no human code should ever directly use the `empty` type in flow
-      // So let's put a pin in it for now
       return unsupportedAnnotation(node, 'empty type');
     },
-
     EnumDeclaration(node) {
       return EnumImpl(node);
     },
-
     DeclareModuleExports(node) {
       throw translationError(node, 'CommonJS exports are not supported.');
     },
-
     ExistsTypeAnnotation(node) {
-      // The existential type does not map to any types in TS
-      // It's also super deprecated - so let's not ever worry
       return unsupportedAnnotation(node, 'existential type');
     },
-
     ExportAllDeclaration(node) {
       return {
         type: 'ExportAllDeclaration',
         loc: DUMMY_LOC,
-        // flow does not currently support import/export attributes
         assertions: [],
         exportKind: node.exportKind,
         source: transform.StringLiteral(node.source),
         exported: node.exported == null ? null : transform.Identifier(node.exported)
       };
     },
-
     ExportNamedDeclaration(node) {
       if (node.source != null || node.specifiers.length > 0) {
-        // can never have a declaration with a source
         return {
           type: 'ExportNamedDeclaration',
           loc: DUMMY_LOC,
-          // flow does not currently support import/export attributes
           assertions: [],
           declaration: null,
           exportKind: node.exportKind,
@@ -1742,12 +1436,10 @@ const getTransforms = (originalCode, scopeManager, opts) => {
           specifiers: node.specifiers.map(transform.ExportSpecifier)
         };
       }
-
       const [exportedDeclaration, mergedDeclaration] = (() => {
         if (node.declaration == null) {
           return [null, null];
         }
-
         switch (node.declaration.type) {
           case 'ClassDeclaration':
           case 'ComponentDeclaration':
@@ -1755,27 +1447,20 @@ const getTransforms = (originalCode, scopeManager, opts) => {
           case 'HookDeclaration':
           case 'FunctionDeclaration':
           case 'VariableDeclaration':
-            // These cases shouldn't happen in flow defs because they have their own special
-            // AST node (DeclareClass, DeclareFunction, DeclareVariable)
             throw unexpectedTranslationError(node.declaration, `Unexpected named declaration found ${node.declaration.type}`);
-
           case 'EnumDeclaration':
             {
               const result = transform.EnumDeclaration(node.declaration);
               return Array.isArray(result) ? result : [result, null];
             }
-
           case 'InterfaceDeclaration':
             return [transform.InterfaceDeclaration(node.declaration), null];
-
           case 'OpaqueType':
             return [transform.OpaqueType(node.declaration), null];
-
           case 'TypeAlias':
             return [transform.TypeAlias(node.declaration), null];
         }
       })();
-
       const mainExport = {
         type: 'ExportNamedDeclaration',
         loc: DUMMY_LOC,
@@ -1785,9 +1470,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         source: null,
         specifiers: []
       };
-
       if (mergedDeclaration != null) {
-        // for cases where there is a merged declaration, TS enforces BOTH are exported
         return [mainExport, {
           type: 'ExportNamedDeclaration',
           loc: DUMMY_LOC,
@@ -1798,24 +1481,19 @@ const getTransforms = (originalCode, scopeManager, opts) => {
           specifiers: []
         }];
       }
-
       return mainExport;
     },
-
     ExportSpecifier(node) {
       return {
         type: 'ExportSpecifier',
         loc: DUMMY_LOC,
         exported: transform.Identifier(node.exported, false),
         local: transform.Identifier(node.local, false),
-        // flow does not support inline exportKind for named exports
         exportKind: 'value'
       };
     },
-
     FunctionTypeAnnotation(node) {
       const params = node.params.map(transform.FunctionTypeParam);
-
       if (node.type === 'FunctionTypeAnnotation' && node.this != null) {
         params.unshift({
           type: 'Identifier',
@@ -1828,7 +1506,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
           }
         });
       }
-
       if (node.rest != null) {
         const rest = node.rest;
         params.push({
@@ -1846,7 +1523,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
           }
         });
       }
-
       return {
         type: 'TSFunctionType',
         loc: DUMMY_LOC,
@@ -1859,7 +1535,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         typeParameters: node.typeParameters == null ? undefined : transform.TypeParameterDeclaration(node.typeParameters)
       };
     },
-
     FunctionTypeParam(node, idx = 0) {
       return {
         type: 'Identifier',
@@ -1873,12 +1548,10 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         optional: node.optional
       };
     },
-
     GenericTypeAnnotation(node) {
       const [fullTypeName, baseId] = (() => {
         let names = [];
         let currentNode = node.id;
-
         while (currentNode != null) {
           switch (currentNode.type) {
             case 'Identifier':
@@ -1886,7 +1559,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                 names.unshift(currentNode.name);
                 return [names.join('.'), currentNode];
               }
-
             case 'QualifiedTypeIdentifier':
               {
                 names.unshift(currentNode.id.name);
@@ -1895,54 +1567,40 @@ const getTransforms = (originalCode, scopeManager, opts) => {
               }
           }
         }
-
         throw translationError(node, `Invalid program state, types should only contain 'Identifier' and 'QualifiedTypeIdentifier' nodes.`);
       })();
-
       const assertHasExactlyNTypeParameters = count => {
         if (node.typeParameters != null) {
           if (node.typeParameters.params.length !== count) {
             throw translationError(node, `Expected exactly ${count} type parameter${count > 1 ? 's' : ''} with \`${fullTypeName}\``);
           }
-
           const res = [];
-
           for (const param of node.typeParameters.params) {
             res.push(transformTypeAnnotationType(param));
           }
-
           return res;
         }
-
         if (count !== 0) {
           throw translationError(node, `Expected no type parameters with \`${fullTypeName}\``);
         }
-
         return [];
       };
-
       function assertHasTypeParametersInRange(min, max) {
         const {
           typeParameters
         } = node;
-
         if (typeParameters == null) {
           if (min > 0) {
             throw translationError(node, `Expected between ${min} and ${max} type parameters with \`${fullTypeName}\`, but got none.`);
           }
-
           return [];
         }
-
         const params = typeParameters.params;
-
         if (params.length < min || params.length > max) {
           throw translationError(node, `Expected between ${min} and ${max} type parameters with \`${fullTypeName}\`, but got ${params.length}.`);
         }
-
         return typeParameters.params.map(transformTypeAnnotationType);
       }
-
       switch (fullTypeName) {
         case '$Call':
         case '$ObjMap':
@@ -1950,31 +1608,10 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         case '$ObjMapi':
         case '$TupleMap':
           {
-            /*
-            TODO - I don't think it's possible to make these types work in the generic case.
-             TS has no utility types that allow you to generically mimic this functionality.
-            You really need intimiate knowledge of the user's intent in order to correctly
-            transform the code.
-             For example the simple example for $Call from the flow docs:
-            ```
-            type ExtractPropType = <T>({prop: T}) => T;
-            type Obj = {prop: number};
-            type PropType = $Call<ExtractPropType, Obj>;
-            // expected -- typeof PropType === number
-            ```
-             The equivalent in TS would be:
-            ```
-            type ExtractPropType<T extends { prop: any }> = (arg: T) => T['prop'];
-            type Obj = { prop: number };
-            type PropType = ReturnType<ExtractPropType<Obj>>; // number
-            ```
-            */
             return unsupportedAnnotation(node, fullTypeName);
           }
-
         case '$ArrayBufferView':
           {
-            // `$ArrayBufferView` => `ArrayBufferView`
             return {
               type: 'TSTypeReference',
               loc: DUMMY_LOC,
@@ -1985,10 +1622,8 @@ const getTransforms = (originalCode, scopeManager, opts) => {
               }
             };
           }
-
         case '$ArrayLike':
           {
-            // `$ArrayLike<T>` => `ArrayLike<T>`
             return {
               type: 'TSTypeReference',
               loc: DUMMY_LOC,
@@ -1997,18 +1632,16 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                 loc: DUMMY_LOC,
                 name: 'ArrayLike'
               },
-              typeParameters: {
+              typeArguments: {
                 type: 'TSTypeParameterInstantiation',
                 loc: DUMMY_LOC,
                 params: assertHasExactlyNTypeParameters(1)
               }
             };
           }
-
         case '$Diff':
         case '$Rest':
           {
-            // `$Diff<A, B>` => `Pick<A, Exclude<keyof A, keyof B>>`
             const params = assertHasExactlyNTypeParameters(2);
             return {
               type: 'TSTypeReference',
@@ -2018,7 +1651,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                 loc: DUMMY_LOC,
                 name: 'Pick'
               },
-              typeParameters: {
+              typeArguments: {
                 type: 'TSTypeParameterInstantiation',
                 loc: DUMMY_LOC,
                 params: [params[0], {
@@ -2029,7 +1662,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                     loc: DUMMY_LOC,
                     name: 'Exclude'
                   },
-                  typeParameters: {
+                  typeArguments: {
                     type: 'TSTypeParameterInstantiation',
                     loc: DUMMY_LOC,
                     params: [{
@@ -2048,11 +1681,9 @@ const getTransforms = (originalCode, scopeManager, opts) => {
               }
             };
           }
-
         case '$ElementType':
         case '$PropertyType':
           {
-            // `$ElementType<T, K>` => `T[K]`
             const params = assertHasExactlyNTypeParameters(2);
             return {
               type: 'TSIndexedAccessType',
@@ -2061,24 +1692,16 @@ const getTransforms = (originalCode, scopeManager, opts) => {
               indexType: params[1]
             };
           }
-
         case '$Exact':
           {
-            // `$Exact<T>` => `T`
-            // TS has no concept of exact vs inexact types
             return assertHasExactlyNTypeParameters(1)[0];
           }
-
         case '$Exports':
           {
-            // `$Exports<'module'>` => `typeof import('module')`
             const moduleName = assertHasExactlyNTypeParameters(1)[0];
-
             if (moduleName.type !== 'TSLiteralType' || moduleName.literal.type !== 'Literal' || typeof moduleName.literal.value !== 'string') {
               throw translationError(node, '$Exports must have a string literal argument');
-            } // New AST format for `typeof import('module')`
-
-
+            }
             return {
               type: 'TSTypeQuery',
               loc: DUMMY_LOC,
@@ -2087,23 +1710,21 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                 loc: DUMMY_LOC,
                 argument: moduleName,
                 qualifier: null,
-                typeParameters: null
+                options: null,
+                source: moduleName.literal,
+                typeArguments: null
               }
             };
           }
-
         case '$FlowFixMe':
           {
-            // `$FlowFixMe` => `any`
             return {
               type: 'TSAnyKeyword',
               loc: DUMMY_LOC
             };
           }
-
         case '$KeyMirror':
           {
-            // `$KeyMirror<T>` => `{[K in keyof T]: K}`
             return {
               type: 'TSMappedType',
               loc: DUMMY_LOC,
@@ -2147,10 +1768,8 @@ const getTransforms = (originalCode, scopeManager, opts) => {
               }
             };
           }
-
         case '$Keys':
           {
-            // `$Keys<T>` => `keyof T`
             return {
               type: 'TSTypeOperator',
               loc: DUMMY_LOC,
@@ -2158,11 +1777,8 @@ const getTransforms = (originalCode, scopeManager, opts) => {
               typeAnnotation: assertHasExactlyNTypeParameters(1)[0]
             };
           }
-
         case '$NonMaybeType':
           {
-            // `$NonMaybeType<T>` => `NonNullable<T>`
-            // Not a great name because `NonNullable` also excludes `undefined`
             return {
               type: 'TSTypeReference',
               loc: DUMMY_LOC,
@@ -2171,17 +1787,15 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                 loc: DUMMY_LOC,
                 name: 'NonNullable'
               },
-              typeParameters: {
+              typeArguments: {
                 type: 'TSTypeParameterInstantiation',
                 loc: DUMMY_LOC,
                 params: assertHasExactlyNTypeParameters(1)
               }
             };
           }
-
         case '$ReadOnly':
           {
-            // `$ReadOnly<T>` => `Readonly<T>`
             return {
               type: 'TSTypeReference',
               loc: DUMMY_LOC,
@@ -2190,20 +1804,15 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                 loc: DUMMY_LOC,
                 name: 'Readonly'
               },
-              typeParameters: {
+              typeArguments: {
                 type: 'TSTypeParameterInstantiation',
                 loc: DUMMY_LOC,
                 params: assertHasExactlyNTypeParameters(1)
               }
             };
           }
-
         case '$ReadOnlyArray':
           {
-            // `$ReadOnlyArray<T>` => `ReadonlyArray<T>`
-            //
-            // we could also do    => `readonly T[]`
-            // TODO - maybe a config option?
             return {
               type: 'TSTypeReference',
               loc: DUMMY_LOC,
@@ -2212,14 +1821,13 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                 loc: DUMMY_LOC,
                 name: 'ReadonlyArray'
               },
-              typeParameters: {
+              typeArguments: {
                 type: 'TSTypeParameterInstantiation',
                 loc: DUMMY_LOC,
                 params: assertHasExactlyNTypeParameters(1)
               }
             };
           }
-
         case '$ReadOnlyMap':
           {
             return {
@@ -2230,14 +1838,13 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                 loc: DUMMY_LOC,
                 name: 'ReadonlyMap'
               },
-              typeParameters: {
+              typeArguments: {
                 type: 'TSTypeParameterInstantiation',
                 loc: DUMMY_LOC,
                 params: assertHasExactlyNTypeParameters(2)
               }
             };
           }
-
         case '$ReadOnlySet':
           {
             return {
@@ -2248,18 +1855,16 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                 loc: DUMMY_LOC,
                 name: 'ReadonlySet'
               },
-              typeParameters: {
+              typeArguments: {
                 type: 'TSTypeParameterInstantiation',
                 loc: DUMMY_LOC,
                 params: assertHasExactlyNTypeParameters(1)
               }
             };
           }
-
         case '$Values':
         case 'Values':
           {
-            // `$Values<T>` / `Values<T>` => `T[keyof T]`
             const transformedType = assertHasExactlyNTypeParameters(1)[0];
             return {
               type: 'TSIndexedAccessType',
@@ -2273,16 +1878,12 @@ const getTransforms = (originalCode, scopeManager, opts) => {
               }
             };
           }
-
         case 'Class':
           {
-            // `Class<T>` => `new (...args: any[]) => T`
             const param = assertHasExactlyNTypeParameters(1)[0];
-
             if (param.type !== 'TSTypeReference') {
               throw translationError(node, 'Expected a type reference within Class<T>');
             }
-
             return {
               type: 'TSConstructorType',
               loc: DUMMY_LOC,
@@ -2315,20 +1916,14 @@ const getTransforms = (originalCode, scopeManager, opts) => {
               }
             };
           }
-
         case 'StringPrefix':
           {
             var _params$;
-
-            // `StringPrefix<foo>` => `foo${string}`
-            // `StringPrefix<foo, T>` => `foo${T}`
             const params = assertHasTypeParametersInRange(1, 2);
             const prefix = params[0];
-
             if (prefix.type !== 'TSLiteralType' || typeof prefix.literal.value !== 'string') {
               throw translationError(node, 'Expected a string literal for the first type parameter.');
             }
-
             const prefixStr = prefix.literal.value;
             const remainder = (_params$ = params[1]) != null ? _params$ : {
               type: 'TSStringKeyword',
@@ -2357,20 +1952,14 @@ const getTransforms = (originalCode, scopeManager, opts) => {
               types: [remainder]
             };
           }
-
         case 'StringSuffix':
           {
             var _params$2;
-
-            // `StringSuffix<foo>` => `${string}foo`
-            // `StringSuffix<foo, T>` => `${T}foo`
             const params = assertHasTypeParametersInRange(1, 2);
             const suffix = params[0];
-
             if (suffix.type !== 'TSLiteralType' || typeof suffix.literal.value !== 'string') {
               throw translationError(node, 'Expected a string literal for the first type parameter.');
             }
-
             const suffixStr = suffix.literal.value;
             const remainder = (_params$2 = params[1]) != null ? _params$2 : {
               type: 'TSStringKeyword',
@@ -2399,20 +1988,11 @@ const getTransforms = (originalCode, scopeManager, opts) => {
               types: [remainder]
             };
           }
-      } // React special conversion:
-
-
+      }
       const validReactImportOrGlobal = isValidReactImportOrGlobal(baseId);
       const hasReactImport = isReactImport(baseId, baseId.name);
-
       if (validReactImportOrGlobal || hasReactImport) {
         switch (fullTypeName) {
-          // TODO: In flow this is `ChildrenArray<T> = T | $ReadOnlyArray<ChildrenArray<T>>`.
-          // The recursive nature of it is rarely needed, so we're simplifying this for now
-          // but omitting that aspect. Once we're able to provide utility types for our translations,
-          // we should update this.
-          // React.ChildrenArray<T> -> T | ReadonlyArray<T>
-          // React$ChildrenArray<T> -> T | ReadonlyArray<T>
           case 'React.ChildrenArray':
           case 'React$ChildrenArray':
             {
@@ -2428,7 +2008,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                     loc: DUMMY_LOC,
                     name: 'ReadonlyArray'
                   },
-                  typeParameters: {
+                  typeArguments: {
                     type: 'TSTypeParameterInstantiation',
                     loc: DUMMY_LOC,
                     params: [param]
@@ -2436,24 +2016,17 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                 }]
               };
             }
-          // React.Component<A,B> -> React.Component<A,B>
-          // React$Component<A,B> -> React.Component<A,B>
-
           case 'React.Component':
           case 'React$Component':
             {
               const typeParameters = node.typeParameters;
-
               if (typeParameters == null || typeParameters.params.length === 0) {
                 throw translationError(node, `Expected at least 1 type parameter with \`${fullTypeName}\``);
               }
-
               const params = typeParameters.params;
-
               if (params.length > 2) {
                 throw translationError(node, `Expected at no more than 2 type parameters with \`${fullTypeName}\``);
               }
-
               return {
                 type: 'TSTypeReference',
                 loc: DUMMY_LOC,
@@ -2467,16 +2040,13 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                     name: 'Component'
                   }
                 },
-                typeParameters: {
+                typeArguments: {
                   type: 'TSTypeParameterInstantiation',
                   loc: DUMMY_LOC,
                   params: params.map(param => transformTypeAnnotationType(param))
                 }
               };
             }
-          // React.Context<A> -> React.Context<A>
-          // React$Context<A> -> React.Context<A>
-
           case 'React$Context':
           case 'React.Context':
             return {
@@ -2492,15 +2062,12 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                   name: `Context`
                 }
               },
-              typeParameters: {
+              typeArguments: {
                 type: 'TSTypeParameterInstantiation',
                 loc: DUMMY_LOC,
                 params: assertHasExactlyNTypeParameters(1)
               }
             };
-          // React.Key -> React.Key
-          // React$Key -> React.Key
-
           case 'React.Key':
           case 'React$Key':
             assertHasExactlyNTypeParameters(0);
@@ -2518,9 +2085,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                 }
               }
             };
-          // React.ElementType -> React.ElementType
-          // React$ElementType -> React.ElementType
-
           case 'React$ElementType':
           case 'React.ElementType':
             {
@@ -2538,11 +2102,9 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                     name: `ElementType`
                   }
                 },
-                typeParameters: undefined
+                typeArguments: undefined
               };
             }
-          // React.Node -> React.ReactNode
-
           case 'React$Node':
           case 'React.Node':
             {
@@ -2560,11 +2122,9 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                     name: `ReactNode`
                   }
                 },
-                typeParameters: undefined
+                typeArguments: undefined
               };
             }
-          // React.Element<typeof Component> -> React.ReactElement<typeof Component>
-
           case 'React$Element':
           case 'React.Element':
             {
@@ -2581,16 +2141,13 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                     name: `ReactElement`
                   }
                 },
-                typeParameters: {
+                typeArguments: {
                   type: 'TSTypeParameterInstantiation',
                   loc: DUMMY_LOC,
                   params: assertHasExactlyNTypeParameters(1)
                 }
               };
             }
-          // React.ElementRef<typeof Component> -> React.ComponentRef<typeof Component>
-          // React$ElementRef<typeof Component> -> React.ComponentRef<typeof Component>
-
           case 'React$ElementRef':
           case 'React.ElementRef':
             return {
@@ -2606,15 +2163,12 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                   name: `ComponentRef`
                 }
               },
-              typeParameters: {
+              typeArguments: {
                 type: 'TSTypeParameterInstantiation',
                 loc: DUMMY_LOC,
                 params: assertHasExactlyNTypeParameters(1)
               }
             };
-          // React$Fragment -> React.Fragment
-          // React.Fragment -> React.Fragment
-
           case 'React$FragmentType':
           case 'React.Fragment':
             assertHasExactlyNTypeParameters(0);
@@ -2632,8 +2186,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                 }
               }
             };
-          // React.MixedElement -> React.JSX.Element
-
           case 'React$MixedElement':
           case 'React.MixedElement':
             {
@@ -2664,12 +2216,9 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                     name: 'Element'
                   }
                 },
-                typeParameters: undefined
+                typeArguments: undefined
               };
             }
-          // React.ComponentType<Config> -> React.ComponentType<Config>
-          // React$ComponentType<Config> -> React.ComponentType<Config>
-
           case 'React.ComponentType':
           case 'React$ComponentType':
             {
@@ -2686,38 +2235,28 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                     name: 'ComponentType'
                   }
                 },
-                typeParameters: {
+                typeArguments: {
                   type: 'TSTypeParameterInstantiation',
                   loc: DUMMY_LOC,
                   params: assertHasExactlyNTypeParameters(1)
                 }
               };
             }
-          // React.AbstractComponent<Config> -> React.ComponentType<Config>
-          // React$AbstractComponent<Config> -> React.ComponentType<Config>
-          // React.AbstractComponent<Config, Instance> -> React.ComponentType<Config & React.RefAttributes<Instance>>
-          // React$AbstractComponent<Config, Instance> -> React.ComponentType<Config & React.RefAttributes<Instance>>
-
           case 'React.AbstractComponent':
           case 'React$AbstractComponent':
             {
               const typeParameters = node.typeParameters;
-
               if (typeParameters == null || typeParameters.params.length === 0) {
                 throw translationError(node, `Expected at least 1 type parameter with \`${fullTypeName}\``);
               }
-
               const params = typeParameters.params;
-
               if (params.length > 3) {
                 throw translationError(node, `Expected at no more than 3 type parameters with \`${fullTypeName}\``);
               }
-
               const newParams = (() => {
                 if (params.length === 1) {
                   return assertHasExactlyNTypeParameters(1);
                 }
-
                 const props = transformTypeAnnotationType(params[0]);
                 const ref = transformTypeAnnotationType(params[1]);
                 return [{
@@ -2740,7 +2279,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                         name: 'RefAttributes'
                       }
                     },
-                    typeParameters: {
+                    typeArguments: {
                       type: 'TSTypeParameterInstantiation',
                       loc: DUMMY_LOC,
                       params: [ref]
@@ -2748,7 +2287,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                   }]
                 }];
               })();
-
               return {
                 type: 'TSTypeReference',
                 loc: DUMMY_LOC,
@@ -2762,16 +2300,13 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                     name: 'ComponentType'
                   }
                 },
-                typeParameters: {
+                typeArguments: {
                   type: 'TSTypeParameterInstantiation',
                   loc: DUMMY_LOC,
                   params: newParams
                 }
               };
             }
-          // React.ElementProps<A> -> React.ComponentProps<A>
-          // React$ElementProps<A> -> React.ComponentProps<A>
-
           case 'React.ElementProps':
           case 'React$ElementProps':
             {
@@ -2788,16 +2323,13 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                     name: 'ComponentProps'
                   }
                 },
-                typeParameters: {
+                typeArguments: {
                   type: 'TSTypeParameterInstantiation',
                   loc: DUMMY_LOC,
                   params: assertHasExactlyNTypeParameters(1)
                 }
               };
             }
-          // React.ElementConfig<A> ->  React.JSX.LibraryManagedAttributes<A, React.ComponentProps<A>>
-          // React$ElementConfig<A> ->  React.JSX.LibraryManagedAttributes<A, React.ComponentProps<A>>
-
           case 'React.ElementConfig':
           case 'React$ElementConfig':
             {
@@ -2828,7 +2360,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                     name: 'LibraryManagedAttributes'
                   }
                 },
-                typeParameters: {
+                typeArguments: {
                   type: 'TSTypeParameterInstantiation',
                   loc: DUMMY_LOC,
                   params: [param, {
@@ -2844,7 +2376,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                         name: `ComponentProps`
                       }
                     },
-                    typeParameters: {
+                    typeArguments: {
                       type: 'TSTypeParameterInstantiation',
                       loc: DUMMY_LOC,
                       params: [param]
@@ -2853,9 +2385,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                 }
               };
             }
-          // React.RefSetter<C> -> React.Ref<C>
-          // React$RefSetter<C> -> React.Ref<C>
-
           case 'React.RefSetter':
           case 'React$RefSetter':
             return {
@@ -2871,26 +2400,23 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                   name: 'Ref'
                 }
               },
-              typeParameters: {
+              typeArguments: {
                 type: 'TSTypeParameterInstantiation',
                 loc: DUMMY_LOC,
                 params: assertHasExactlyNTypeParameters(1)
               }
             };
-
           default:
             return unsupportedAnnotation(node, fullTypeName);
         }
       }
-
       return {
         type: 'TSTypeReference',
         loc: DUMMY_LOC,
         typeName: node.id.type === 'Identifier' ? transform.Identifier(node.id, false) : transform.QualifiedTypeIdentifier(node.id),
-        typeParameters: transform.TypeParameterInstantiation(node.typeParameters)
+        typeArguments: transform.TypeParameterInstantiation(node.typeParameters)
       };
     },
-
     Identifier(node, includeTypeAnnotation = true) {
       return {
         type: 'Identifier',
@@ -2901,7 +2427,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         } : {})
       };
     },
-
     IndexedAccessType(node) {
       return {
         type: 'TSIndexedAccessType',
@@ -2910,11 +2435,9 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         indexType: transformTypeAnnotationType(node.indexType)
       };
     },
-
     InterfaceDeclaration(node) {
       return transform.DeclareInterface(node);
     },
-
     ImportAttribute(node) {
       return {
         type: 'ImportAttribute',
@@ -2923,7 +2446,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         value: transform.Literal(node.value)
       };
     },
-
     ImportDeclaration(node) {
       const importKind = node.importKind;
       const specifiers = [];
@@ -2948,10 +2470,8 @@ const getTransforms = (originalCode, scopeManager, opts) => {
             });
             return id;
           }
-
           return transform.Identifier(spec.local, false);
         })();
-
         switch (spec.type) {
           case 'ImportDefaultSpecifier':
             specifiers.push({
@@ -2960,7 +2480,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
               local: id
             });
             return;
-
           case 'ImportNamespaceSpecifier':
             specifiers.push({
               type: 'ImportNamespaceSpecifier',
@@ -2968,7 +2487,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
               local: id
             });
             return;
-
           case 'ImportSpecifier':
             specifiers.push({
               type: 'ImportSpecifier',
@@ -2990,37 +2508,29 @@ const getTransforms = (originalCode, scopeManager, opts) => {
       }] : [];
       return [...out, ...unsupportedSpecifiers];
     },
-
     InterfaceExtends(node) {
       return {
         type: 'TSInterfaceHeritage',
         loc: DUMMY_LOC,
         expression: node.id.type === 'QualifiedTypeIdentifier' ? transform.QualifiedTypeIdentifier(node.id) : transform.Identifier(node.id, false),
-        typeParameters: transform.TypeParameterInstantiation(node.typeParameters)
+        typeArguments: transform.TypeParameterInstantiation(node.typeParameters)
       };
     },
-
     InterfaceTypeAnnotation(node) {
       if (node.extends) {
-        // type T = interface extends U, V { ... }
-        // to
-        // type T = U & V & { ... }
         return {
           type: 'TSIntersectionType',
           loc: DUMMY_LOC,
           types: [...node.extends.map(ex => ({
             type: 'TSTypeReference',
             loc: DUMMY_LOC,
-            // Bug: ex.id can be qualified
             typeName: transform.Identifier(ex.id, false),
-            typeParameters: transform.TypeParameterInstantiation(ex.typeParameters)
+            typeArguments: transform.TypeParameterInstantiation(ex.typeParameters)
           })), transform.ObjectTypeAnnotation(node.body)]
         };
       }
-
       return transform.ObjectTypeAnnotation(node.body);
     },
-
     IntersectionTypeAnnotation(node) {
       return {
         type: 'TSIntersectionType',
@@ -3028,36 +2538,28 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         types: node.types.map(transformTypeAnnotationType)
       };
     },
-
     Literal(node) {
       switch (node.literalType) {
         case 'bigint':
           return transform.BigIntLiteral(node);
-
         case 'boolean':
           return transform.BooleanLiteral(node);
-
         case 'null':
           return transform.NullLiteral(node);
-
         case 'numeric':
           return transform.NumericLiteral(node);
-
         case 'regexp':
           return transform.RegExpLiteral(node);
-
         case 'string':
           return transform.StringLiteral(node);
       }
     },
-
     MixedTypeAnnotation(_node) {
       return {
         type: 'TSUnknownKeyword',
         loc: DUMMY_LOC
       };
     },
-
     NullLiteral(_node) {
       return {
         type: 'Literal',
@@ -3066,17 +2568,13 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         value: null
       };
     },
-
     NullLiteralTypeAnnotation(_node) {
       return {
         type: 'TSNullKeyword',
         loc: DUMMY_LOC
       };
     },
-
     NullableTypeAnnotation(node) {
-      // TS doesn't support the maybe type, so have to explicitly union in `null | undefined`
-      // `?T` becomes `null | undefined | T`
       return {
         type: 'TSUnionType',
         loc: DUMMY_LOC,
@@ -3089,7 +2587,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         }, transformTypeAnnotationType(node.typeAnnotation)]
       };
     },
-
     NumberLiteralTypeAnnotation(node) {
       return {
         type: 'TSLiteralType',
@@ -3102,14 +2599,12 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         }
       };
     },
-
     NumberTypeAnnotation(_node) {
       return {
         type: 'TSNumberKeyword',
         loc: DUMMY_LOC
       };
     },
-
     NumericLiteral(node) {
       return {
         type: 'Literal',
@@ -3118,12 +2613,9 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         value: node.value
       };
     },
-
     ObjectTypeAnnotation(node) {
       if (node.properties.length === 1 && node.properties[0].type === 'ObjectTypeMappedTypeProperty') {
         var _prop$variance, _prop$variance2;
-
-        // Mapped Object Object types must not have other object properties.
         const prop = node.properties[0];
         const tsProp = {
           type: 'TSMappedType',
@@ -3152,56 +2644,36 @@ const getTransforms = (originalCode, scopeManager, opts) => {
           nameType: null
         };
         return tsProp;
-      } // we want to preserve the source order of the members
-      // unfortunately flow has unordered properties storing things
-      // so store all elements with their start index and sort the
-      // list afterward
-
-
+      }
       const members = [];
-
       for (const callProp of node.callProperties) {
         members.push({
           start: callProp.range[0],
           node: transform.ObjectTypeCallProperty(callProp)
         });
       }
-
       for (const indexer of node.indexers) {
         members.push({
           start: indexer.range[0],
           node: transform.ObjectTypeIndexer(indexer)
         });
       }
-      /*
-      TODO - internalSlots
-      I don't think there's anything analogous in TS.
-      They're really rarely used (if ever) - so let's just ignore them for now
-      */
-
-
       if (node.internalSlots.length > 0) {
         return unsupportedAnnotation(node.internalSlots[0], 'internal slots');
       }
-
       if (!node.properties.find(FlowESTree.isObjectTypeSpreadProperty)) {
         for (const property of node.properties) {
           if (property.type === 'ObjectTypeSpreadProperty') {
-            // this is imposible due to the above find condition
-            // this check is purely to satisfy flow
             throw unexpectedTranslationError(property, 'Impossible state');
           }
-
           if (property.type === 'ObjectTypeMappedTypeProperty') {
             return unsupportedAnnotation(property, 'object type with mapped type property along with other properties');
           }
-
           members.push({
             start: property.range[0],
             node: transform.ObjectTypeProperty(property)
           });
         }
-
         const tsBody = members.sort((a, b) => a.start - b.start).map(({
           node
         }) => node);
@@ -3211,88 +2683,22 @@ const getTransforms = (originalCode, scopeManager, opts) => {
           members: tsBody
         };
       } else {
-        /*
-        spreads are a complicate thing for us to handle, sadly.
-        in flow type spreads are modelled after object spreads; meaning that for
-        { ...A, ...B } - all properties in B will explicitly replace any properties
-        in A of the same name.
-        ```
-        type T1 = { a: string };
-        type T2 = { a: number };
-        type T3 = { ...T1, ...T2 };
-        type A = T3['a'] // === number
-        ```
-         however in TS there are no object type spreads - you can only merge
-        objects either via the intersection operator or via interface extends.
-         For an interface extends - `interface B extends A { ... }` - TS enforces
-        that the properties of B are all covariantly related to the same named
-        properties in A.
-        So we can't use an interface extends.
-         For a type intersection - `type T = A & B;` - TS will (essentially) merge
-        the types by intersecting each same named property in each type to calculate
-        the resulting type. This has the effect of enforcing the same constraint
-        as the interface case, however instead of an error it causes properties to
-        become `never`:
-        ```
-        type T1 = { a: string };
-        type T2 = { a: number };
-        type T3 = T1 & T2;
-        type A = T3['a'] // === string & number === never
-        ```
-         So in order for us to model flow's spreads we have to explicitly omit the keys
-        from the proceeding type that might clash. We can do this pretty easily using
-        TS's utility types:
-        ```
-        type T1 = { a: string };
-        type T2 = { a: number };
-        type T3 = Omit<T1, keyof T2> & T2;
-        type A = T3['a'] // === number
-        ```
-         Unfortunately because we need to solve for the general case object type usage,
-        it's going to be a bit ugly and complicated, sadly.
-         If we had access to type information we would be able to skip some ugliness by
-        checking to see if there is any overlap and skipping the omit step if there isn't.
-        But alas - we're working purely syntactically.
-         ```
-        type T = { ...T1, b: string  };
-        // becomes
-        type T = Omit<T1, keyof { b: string }> & { b: string };
-        ```
-        ```
-        type T = { ...T1, ...T2, ...T3, b: string  };
-        // becomes
-        type T =
-          & Omit<T1, keyof T2 | keyof T3 | keyof { b: string }>
-          & Omit<T2, keyof T3 | keyof { b: string }>
-          & Omit<T3, keyof { b: string }>
-          & { b: string };
-        ```
-         Note that because it's going to be super ugly and complicated - for now we're going to disallow:
-        - spreads in the middle
-        - spreads at the end
-        - spreads of things that aren't "Identifiers"
-        */
+        var _extractPropertyKeyLi;
         if (members.length > 0) {
           return unsupportedAnnotation(node, 'object types with spreads, indexers and/or call properties at the same time');
         }
-
         const typesToIntersect = [];
-
         for (const property of node.properties) {
           if (property.type === 'ObjectTypeSpreadProperty') {
             if (members.length > 0) {
               return unsupportedAnnotation(property, 'object types with spreads in the middle or at the end');
             }
-
             const spreadType = transformTypeAnnotationType(property.argument);
-
             if (spreadType.type !== 'TSTypeReference' && spreadType.type !== 'TSTypeQuery') {
               return unsupportedAnnotation(property, 'object types with complex spreads');
             }
-
             typesToIntersect.push(spreadType);
           } else if (property.type === 'ObjectTypeMappedTypeProperty') {
-            // TODO - Support mapped types
             return unsupportedAnnotation(property, 'object type with mapped type property');
           } else {
             members.push({
@@ -3301,7 +2707,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
             });
           }
         }
-
         const tsBody = members.sort((a, b) => a.start - b.start).map(({
           node
         }) => node);
@@ -3310,11 +2715,22 @@ const getTransforms = (originalCode, scopeManager, opts) => {
           loc: DUMMY_LOC,
           members: tsBody
         };
+        const objectKeyTypes = (_extractPropertyKeyLi = (0, _TSNodeUtils.extractPropertyKeyLiterals)(tsBody)) != null ? _extractPropertyKeyLi : [{
+          type: 'TSTypeOperator',
+          loc: DUMMY_LOC,
+          operator: 'keyof',
+          typeAnnotation: objectType
+        }];
         const intersectionMembers = [];
-
         for (let i = 0; i < typesToIntersect.length; i += 1) {
           const currentType = typesToIntersect[i];
           const remainingTypes = typesToIntersect.slice(i + 1);
+          const omitKeyTypes = [...remainingTypes.map(t => ({
+            type: 'TSTypeOperator',
+            loc: DUMMY_LOC,
+            operator: 'keyof',
+            typeAnnotation: t
+          })), ...objectKeyTypes];
           intersectionMembers.push({
             type: 'TSTypeReference',
             loc: DUMMY_LOC,
@@ -3323,28 +2739,17 @@ const getTransforms = (originalCode, scopeManager, opts) => {
               loc: DUMMY_LOC,
               name: 'Omit'
             },
-            typeParameters: {
+            typeArguments: {
               type: 'TSTypeParameterInstantiation',
               loc: DUMMY_LOC,
-              params: [currentType, {
+              params: [currentType, omitKeyTypes.length === 1 ? omitKeyTypes[0] : {
                 type: 'TSUnionType',
                 loc: DUMMY_LOC,
-                types: [...remainingTypes.map(t => ({
-                  type: 'TSTypeOperator',
-                  loc: DUMMY_LOC,
-                  operator: 'keyof',
-                  typeAnnotation: t
-                })), {
-                  type: 'TSTypeOperator',
-                  loc: DUMMY_LOC,
-                  operator: 'keyof',
-                  typeAnnotation: objectType
-                }]
+                types: omitKeyTypes
               }]
             }
           });
         }
-
         intersectionMembers.push(objectType);
         return {
           type: 'TSIntersectionType',
@@ -3353,9 +2758,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         };
       }
     },
-
     ObjectTypeCallProperty(node) {
-      // the info is stored on the "value"
       const func = transform.FunctionTypeAnnotation(node.value);
       return {
         type: 'TSCallSignatureDeclaration',
@@ -3365,13 +2768,10 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         typeParameters: func.typeParameters
       };
     },
-
     ObjectTypeIndexer(node) {
       var _node$variance3, _node$variance4;
-
       if (node.key.type === 'GenericTypeAnnotation') {
         var _node$variance, _node$variance2;
-
         const ident = node.key.id.type === 'Identifier' ? node.key.id : node.key.id.id;
         return {
           type: 'TSPropertySignature',
@@ -3401,7 +2801,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
           }
         };
       }
-
       return {
         type: 'TSIndexSignature',
         loc: DUMMY_LOC,
@@ -3424,14 +2823,11 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         }
       };
     },
-
     ObjectTypeProperty(node) {
       var _node$variance5, _node$variance6;
-
       const [key, computed] = (() => {
         if (node.key.type === 'Identifier' && node.key.name.startsWith('@@')) {
           const name = node.key.name.slice(2);
-
           if (node.method === true && wellKnownSymbols.has(name)) {
             return [{
               type: 'MemberExpression',
@@ -3453,21 +2849,14 @@ const getTransforms = (originalCode, scopeManager, opts) => {
             }, true];
           }
         }
-
         const key = node.key.type === 'Identifier' ? transform.Identifier(node.key) : node.key.literalType === 'string' ? transform.StringLiteral(node.key) : null;
-
         if (key == null) {
           throw unexpectedTranslationError(node, 'Unsupported key type');
         }
-
         return [key, false];
       })();
-
       if (node.method === true) {
-        // flow has just one node for all object properties and relies upon the method flag
-        // TS has separate nodes for methods and properties
-        const func = transform.FunctionTypeAnnotation(node.value); // $FlowFixMe[incompatible-type] `computed` is set dynamically
-
+        const func = transform.FunctionTypeAnnotation(node.value);
         return {
           type: 'TSMethodSignature',
           loc: DUMMY_LOC,
@@ -3481,12 +2870,8 @@ const getTransforms = (originalCode, scopeManager, opts) => {
           typeParameters: func.typeParameters
         };
       }
-
       if (node.kind === 'get' || node.kind === 'set') {
-        // flow treats getters/setters as true property signatures (method === false)
-        // TS treats them as method signatures
-        const func = transform.FunctionTypeAnnotation(node.value); // $FlowFixMe[incompatible-type] `computed` is set dynamically
-
+        const func = transform.FunctionTypeAnnotation(node.value);
         return {
           type: 'TSMethodSignature',
           loc: DUMMY_LOC,
@@ -3495,15 +2880,11 @@ const getTransforms = (originalCode, scopeManager, opts) => {
           kind: node.kind,
           optional: false,
           params: func.params,
-          // TS setters must not have a return type
           returnType: node.kind === 'set' ? undefined : func.returnType,
           static: node.static,
-          // TS accessors cannot have type parameters
           typeParameters: undefined
         };
-      } // $FlowFixMe[incompatible-type] `computed` is set dynamically
-
-
+      }
       return {
         type: 'TSPropertySignature',
         loc: DUMMY_LOC,
@@ -3515,25 +2896,17 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         typeAnnotation: {
           type: 'TSTypeAnnotation',
           loc: DUMMY_LOC,
-          typeAnnotation: transformTypeAnnotationType(node.value)
+          typeAnnotation: node.optional === true ? (0, _TSNodeUtils.ensureTypeIncludesUndefined)(transformTypeAnnotationType(node.value)) : transformTypeAnnotationType(node.value)
         }
       };
     },
-
     OpaqueType(node) {
       return transform.DeclareOpaqueType(node);
     },
-
     OptionalIndexedAccessType(node) {
-      // Foo?.[A][B]
-      // ^^^^^^^^    optional = true
-      // ^^^^^^^^^^^ optional = false
       if (node.optional === false) {
         return transform.IndexedAccessType(node);
-      } // TS doesn't support optional index access so we have to wrap the object:
-      // `T?.[K]` becomes `NonNullable<T>[K]`
-
-
+      }
       return {
         type: 'TSIndexedAccessType',
         loc: DUMMY_LOC,
@@ -3545,7 +2918,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
             loc: DUMMY_LOC,
             name: 'NonNullable'
           },
-          typeParameters: {
+          typeArguments: {
             type: 'TSTypeParameterInstantiation',
             loc: DUMMY_LOC,
             params: [transformTypeAnnotationType(node.objectType)]
@@ -3554,7 +2927,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         indexType: transformTypeAnnotationType(node.indexType)
       };
     },
-
     QualifiedTypeIdentifier(node) {
       const qual = node.qualification;
       return {
@@ -3564,7 +2936,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         right: transform.Identifier(node.id, false)
       };
     },
-
     QualifiedTypeofIdentifier(node) {
       const qual = node.qualification;
       return {
@@ -3574,7 +2945,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         right: transform.Identifier(node.id, false)
       };
     },
-
     RegExpLiteral(node) {
       return {
         type: 'Literal',
@@ -3587,7 +2957,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         value: node.value
       };
     },
-
     StringLiteral(node) {
       return {
         type: 'Literal',
@@ -3596,7 +2965,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         value: node.value
       };
     },
-
     StringLiteralTypeAnnotation(node) {
       return {
         type: 'TSLiteralType',
@@ -3609,28 +2977,24 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         }
       };
     },
-
     StringTypeAnnotation(_node) {
       return {
         type: 'TSStringKeyword',
         loc: DUMMY_LOC
       };
     },
-
     SymbolTypeAnnotation(_node) {
       return {
         type: 'TSSymbolKeyword',
         loc: DUMMY_LOC
       };
     },
-
     ThisTypeAnnotation(_node) {
       return {
         type: 'TSThisType',
         loc: DUMMY_LOC
       };
     },
-
     TupleTypeAnnotation(node) {
       const allReadOnly = node.elementTypes.length > 0 && node.elementTypes.every(element => element.type === 'TupleTypeLabeledElement' && element.variance != null && (element.variance.kind === 'plus' || element.variance.kind === 'readonly'));
       const elems = node.elementTypes.map(element => {
@@ -3639,7 +3003,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
             if (!allReadOnly && element.variance != null) {
               return unsupportedAnnotation(element, 'tuple type element variance annotations');
             }
-
             return {
               type: 'TSNamedTupleMember',
               loc: DUMMY_LOC,
@@ -3647,7 +3010,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
               optional: element.optional,
               elementType: transformTypeAnnotationType(element.elementType)
             };
-
           case 'TupleTypeSpreadElement':
             {
               const annot = transformTypeAnnotationType(element.typeAnnotation);
@@ -3663,7 +3025,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                 } : annot
               };
             }
-
           default:
             return transformTypeAnnotationType(element);
         }
@@ -3692,11 +3053,9 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         typeAnnotation: tupleAnnot
       } : tupleAnnot;
     },
-
     TypeAlias(node) {
       return transform.DeclareTypeAlias(node);
     },
-
     TypeAnnotation(node) {
       return {
         type: 'TSTypeAnnotation',
@@ -3704,7 +3063,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         typeAnnotation: transformTypeAnnotationType(node.typeAnnotation)
       };
     },
-
     TypeofTypeAnnotation(node) {
       switch (node.argument.type) {
         case 'Identifier':
@@ -3712,39 +3070,18 @@ const getTransforms = (originalCode, scopeManager, opts) => {
             type: 'TSTypeQuery',
             loc: DUMMY_LOC,
             exprName: transform.Identifier(node.argument),
-            typeParameters: undefined
+            typeArguments: undefined
           };
-
         case 'QualifiedTypeofIdentifier':
           return {
             type: 'TSTypeQuery',
             loc: DUMMY_LOC,
             exprName: transform.QualifiedTypeofIdentifier(node.argument),
-            typeParameters: undefined
+            typeArguments: undefined
           };
       }
     },
-
     TypeParameter(node) {
-      /*
-      TODO - flow models variance as explicit syntax, but but TS resolves it automatically
-      TS does have syntax for explicit variance, but you can introduce a TS error if the
-      marked parameter isn't used in the location that TS expects them to be in.
-       To make it easier for now let's just rely on TS's auto-resolution.
-       ```
-      const variance =
-        new Set(
-          node.variance == null
-            ? // by default flow generics act invariantly
-              ['in', 'out']
-            : node.variance.kind === 'plus'
-            ? // covariant
-              ['out']
-            : // contravariant
-              ['in'],
-        );
-      ```
-      */
       return {
         type: 'TSTypeParameter',
         loc: DUMMY_LOC,
@@ -3756,12 +3093,9 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         constraint: node.bound == null ? undefined : transformTypeAnnotationType(node.bound.typeAnnotation),
         default: node.default == null ? undefined : transformTypeAnnotationType(node.default),
         in: false,
-        out: false // in: variance.has('in'),
-        // out: variance.has('out'),
-
+        out: false
       };
     },
-
     TypeParameterDeclaration(node) {
       return {
         type: 'TSTypeParameterDeclaration',
@@ -3769,21 +3103,16 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         params: node.params.map(transform.TypeParameter)
       };
     },
-
     TypeParameterInstantiation(node) {
-      // Empty parameters in Flow are valid, but TS requires at least one parameter.
-      // This ensures empty type parameters are not created in TS
       if (node == null || node.params.length === 0) {
         return undefined;
       }
-
       return {
         type: 'TSTypeParameterInstantiation',
         loc: DUMMY_LOC,
         params: node.params.map(transformTypeAnnotationType)
       };
     },
-
     UnionTypeAnnotation(node) {
       return {
         type: 'TSUnionType',
@@ -3791,35 +3120,30 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         types: node.types.map(transformTypeAnnotationType)
       };
     },
-
     VoidTypeAnnotation(_node) {
       return {
         type: 'TSVoidKeyword',
         loc: DUMMY_LOC
       };
     },
-
     NeverTypeAnnotation(_node) {
       return {
         type: 'TSNeverKeyword',
         loc: DUMMY_LOC
       };
     },
-
     UndefinedTypeAnnotation(_node) {
       return {
         type: 'TSUndefinedKeyword',
         loc: DUMMY_LOC
       };
     },
-
     UnknownTypeAnnotation(_node) {
       return {
         type: 'TSUnknownKeyword',
         loc: DUMMY_LOC
       };
     },
-
     ConditionalTypeAnnotation(node) {
       return {
         type: 'TSConditionalType',
@@ -3830,7 +3154,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         falseType: transformTypeAnnotationType(node.falseType)
       };
     },
-
     TypePredicateAnnotation(node) {
       return {
         type: 'TSTypePredicate',
@@ -3844,7 +3167,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         }
       };
     },
-
     InferTypeAnnotation(node) {
       return {
         type: 'TSInferType',
@@ -3852,7 +3174,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         typeParameter: transform.TypeParameter(node.typeParameter)
       };
     },
-
     KeyofTypeAnnotation(node) {
       return {
         type: 'TSTypeOperator',
@@ -3861,7 +3182,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         typeAnnotation: transformTypeAnnotationType(node.argument)
       };
     },
-
     TypeOperator(node) {
       switch (node.operator) {
         case 'renders':
@@ -3882,21 +3202,18 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                   name: `ReactNode`
                 }
               },
-              typeParameters: undefined
+              typeArguments: undefined
             };
           }
       }
     },
-
     ComponentTypeAnnotation(node) {
       const typeParameters = node.typeParameters == null ? undefined : transform.TypeParameterDeclaration(node.typeParameters);
-      const params = transform.ComponentTypeParameters(node.params, node.rest); // TS cannot support `renderType` so we always use ReactNode as the return type.
-
+      const params = transform.ComponentTypeParameters(node.params, node.rest);
       const hasReactImport = isReactImport(node, 'React');
       const returnType = {
         type: 'TSTypeAnnotation',
         loc: DUMMY_LOC,
-        // If no rendersType we assume its ReactNode type.
         typeAnnotation: {
           type: 'TSTypeReference',
           loc: DUMMY_LOC,
@@ -3910,7 +3227,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
               name: `ReactNode`
             }
           },
-          typeParameters: undefined
+          typeArguments: undefined
         }
       };
       return {
@@ -3921,17 +3238,11 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         returnType
       };
     }
-
-  }; // wrap each transform so that we automatically preserve jsdoc comments
-  // this just saves us manually wiring up every single case
-
+  };
   for (const key of Object.keys(transform)) {
-    const originalFn = transform[key]; // $FlowExpectedError[cannot-write]
-    // $FlowExpectedError[missing-local-annot]
-
+    const originalFn = transform[key];
     transform[key] = (node, ...args) => {
       const result = originalFn(node, ...args);
-
       if (node != null && result != null) {
         if (Array.isArray(result)) {
           cloneJSDocCommentsToNewNode(node, result[0]);
@@ -3939,10 +3250,8 @@ const getTransforms = (originalCode, scopeManager, opts) => {
           cloneJSDocCommentsToNewNode(node, result);
         }
       }
-
       return result;
     };
   }
-
   return [transform, code];
 };