flow-api-translator 0.36.1 → 0.327.0

package/dist/flowDefToTSDef.js.flow

@@ -10,22 +10,26 @@
 
 'use strict';
 
-import type {ObjectWithLoc} from 'hermes-estree';
+import type {ObjectWithLoc} from 'flow-estree';
 import type {TranslationOptions} from './utils/TranslationUtils';
-import type {ScopeManager} from 'hermes-eslint';
+import type {ScopeManager} from 'flow-eslint';
 
-import * as FlowESTree from 'hermes-estree';
+import * as FlowESTree from 'flow-estree';
 import * as TSESTree from './utils/ts-estree-ast-types';
 import {
   cloneJSDocCommentsToNewNode as cloneJSDocCommentsToNewNodeOriginal,
   makeCommentOwnLine as makeCommentOwnLineOriginal,
-} from 'hermes-transform';
+} from 'flow-transform';
 import {
   buildCodeFrame,
   translationError as translationErrorBase,
   unexpectedTranslationError as unexpectedTranslationErrorBase,
 } from './utils/ErrorUtils';
 import {removeAtFlowFromDocblock} from './utils/DocblockUtils';
+import {
+  ensureTypeIncludesUndefined,
+  extractPropertyKeyLiterals,
+} from './utils/TSNodeUtils';
 import {EOL} from 'os';
 
 type DeclarationOrUnsupported<T> = T | TSESTree.TSTypeAliasDeclaration;
@@ -35,23 +39,82 @@ const DUMMY_LOC: FlowESTree.SourceLocation = {
   end: {line: 1, column: 0},
 };
 
-type LooseOmit<O: interface {}, K: $Keys<$FlowFixMe>> = Pick<
+type LooseOmit<O extends interface {}, K extends keyof $FlowFixMe> = Pick<
   O,
-  Exclude<$Keys<O>, K>,
+  Exclude<keyof O, K>,
 >;
-function constructFlowNode<T: FlowESTree.BaseNode>(
+function constructFlowNode<T extends FlowESTree.BaseNode>(
   node: LooseOmit<NoInfer<T>, 'parent'>,
 ): T {
-  return (node: $FlowFixMe);
+  return node as $FlowFixMe;
 }
 
 const cloneJSDocCommentsToNewNode =
   // $FlowExpectedError[incompatible-type] - trust me this re-type is 100% safe
-  (cloneJSDocCommentsToNewNodeOriginal: (mixed, mixed) => void);
+  cloneJSDocCommentsToNewNodeOriginal as (unknown, unknown) => void;
 
 const makeCommentOwnLine =
   // $FlowExpectedError[incompatible-type] - trust me this re-type is 100% safe
-  (makeCommentOwnLineOriginal: (string, mixed) => string);
+  makeCommentOwnLineOriginal as (string, unknown) => string;
+
+/**
+ * `DeclareComponent` reaches us in one of two shapes: parsed nodes carry
+ * `ComponentParameter`/`RestElement` in `params` with a null `rest` (the
+ * `ComponentDeclaration` shape the Flow parser reuses here), while detached
+ * nodes built with `flow-transform` use `ComponentTypeParameter` + `rest`.
+ * Normalize both onto the latter so the shared `ComponentTypeParameters`
+ * translation — which `ComponentTypeAnnotation` also uses — sees one shape.
+ */
+function normalizeDeclareComponentParams(
+  params: FlowESTree.DeclareComponent['params'],
+  rest: FlowESTree.DeclareComponent['rest'],
+  onUnexpected: (node: ObjectWithLoc, message: string) => Error,
+): [
+  ReadonlyArray<FlowESTree.ComponentTypeParameter>,
+  FlowESTree.ComponentTypeParameter | null,
+] {
+  const normalizedParams: Array<FlowESTree.ComponentTypeParameter> = [];
+  let normalizedRest: FlowESTree.ComponentTypeParameter | null = rest;
+
+  const toComponentTypeParameter = (
+    name: FlowESTree.ComponentTypeParameter['name'],
+    local: FlowESTree.ESNode,
+    source: FlowESTree.BaseToken,
+  ): FlowESTree.ComponentTypeParameter => {
+    if (local.type !== 'Identifier' || local.typeAnnotation == null) {
+      throw onUnexpected(
+        source,
+        `DeclareComponent: expected an annotated identifier parameter, got "${local.type}"`,
+      );
+    }
+    return constructFlowNode<FlowESTree.ComponentTypeParameter>({
+      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<string>(['React', 'react']);
 
@@ -180,7 +243,7 @@ const getTransforms = (
     // $FlowExpectedError[cannot-write]
     node.comments ??= [];
     // $FlowExpectedError[incompatible-type]
-    (node.comments: Array<TSESTree.Comment>).push(comment);
+    (node.comments as Array<TSESTree.Comment>).push(comment);
   }
   function unsupportedAnnotation(
     node: ObjectWithLoc,
@@ -385,12 +448,12 @@ const getTransforms = (
             loc: DUMMY_LOC,
             computed: false,
             id: transform.Identifier(member.id, false),
-            initializer: ({
+            initializer: {
               type: 'Literal',
               loc: DUMMY_LOC,
               raw: `"${member.id.name}"`,
               value: member.id.name,
-            }: TSESTree.StringLiteral),
+            } as TSESTree.StringLiteral,
           });
           break;
         }
@@ -607,7 +670,7 @@ const getTransforms = (
                       loc: DUMMY_LOC,
                       name: 'IterableIterator',
                     },
-                    typeParameters: {
+                    typeArguments: {
                       type: 'TSTypeParameterInstantiation',
                       loc: DUMMY_LOC,
                       params: [
@@ -818,13 +881,13 @@ const getTransforms = (
       return {
         type: 'TSLiteralType',
         loc: DUMMY_LOC,
-        literal: ({
+        literal: {
           type: 'Literal',
           loc: DUMMY_LOC,
           value: node.value,
           raw: node.raw,
           bigint,
-        }: TSESTree.BigIntLiteral),
+        } as TSESTree.BigIntLiteral,
       };
     },
     BigIntTypeAnnotation(
@@ -849,12 +912,12 @@ const getTransforms = (
       return {
         type: 'TSLiteralType',
         loc: DUMMY_LOC,
-        literal: ({
+        literal: {
           type: 'Literal',
           loc: DUMMY_LOC,
           value: node.value,
           raw: node.raw,
-        }: TSESTree.BooleanLiteral),
+        } as TSESTree.BooleanLiteral,
       };
     },
     BooleanTypeAnnotation(
@@ -872,7 +935,7 @@ const getTransforms = (
         type: 'TSClassImplements',
         loc: DUMMY_LOC,
         expression: transform.Identifier(node.id, false),
-        typeParameters: transform.TypeParameterInstantiation(
+        typeArguments: transform.TypeParameterInstantiation(
           node.typeParameters,
         ),
       };
@@ -1084,8 +1147,8 @@ const getTransforms = (
             ? null
             : superClass.id.type === 'QualifiedTypeIdentifier'
               ? transform.QualifiedTypeIdentifier(superClass.id)
-              : transform.Identifier((superClass.id: $FlowFixMe), false),
-        superTypeParameters: transform.TypeParameterInstantiation(
+              : transform.Identifier(superClass.id as $FlowFixMe, false),
+        superTypeArguments: transform.TypeParameterInstantiation(
           superClass?.typeParameters,
         ),
         typeParameters:
@@ -1378,7 +1441,7 @@ const getTransforms = (
         if (node.source === null) {
           // eslint-disable-next-line eqeqeq
           if (node.declaration === null) {
-            return ({
+            return {
               type: 'ExportNamedDeclaration',
               loc: DUMMY_LOC,
               // flow does not currently support attributes
@@ -1388,7 +1451,7 @@ const getTransforms = (
               exportKind: 'value',
               source: null,
               specifiers: node.specifiers.map(transform.ExportSpecifier),
-            }: TSESTree.ExportNamedDeclarationWithoutSourceWithMultiple);
+            } as TSESTree.ExportNamedDeclarationWithoutSourceWithMultiple;
           }
 
           const declarations = ((): Array<{
@@ -1537,7 +1600,7 @@ const getTransforms = (
 
           return mappedDeclarations.flat();
         } else {
-          return ({
+          return {
             type: 'ExportNamedDeclaration',
             loc: DUMMY_LOC,
             // flow does not currently support attributes
@@ -1547,7 +1610,7 @@ const getTransforms = (
             exportKind: 'value',
             source: transform.StringLiteral(node.source),
             specifiers: node.specifiers.map(transform.ExportSpecifier),
-          }: TSESTree.ExportNamedDeclarationWithSource);
+          } as TSESTree.ExportNamedDeclarationWithSource;
         }
       }
     },
@@ -1561,7 +1624,15 @@ const getTransforms = (
           ? undefined
           : transform.TypeParameterDeclaration(node.typeParameters);
 
-      const params = transform.ComponentTypeParameters(node.params, node.rest);
+      const [declaredParams, declaredRest] = normalizeDeclareComponentParams(
+        node.params,
+        node.rest,
+        unexpectedTranslationError,
+      );
+      const params = transform.ComponentTypeParameters(
+        declaredParams,
+        declaredRest,
+      );
 
       // TS cannot support `renderType` so we always use ReactNode as the return type.
       const hasReactImport = isReactImport(node, 'React');
@@ -1582,7 +1653,7 @@ const getTransforms = (
               name: `ReactNode`,
             },
           },
-          typeParameters: undefined,
+          typeArguments: undefined,
         },
       };
 
@@ -1605,9 +1676,9 @@ const getTransforms = (
       };
     },
     ComponentTypeParameters(
-      params: $ReadOnlyArray<FlowESTree.ComponentTypeParameter>,
+      params: ReadonlyArray<FlowESTree.ComponentTypeParameter>,
       rest: FlowESTree.ComponentTypeParameter | null,
-    ): $ReadOnlyArray<TSESTree.Parameter> {
+    ): ReadonlyArray<TSESTree.Parameter> {
       if (params.length === 0 && rest != null) {
         return [
           {
@@ -1860,15 +1931,21 @@ const getTransforms = (
         type: 'VariableDeclaration',
         loc: DUMMY_LOC,
         declare: true,
-        declarations: [
-          {
+        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(node.id, true),
+            id: transform.Identifier(declaration.id, true),
             init: null,
-          },
-        ],
+          };
+        }),
         kind: node.kind,
       };
     },
@@ -1974,7 +2051,7 @@ const getTransforms = (
       })();
 
       const mainExport = {
-        type: ('ExportNamedDeclaration': 'ExportNamedDeclaration'),
+        type: 'ExportNamedDeclaration' as 'ExportNamedDeclaration',
         loc: DUMMY_LOC,
         assertions: [],
         declaration: exportedDeclaration,
@@ -2112,7 +2189,7 @@ const getTransforms = (
 
       const assertHasExactlyNTypeParameters = (
         count: number,
-      ): $ReadOnlyArray<TSESTree.TypeNode> => {
+      ): ReadonlyArray<TSESTree.TypeNode> => {
         if (node.typeParameters != null) {
           if (node.typeParameters.params.length !== count) {
             throw translationError(
@@ -2143,7 +2220,7 @@ const getTransforms = (
       function assertHasTypeParametersInRange(
         min: number,
         max: number,
-      ): $ReadOnlyArray<TSESTree.TypeNode> {
+      ): ReadonlyArray<TSESTree.TypeNode> {
         const {typeParameters} = node;
         if (typeParameters == null) {
           if (min > 0) {
@@ -2219,7 +2296,7 @@ const getTransforms = (
               loc: DUMMY_LOC,
               name: 'ArrayLike',
             },
-            typeParameters: {
+            typeArguments: {
               type: 'TSTypeParameterInstantiation',
               loc: DUMMY_LOC,
               params: assertHasExactlyNTypeParameters(1),
@@ -2239,7 +2316,7 @@ const getTransforms = (
               loc: DUMMY_LOC,
               name: 'Pick',
             },
-            typeParameters: {
+            typeArguments: {
               type: 'TSTypeParameterInstantiation',
               loc: DUMMY_LOC,
               params: [
@@ -2252,7 +2329,7 @@ const getTransforms = (
                     loc: DUMMY_LOC,
                     name: 'Exclude',
                   },
-                  typeParameters: {
+                  typeArguments: {
                     type: 'TSTypeParameterInstantiation',
                     loc: DUMMY_LOC,
                     params: [
@@ -2309,7 +2386,7 @@ const getTransforms = (
           }
 
           // New AST format for `typeof import('module')`
-          return ({
+          return {
             type: 'TSTypeQuery',
             loc: DUMMY_LOC,
             exprName: {
@@ -2317,9 +2394,11 @@ const getTransforms = (
               loc: DUMMY_LOC,
               argument: moduleName,
               qualifier: null,
-              typeParameters: null,
+              options: null,
+              source: moduleName.literal,
+              typeArguments: null,
             },
-          }: $FlowFixMe);
+          } as $FlowFixMe;
         }
 
         case '$FlowFixMe': {
@@ -2397,7 +2476,7 @@ const getTransforms = (
               loc: DUMMY_LOC,
               name: 'NonNullable',
             },
-            typeParameters: {
+            typeArguments: {
               type: 'TSTypeParameterInstantiation',
               loc: DUMMY_LOC,
               params: assertHasExactlyNTypeParameters(1),
@@ -2415,7 +2494,7 @@ const getTransforms = (
               loc: DUMMY_LOC,
               name: 'Readonly',
             },
-            typeParameters: {
+            typeArguments: {
               type: 'TSTypeParameterInstantiation',
               loc: DUMMY_LOC,
               params: assertHasExactlyNTypeParameters(1),
@@ -2436,7 +2515,7 @@ const getTransforms = (
               loc: DUMMY_LOC,
               name: 'ReadonlyArray',
             },
-            typeParameters: {
+            typeArguments: {
               type: 'TSTypeParameterInstantiation',
               loc: DUMMY_LOC,
               params: assertHasExactlyNTypeParameters(1),
@@ -2453,7 +2532,7 @@ const getTransforms = (
               loc: DUMMY_LOC,
               name: 'ReadonlyMap',
             },
-            typeParameters: {
+            typeArguments: {
               type: 'TSTypeParameterInstantiation',
               loc: DUMMY_LOC,
               params: assertHasExactlyNTypeParameters(2),
@@ -2470,7 +2549,7 @@ const getTransforms = (
               loc: DUMMY_LOC,
               name: 'ReadonlySet',
             },
-            typeParameters: {
+            typeArguments: {
               type: 'TSTypeParameterInstantiation',
               loc: DUMMY_LOC,
               params: assertHasExactlyNTypeParameters(1),
@@ -2640,7 +2719,7 @@ const getTransforms = (
       const hasReactImport = isReactImport(baseId, baseId.name);
       if (validReactImportOrGlobal || hasReactImport) {
         switch (fullTypeName) {
-          // TODO: In flow this is `ChildrenArray<T> = T | $ReadOnlyArray<ChildrenArray<T>>`.
+          // 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.
@@ -2662,7 +2741,7 @@ const getTransforms = (
                     loc: DUMMY_LOC,
                     name: 'ReadonlyArray',
                   },
-                  typeParameters: {
+                  typeArguments: {
                     type: 'TSTypeParameterInstantiation',
                     loc: DUMMY_LOC,
                     params: [param],
@@ -2703,7 +2782,7 @@ const getTransforms = (
                   name: 'Component',
                 },
               },
-              typeParameters: {
+              typeArguments: {
                 type: 'TSTypeParameterInstantiation',
                 loc: DUMMY_LOC,
                 params: params.map(param => transformTypeAnnotationType(param)),
@@ -2728,7 +2807,7 @@ const getTransforms = (
                   name: `Context`,
                 },
               },
-              typeParameters: {
+              typeArguments: {
                 type: 'TSTypeParameterInstantiation',
                 loc: DUMMY_LOC,
                 params: assertHasExactlyNTypeParameters(1),
@@ -2771,7 +2850,7 @@ const getTransforms = (
                   name: `ElementType`,
                 },
               },
-              typeParameters: undefined,
+              typeArguments: undefined,
             };
           }
           // React.Node -> React.ReactNode
@@ -2791,7 +2870,7 @@ const getTransforms = (
                   name: `ReactNode`,
                 },
               },
-              typeParameters: undefined,
+              typeArguments: undefined,
             };
           }
           // React.Element<typeof Component> -> React.ReactElement<typeof Component>
@@ -2810,7 +2889,7 @@ const getTransforms = (
                   name: `ReactElement`,
                 },
               },
-              typeParameters: {
+              typeArguments: {
                 type: 'TSTypeParameterInstantiation',
                 loc: DUMMY_LOC,
                 params: assertHasExactlyNTypeParameters(1),
@@ -2834,7 +2913,7 @@ const getTransforms = (
                   name: `ComponentRef`,
                 },
               },
-              typeParameters: {
+              typeArguments: {
                 type: 'TSTypeParameterInstantiation',
                 loc: DUMMY_LOC,
                 params: assertHasExactlyNTypeParameters(1),
@@ -2889,7 +2968,7 @@ const getTransforms = (
                   name: 'Element',
                 },
               },
-              typeParameters: undefined,
+              typeArguments: undefined,
             };
           }
           // React.ComponentType<Config> -> React.ComponentType<Config>
@@ -2909,7 +2988,7 @@ const getTransforms = (
                   name: 'ComponentType',
                 },
               },
-              typeParameters: {
+              typeArguments: {
                 type: 'TSTypeParameterInstantiation',
                 loc: DUMMY_LOC,
                 params: assertHasExactlyNTypeParameters(1),
@@ -2937,7 +3016,7 @@ const getTransforms = (
               );
             }
 
-            const newParams = ((): $ReadOnlyArray<TSESTree.TypeNode> => {
+            const newParams = ((): ReadonlyArray<TSESTree.TypeNode> => {
               if (params.length === 1) {
                 return assertHasExactlyNTypeParameters(1);
               }
@@ -2968,7 +3047,7 @@ const getTransforms = (
                           name: 'RefAttributes',
                         },
                       },
-                      typeParameters: {
+                      typeArguments: {
                         type: 'TSTypeParameterInstantiation',
                         loc: DUMMY_LOC,
                         params: [ref],
@@ -2992,7 +3071,7 @@ const getTransforms = (
                   name: 'ComponentType',
                 },
               },
-              typeParameters: {
+              typeArguments: {
                 type: 'TSTypeParameterInstantiation',
                 loc: DUMMY_LOC,
                 params: newParams,
@@ -3016,7 +3095,7 @@ const getTransforms = (
                   name: 'ComponentProps',
                 },
               },
-              typeParameters: {
+              typeArguments: {
                 type: 'TSTypeParameterInstantiation',
                 loc: DUMMY_LOC,
                 params: assertHasExactlyNTypeParameters(1),
@@ -3054,7 +3133,7 @@ const getTransforms = (
                   name: 'LibraryManagedAttributes',
                 },
               },
-              typeParameters: {
+              typeArguments: {
                 type: 'TSTypeParameterInstantiation',
                 loc: DUMMY_LOC,
                 params: [
@@ -3072,7 +3151,7 @@ const getTransforms = (
                         name: `ComponentProps`,
                       },
                     },
-                    typeParameters: {
+                    typeArguments: {
                       type: 'TSTypeParameterInstantiation',
                       loc: DUMMY_LOC,
                       params: [param],
@@ -3099,7 +3178,7 @@ const getTransforms = (
                   name: 'Ref',
                 },
               },
-              typeParameters: {
+              typeArguments: {
                 type: 'TSTypeParameterInstantiation',
                 loc: DUMMY_LOC,
                 params: assertHasExactlyNTypeParameters(1),
@@ -3117,7 +3196,7 @@ const getTransforms = (
           node.id.type === 'Identifier'
             ? transform.Identifier(node.id, false)
             : transform.QualifiedTypeIdentifier(node.id),
-        typeParameters: transform.TypeParameterInstantiation(
+        typeArguments: transform.TypeParameterInstantiation(
           node.typeParameters,
         ),
       };
@@ -3256,7 +3335,7 @@ const getTransforms = (
           node.id.type === 'QualifiedTypeIdentifier'
             ? transform.QualifiedTypeIdentifier(node.id)
             : transform.Identifier(node.id, false),
-        typeParameters: transform.TypeParameterInstantiation(
+        typeArguments: transform.TypeParameterInstantiation(
           node.typeParameters,
         ),
       };
@@ -3276,8 +3355,8 @@ const getTransforms = (
               type: 'TSTypeReference',
               loc: DUMMY_LOC,
               // Bug: ex.id can be qualified
-              typeName: transform.Identifier((ex.id: $FlowFixMe), false),
-              typeParameters: transform.TypeParameterInstantiation(
+              typeName: transform.Identifier(ex.id as $FlowFixMe, false),
+              typeArguments: transform.TypeParameterInstantiation(
                 ex.typeParameters,
               ),
             })),
@@ -3364,12 +3443,12 @@ const getTransforms = (
       return {
         type: 'TSLiteralType',
         loc: DUMMY_LOC,
-        literal: ({
+        literal: {
           type: 'Literal',
           loc: DUMMY_LOC,
           value: node.value,
           raw: node.raw,
-        }: TSESTree.NumberLiteral),
+        } as TSESTree.NumberLiteral,
       };
     },
     NumberTypeAnnotation(
@@ -3546,15 +3625,15 @@ const getTransforms = (
         ```
         type T = { ...T1, b: string  };
         // becomes
-        type T = Omit<T1, keyof { b: string }> & { b: string };
+        type T = Omit<T1, 'b'> & { 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 }>
+          & Omit<T1, keyof T2 | keyof T3 | 'b'>
+          & Omit<T2, keyof T3 | 'b'>
+          & Omit<T3, 'b'>
           & { b: string };
         ```
 
@@ -3616,10 +3695,33 @@ const getTransforms = (
           members: tsBody,
         };
 
+        // When the non-spread properties have statically known key
+        // names, emit them as string literal types directly instead of
+        // wrapping in `keyof`. Falls back to `keyof objectType` when
+        // any key is computed or otherwise non-extractable.
+        const objectKeyTypes: ReadonlyArray<TSESTree.TypeNode> =
+          extractPropertyKeyLiterals(tsBody) ?? [
+            {
+              type: 'TSTypeOperator',
+              loc: DUMMY_LOC,
+              operator: 'keyof',
+              typeAnnotation: objectType,
+            },
+          ];
+
         const intersectionMembers: Array<TSESTree.TypeNode> = [];
         for (let i = 0; i < typesToIntersect.length; i += 1) {
           const currentType = typesToIntersect[i];
           const remainingTypes = typesToIntersect.slice(i + 1);
+          const omitKeyTypes: Array<TSESTree.TypeNode> = [
+            ...remainingTypes.map(t => ({
+              type: 'TSTypeOperator',
+              loc: DUMMY_LOC,
+              operator: 'keyof',
+              typeAnnotation: t,
+            })),
+            ...objectKeyTypes,
+          ];
           intersectionMembers.push({
             type: 'TSTypeReference',
             loc: DUMMY_LOC,
@@ -3628,29 +3730,18 @@ const getTransforms = (
               loc: DUMMY_LOC,
               name: 'Omit',
             },
-            typeParameters: {
+            typeArguments: {
               type: 'TSTypeParameterInstantiation',
               loc: DUMMY_LOC,
               params: [
                 currentType,
-                {
-                  type: 'TSUnionType',
-                  loc: DUMMY_LOC,
-                  types: [
-                    ...remainingTypes.map(t => ({
-                      type: 'TSTypeOperator',
+                omitKeyTypes.length === 1
+                  ? omitKeyTypes[0]
+                  : {
+                      type: 'TSUnionType',
                       loc: DUMMY_LOC,
-                      operator: 'keyof',
-                      typeAnnotation: t,
-                    })),
-                    {
-                      type: 'TSTypeOperator',
-                      loc: DUMMY_LOC,
-                      operator: 'keyof',
-                      typeAnnotation: objectType,
+                      types: omitKeyTypes,
                     },
-                  ],
-                },
               ],
             },
           });
@@ -3836,7 +3927,12 @@ const getTransforms = (
         typeAnnotation: {
           type: 'TSTypeAnnotation',
           loc: DUMMY_LOC,
-          typeAnnotation: transformTypeAnnotationType(node.value),
+          typeAnnotation:
+            node.optional === true
+              ? ensureTypeIncludesUndefined(
+                  transformTypeAnnotationType(node.value),
+                )
+              : transformTypeAnnotationType(node.value),
         },
       };
     },
@@ -3866,7 +3962,7 @@ const getTransforms = (
             loc: DUMMY_LOC,
             name: 'NonNullable',
           },
-          typeParameters: {
+          typeArguments: {
             type: 'TSTypeParameterInstantiation',
             loc: DUMMY_LOC,
             params: [transformTypeAnnotationType(node.objectType)],
@@ -3931,12 +4027,12 @@ const getTransforms = (
       return {
         type: 'TSLiteralType',
         loc: DUMMY_LOC,
-        literal: ({
+        literal: {
           type: 'Literal',
           loc: DUMMY_LOC,
           value: node.value,
           raw: node.raw,
-        }: TSESTree.StringLiteral),
+        } as TSESTree.StringLiteral,
       };
     },
     StringTypeAnnotation(
@@ -4064,14 +4160,14 @@ const getTransforms = (
             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,
           };
       }
     },
@@ -4249,7 +4345,7 @@ const getTransforms = (
                 name: `ReactNode`,
               },
             },
-            typeParameters: undefined,
+            typeArguments: undefined,
           };
         }
       }
@@ -4283,7 +4379,7 @@ const getTransforms = (
               name: `ReactNode`,
             },
           },
-          typeParameters: undefined,
+          typeArguments: undefined,
         },
       };