flow-api-translator 0.36.1 → 0.37.0

package/dist/src/flowDefToTSDef.js

@@ -1,12 +1,3 @@
-/**
- * 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", {
@@ -24,6 +15,8 @@ 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); }
@@ -45,18 +38,15 @@ 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 = _hermesTransform.cloneJSDocCommentsToNewNode;
+const makeCommentOwnLine = _hermesTransform.makeCommentOwnLine;
 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) {
@@ -84,10 +74,7 @@ function flowDefToTSDef(originalCode, ast, 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}`, {
@@ -156,11 +143,8 @@ 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);
   }
 
@@ -240,19 +224,15 @@ const getTransforms = (originalCode, scopeManager, opts) => {
 
         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') {
@@ -261,15 +241,11 @@ const getTransforms = (originalCode, scopeManager, opts) => {
 
           return false;
         }
-      // Globals
 
       case 'ImplicitGlobalVariable':
         {
           return VALID_REACT_IMPORTS.has(name);
         }
-      // TODO Handle:
-      // const React = require('react');
-      // const Something = React;
     }
 
     return false;
@@ -279,49 +255,10 @@ const getTransforms = (originalCode, scopeManager, opts) => {
     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));
     }
 
@@ -332,7 +269,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         case 'EnumDefaultedMember':
           {
             if (body.type === 'EnumNumberBody') {
-              // this should be impossible!
               throw unexpectedTranslationError(member, 'Unexpected defaulted number enum member');
             }
 
@@ -383,22 +319,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 +328,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 +376,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 +438,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
           source: null,
           exportKind: 'value',
           assertions: []
-        }, // export function members(): IterableIterator<Foo>;
-        {
+        }, {
           type: 'ExportNamedDeclaration',
           loc: DUMMY_LOC,
           declaration: {
@@ -546,7 +464,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                   loc: DUMMY_LOC,
                   name: 'IterableIterator'
                 },
-                typeParameters: {
+                typeArguments: {
                   type: 'TSTypeParameterInstantiation',
                   loc: DUMMY_LOC,
                   params: [{
@@ -562,8 +480,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
           source: null,
           exportKind: 'value',
           assertions: []
-        }, // export function getName(value: Foo): string;
-        {
+        }, {
           type: 'ExportNamedDeclaration',
           loc: DUMMY_LOC,
           declaration: {
@@ -765,13 +682,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
     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,
@@ -826,7 +737,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         type: 'TSClassImplements',
         loc: DUMMY_LOC,
         expression: transform.Identifier(node.id, false),
-        typeParameters: transform.TypeParameterInstantiation(node.typeParameters)
+        typeArguments: transform.TypeParameterInstantiation(node.typeParameters)
       };
     },
 
@@ -839,8 +750,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
       }
 
       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':
             {
@@ -850,8 +759,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
 
           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;
@@ -885,7 +792,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                     generator: false,
                     id: null,
                     params: member.params,
-                    // constructors explicitly have no return type
                     returnType: undefined,
                     typeParameters: member.typeParameters
                   }
@@ -983,22 +889,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
             {
               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);
             }
 
@@ -1020,9 +910,8 @@ 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)
       };
     },
 
@@ -1031,7 +920,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         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,7 +935,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                 exportKind: 'value'
               }];
             }
-          // TS doesn't support direct default export for declare'd functions
 
           case 'DeclareFunction':
             {
@@ -1064,7 +951,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                 exportKind: 'value'
               }];
             }
-          // TS doesn't support direct default export for declare'd functions
 
           case 'DeclareComponent':
             {
@@ -1081,7 +967,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                 exportKind: 'value'
               }];
             }
-          // TS doesn't support direct default export for declare'd functions
 
           case 'DeclareHook':
             {
@@ -1098,16 +983,10 @@ 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);
@@ -1118,16 +997,11 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                   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':
@@ -1135,7 +1009,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                     case 'FunctionName':
                     case 'ImplicitGlobalVariable':
                     case 'Variable':
-                      // there's already a variable defined to hold the type
                       return {
                         type: 'ExportDefaultDeclaration',
                         loc: DUMMY_LOC,
@@ -1153,12 +1026,10 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                       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':
@@ -1188,24 +1059,11 @@ 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,17 +1120,13 @@ 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)
@@ -1352,7 +1206,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                 return [{
                   type: 'ExportNamedDeclaration',
                   loc: DUMMY_LOC,
-                  // flow does not currently support attributes
                   assertions: [],
                   declaration,
                   exportKind,
@@ -1387,7 +1240,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                   loc: DUMMY_LOC,
                   specifiers: [],
                   exportKind: 'type',
-                  // flow does not currently support attributes
                   assertions: []
                 }];
               }
@@ -1396,7 +1248,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
             const exportNamedDeclaration = {
               type: 'ExportNamedDeclaration',
               loc: DUMMY_LOC,
-              // flow does not currently support attributes
               assertions: [],
               declaration,
               exportKind,
@@ -1410,10 +1261,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)
@@ -1425,13 +1274,11 @@ 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 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,
@@ -1445,7 +1292,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
               name: `ReactNode`
             }
           },
-          typeParameters: undefined
+          typeArguments: undefined
         }
       };
       return {
@@ -1540,7 +1387,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
     },
 
     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 {
@@ -1563,7 +1409,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
     },
 
     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 {
@@ -1619,9 +1464,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
     },
 
     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 {
@@ -1695,10 +1537,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
     },
 
     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');
     },
 
@@ -1711,8 +1549,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
     },
 
     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');
     },
 
@@ -1720,7 +1556,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
       return {
         type: 'ExportAllDeclaration',
         loc: DUMMY_LOC,
-        // flow does not currently support import/export attributes
         assertions: [],
         exportKind: node.exportKind,
         source: transform.StringLiteral(node.source),
@@ -1730,11 +1565,9 @@ const getTransforms = (originalCode, scopeManager, opts) => {
 
     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,
@@ -1755,8 +1588,6 @@ 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':
@@ -1787,7 +1618,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
       };
 
       if (mergedDeclaration != null) {
-        // for cases where there is a merged declaration, TS enforces BOTH are exported
         return [mainExport, {
           type: 'ExportNamedDeclaration',
           loc: DUMMY_LOC,
@@ -1808,7 +1638,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         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'
       };
     },
@@ -1950,31 +1779,11 @@ 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,
@@ -1988,7 +1797,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
 
         case '$ArrayLike':
           {
-            // `$ArrayLike<T>` => `ArrayLike<T>`
             return {
               type: 'TSTypeReference',
               loc: DUMMY_LOC,
@@ -1997,7 +1805,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                 loc: DUMMY_LOC,
                 name: 'ArrayLike'
               },
-              typeParameters: {
+              typeArguments: {
                 type: 'TSTypeParameterInstantiation',
                 loc: DUMMY_LOC,
                 params: assertHasExactlyNTypeParameters(1)
@@ -2008,7 +1816,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         case '$Diff':
         case '$Rest':
           {
-            // `$Diff<A, B>` => `Pick<A, Exclude<keyof A, keyof B>>`
             const params = assertHasExactlyNTypeParameters(2);
             return {
               type: 'TSTypeReference',
@@ -2018,7 +1825,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                 loc: DUMMY_LOC,
                 name: 'Pick'
               },
-              typeParameters: {
+              typeArguments: {
                 type: 'TSTypeParameterInstantiation',
                 loc: DUMMY_LOC,
                 params: [params[0], {
@@ -2029,7 +1836,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                     loc: DUMMY_LOC,
                     name: 'Exclude'
                   },
-                  typeParameters: {
+                  typeArguments: {
                     type: 'TSTypeParameterInstantiation',
                     loc: DUMMY_LOC,
                     params: [{
@@ -2052,7 +1859,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         case '$ElementType':
         case '$PropertyType':
           {
-            // `$ElementType<T, K>` => `T[K]`
             const params = assertHasExactlyNTypeParameters(2);
             return {
               type: 'TSIndexedAccessType',
@@ -2064,20 +1870,16 @@ const getTransforms = (originalCode, scopeManager, opts) => {
 
         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',
@@ -2087,14 +1889,15 @@ 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
@@ -2103,7 +1906,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
 
         case '$KeyMirror':
           {
-            // `$KeyMirror<T>` => `{[K in keyof T]: K}`
             return {
               type: 'TSMappedType',
               loc: DUMMY_LOC,
@@ -2150,7 +1952,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
 
         case '$Keys':
           {
-            // `$Keys<T>` => `keyof T`
             return {
               type: 'TSTypeOperator',
               loc: DUMMY_LOC,
@@ -2161,8 +1962,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
 
         case '$NonMaybeType':
           {
-            // `$NonMaybeType<T>` => `NonNullable<T>`
-            // Not a great name because `NonNullable` also excludes `undefined`
             return {
               type: 'TSTypeReference',
               loc: DUMMY_LOC,
@@ -2171,7 +1970,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                 loc: DUMMY_LOC,
                 name: 'NonNullable'
               },
-              typeParameters: {
+              typeArguments: {
                 type: 'TSTypeParameterInstantiation',
                 loc: DUMMY_LOC,
                 params: assertHasExactlyNTypeParameters(1)
@@ -2181,7 +1980,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
 
         case '$ReadOnly':
           {
-            // `$ReadOnly<T>` => `Readonly<T>`
             return {
               type: 'TSTypeReference',
               loc: DUMMY_LOC,
@@ -2190,7 +1988,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                 loc: DUMMY_LOC,
                 name: 'Readonly'
               },
-              typeParameters: {
+              typeArguments: {
                 type: 'TSTypeParameterInstantiation',
                 loc: DUMMY_LOC,
                 params: assertHasExactlyNTypeParameters(1)
@@ -2200,10 +1998,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
 
         case '$ReadOnlyArray':
           {
-            // `$ReadOnlyArray<T>` => `ReadonlyArray<T>`
-            //
-            // we could also do    => `readonly T[]`
-            // TODO - maybe a config option?
             return {
               type: 'TSTypeReference',
               loc: DUMMY_LOC,
@@ -2212,7 +2006,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                 loc: DUMMY_LOC,
                 name: 'ReadonlyArray'
               },
-              typeParameters: {
+              typeArguments: {
                 type: 'TSTypeParameterInstantiation',
                 loc: DUMMY_LOC,
                 params: assertHasExactlyNTypeParameters(1)
@@ -2230,7 +2024,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                 loc: DUMMY_LOC,
                 name: 'ReadonlyMap'
               },
-              typeParameters: {
+              typeArguments: {
                 type: 'TSTypeParameterInstantiation',
                 loc: DUMMY_LOC,
                 params: assertHasExactlyNTypeParameters(2)
@@ -2248,7 +2042,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                 loc: DUMMY_LOC,
                 name: 'ReadonlySet'
               },
-              typeParameters: {
+              typeArguments: {
                 type: 'TSTypeParameterInstantiation',
                 loc: DUMMY_LOC,
                 params: assertHasExactlyNTypeParameters(1)
@@ -2259,7 +2053,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         case '$Values':
         case 'Values':
           {
-            // `$Values<T>` / `Values<T>` => `T[keyof T]`
             const transformedType = assertHasExactlyNTypeParameters(1)[0];
             return {
               type: 'TSIndexedAccessType',
@@ -2276,7 +2069,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
 
         case 'Class':
           {
-            // `Class<T>` => `new (...args: any[]) => T`
             const param = assertHasExactlyNTypeParameters(1)[0];
 
             if (param.type !== 'TSTypeReference') {
@@ -2320,8 +2112,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
           {
             var _params$;
 
-            // `StringPrefix<foo>` => `foo${string}`
-            // `StringPrefix<foo, T>` => `foo${T}`
             const params = assertHasTypeParametersInRange(1, 2);
             const prefix = params[0];
 
@@ -2362,8 +2152,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
           {
             var _params$2;
 
-            // `StringSuffix<foo>` => `${string}foo`
-            // `StringSuffix<foo, T>` => `${T}foo`
             const params = assertHasTypeParametersInRange(1, 2);
             const suffix = params[0];
 
@@ -2399,20 +2187,13 @@ 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 +2209,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                     loc: DUMMY_LOC,
                     name: 'ReadonlyArray'
                   },
-                  typeParameters: {
+                  typeArguments: {
                     type: 'TSTypeParameterInstantiation',
                     loc: DUMMY_LOC,
                     params: [param]
@@ -2436,8 +2217,6 @@ 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':
@@ -2467,15 +2246,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':
@@ -2492,14 +2269,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':
@@ -2518,8 +2293,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                 }
               }
             };
-          // React.ElementType -> React.ElementType
-          // React$ElementType -> React.ElementType
 
           case 'React$ElementType':
           case 'React.ElementType':
@@ -2538,10 +2311,9 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                     name: `ElementType`
                   }
                 },
-                typeParameters: undefined
+                typeArguments: undefined
               };
             }
-          // React.Node -> React.ReactNode
 
           case 'React$Node':
           case 'React.Node':
@@ -2560,10 +2332,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,15 +2352,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':
@@ -2606,14 +2375,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':
@@ -2632,7 +2399,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                 }
               }
             };
-          // React.MixedElement -> React.JSX.Element
 
           case 'React$MixedElement':
           case 'React.MixedElement':
@@ -2664,11 +2430,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,17 +2450,13 @@ 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':
@@ -2740,7 +2500,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                         name: 'RefAttributes'
                       }
                     },
-                    typeParameters: {
+                    typeArguments: {
                       type: 'TSTypeParameterInstantiation',
                       loc: DUMMY_LOC,
                       params: [ref]
@@ -2762,15 +2522,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,15 +2546,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 +2584,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                     name: 'LibraryManagedAttributes'
                   }
                 },
-                typeParameters: {
+                typeArguments: {
                   type: 'TSTypeParameterInstantiation',
                   loc: DUMMY_LOC,
                   params: [param, {
@@ -2844,7 +2600,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                         name: `ComponentProps`
                       }
                     },
-                    typeParameters: {
+                    typeArguments: {
                       type: 'TSTypeParameterInstantiation',
                       loc: DUMMY_LOC,
                       params: [param]
@@ -2853,8 +2609,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                 }
               };
             }
-          // React.RefSetter<C> -> React.Ref<C>
-          // React$RefSetter<C> -> React.Ref<C>
 
           case 'React.RefSetter':
           case 'React$RefSetter':
@@ -2871,7 +2625,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                   name: 'Ref'
                 }
               },
-              typeParameters: {
+              typeArguments: {
                 type: 'TSTypeParameterInstantiation',
                 loc: DUMMY_LOC,
                 params: assertHasExactlyNTypeParameters(1)
@@ -2887,7 +2641,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         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)
       };
     },
 
@@ -2996,24 +2750,20 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         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)]
         };
       }
@@ -3075,8 +2825,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
     },
 
     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,
@@ -3123,7 +2871,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
       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,11 +2899,7 @@ 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 = [];
 
@@ -3173,12 +2916,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
           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');
@@ -3187,8 +2924,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
       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');
           }
 
@@ -3211,67 +2946,8 @@ 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');
         }
@@ -3292,7 +2968,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
 
             typesToIntersect.push(spreadType);
           } else if (property.type === 'ObjectTypeMappedTypeProperty') {
-            // TODO - Support mapped types
             return unsupportedAnnotation(property, 'object type with mapped type property');
           } else {
             members.push({
@@ -3310,11 +2985,23 @@ 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,23 +3010,13 @@ 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
               }]
             }
           });
@@ -3355,7 +3032,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
     },
 
     ObjectTypeCallProperty(node) {
-      // the info is stored on the "value"
       const func = transform.FunctionTypeAnnotation(node.value);
       return {
         type: 'TSCallSignatureDeclaration',
@@ -3464,10 +3140,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
       })();
 
       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,
@@ -3483,10 +3156,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
       }
 
       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,14 +3165,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',
@@ -3525,14 +3192,9 @@ const getTransforms = (originalCode, scopeManager, opts) => {
     },
 
     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',
@@ -3545,7 +3207,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
             loc: DUMMY_LOC,
             name: 'NonNullable'
           },
-          typeParameters: {
+          typeArguments: {
             type: 'TSTypeParameterInstantiation',
             loc: DUMMY_LOC,
             params: [transformTypeAnnotationType(node.objectType)]
@@ -3712,7 +3374,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
             type: 'TSTypeQuery',
             loc: DUMMY_LOC,
             exprName: transform.Identifier(node.argument),
-            typeParameters: undefined
+            typeArguments: undefined
           };
 
         case 'QualifiedTypeofIdentifier':
@@ -3720,31 +3382,12 @@ const getTransforms = (originalCode, scopeManager, opts) => {
             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,9 +3399,7 @@ 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
       };
     },
 
@@ -3771,8 +3412,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
     },
 
     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;
       }
@@ -3882,7 +3521,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                   name: `ReactNode`
                 }
               },
-              typeParameters: undefined
+              typeArguments: undefined
             };
           }
       }
@@ -3890,13 +3529,11 @@ const getTransforms = (originalCode, scopeManager, opts) => {
 
     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 +3547,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
               name: `ReactNode`
             }
           },
-          typeParameters: undefined
+          typeArguments: undefined
         }
       };
       return {
@@ -3922,12 +3559,10 @@ const getTransforms = (originalCode, scopeManager, opts) => {
       };
     }
 
-  }; // 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);