flow-api-translator 0.36.0 → 0.37.0

package/dist/TSDefToFlowDef.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", {
@@ -43,8 +34,7 @@ function constructFlowNode(node) {
   };
 }
 
-const makeCommentOwnLine = // $FlowExpectedError[incompatible-type] - trust me this re-type is 100% safe
-_hermesTransform.makeCommentOwnLine;
+const makeCommentOwnLine = _hermesTransform.makeCommentOwnLine;
 
 function TSDefToFlowDef(originalCode, ast, opts) {
   const flowBody = [];
@@ -66,10 +56,7 @@ function TSDefToFlowDef(originalCode, ast, opts) {
   }
 
   return [flowProgram, code];
-} // Note: The implementation here is still in early stage. If something is not supported, it doesn't
-// necessarily mean that it cannot be. It might just mean that it's not priortized yet. If something
-// is translated in way that is wrong, then it's likely wrong.
-
+}
 
 const getTransforms = (originalCode, opts) => {
   let code = originalCode;
@@ -104,11 +91,8 @@ const getTransforms = (originalCode, 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);
   }
 
@@ -183,14 +167,12 @@ const getTransforms = (originalCode, opts) => {
 
           case 'TSAbstractPropertyDefinition':
           case 'PropertyDefinition':
-            // $FlowFixMe[incompatible-type] ambiguous node
             Transform._translateIntoObjectProp(classItem, properties, indexers);
 
             break;
 
           case 'MethodDefinition':
           case 'TSAbstractMethodDefinition':
-            // $FlowFixMe[incompatible-type] ambiguous node
             Transform._translateIntoObjectMethod(classItem, properties);
 
             break;
@@ -296,13 +278,11 @@ const getTransforms = (originalCode, opts) => {
 
       switch (node.declaration.type) {
         case 'ClassDeclaration':
-          declaration = Transform.ClassDeclarationWithName( // possibly missing id
-          node.declaration);
+          declaration = Transform.ClassDeclarationWithName(node.declaration);
           break;
 
         case 'FunctionDeclaration':
-          declaration = Transform.FunctionDeclarationWithName( // possibly missing id
-          node.declaration);
+          declaration = Transform.FunctionDeclarationWithName(node.declaration);
           break;
 
         case 'TSDeclareFunction':
@@ -355,8 +335,7 @@ const getTransforms = (originalCode, opts) => {
         case 'ClassDeclaration':
           return constructFlowNode({
             type: 'DeclareExportDeclaration',
-            declaration: Transform.ClassDeclarationWithName( // possibly missing id
-            node.declaration),
+            declaration: Transform.ClassDeclarationWithName(node.declaration),
             default: false,
             source: null,
             specifiers: []
@@ -365,8 +344,7 @@ const getTransforms = (originalCode, opts) => {
         case 'FunctionDeclaration':
           return constructFlowNode({
             type: 'DeclareExportDeclaration',
-            declaration: Transform.FunctionDeclarationWithName( // possibly missing id
-            node.declaration),
+            declaration: Transform.FunctionDeclarationWithName(node.declaration),
             default: false,
             source: null,
             specifiers: []
@@ -523,8 +501,7 @@ const getTransforms = (originalCode, opts) => {
           value: node.source.value,
           raw: node.source.raw
         }),
-        importKind: // `import type React from 'react'` in TS means `import typeof React from react` in Flow
-        specifiers.some(s => s.type === 'ImportDefaultSpecifier') && node.importKind === 'type' ? 'typeof' : node.importKind,
+        importKind: specifiers.some(s => s.type === 'ImportDefaultSpecifier') && node.importKind === 'type' ? 'typeof' : node.importKind,
         attributes: [],
         specifiers
       });
@@ -691,10 +668,6 @@ const getTransforms = (originalCode, opts) => {
           return Transform.TSModuleDeclaration(node);
 
         case 'TSNamespaceExportDeclaration':
-          // Flow will never support `export as namespace` since we can't allow a normal file to
-          // introduce a global out of nowhere, and because it's only useful for legacy module
-          // system However, it's very reasonable to completely ignore it under some mode, so that
-          // people using these libdefs won't have a lot of pain.
           return [];
 
         case 'TSTypeAliasDeclaration':
@@ -936,6 +909,18 @@ const getTransforms = (originalCode, opts) => {
     }
 
     static TSImportType(node) {
+      var _node$argument;
+
+      const source = (_node$argument = node.argument) != null ? _node$argument : node.source == null ? null : {
+        type: 'TSLiteralType',
+        loc: node.source.loc,
+        literal: node.source
+      };
+
+      if (source == null) {
+        return unsupportedAnnotation(node, 'import types without a source');
+      }
+
       let base = constructFlowNode({
         type: 'GenericTypeAnnotation',
         id: constructFlowNode({
@@ -946,16 +931,16 @@ const getTransforms = (originalCode, opts) => {
         }),
         typeParameters: constructFlowNode({
           type: 'TypeParameterInstantiation',
-          params: [Transform.TSTypeAnnotation(node.argument)]
+          params: [Transform.TSTypeAnnotation(source)]
         })
       });
 
-      if (node.qualifier == null) {
-        return base;
+      if (node.typeArguments != null) {
+        return unsupportedAnnotation(node, 'import types with type arguments');
       }
 
-      if (node.typeParameters != null) {
-        return unsupportedAnnotation(node, 'import types with type parameters');
+      if (node.qualifier == null) {
+        return base;
       }
 
       let qualifier = Transform.EntityNameToTypeIdentifier(node.qualifier);
@@ -975,9 +960,7 @@ const getTransforms = (originalCode, opts) => {
           objectType: base,
           indexType: constructFlowNode({
             type: 'StringLiteralTypeAnnotation',
-            // $FlowFixMe[incompatible-type]
             value: name,
-            // $FlowFixMe[incompatible-type]
             raw: `'${name}'`
           })
         });
@@ -1051,8 +1034,7 @@ const getTransforms = (originalCode, opts) => {
     }
 
     static TSInterfaceDeclaration(node) {
-      const body = Transform.TSTypeLiteralOrInterfaceBody(node.body); // $FlowFixMe[cannot-write]
-
+      const body = Transform.TSTypeLiteralOrInterfaceBody(node.body);
       body.inexact = false;
       return constructFlowNode({
         type: 'InterfaceDeclaration',
@@ -1113,8 +1095,7 @@ const getTransforms = (originalCode, opts) => {
       var _keyTparam$bound;
 
       const keyTparam = Transform.TSTypeParameter(node.typeParameter);
-      const sourceType = (_keyTparam$bound = keyTparam.bound) == null ? void 0 : _keyTparam$bound.typeAnnotation; // $FlowFixMe[cannot-write]
-
+      const sourceType = (_keyTparam$bound = keyTparam.bound) == null ? void 0 : _keyTparam$bound.typeAnnotation;
       keyTparam.bound = null;
       const prop = constructFlowNode({
         type: 'ObjectTypeMappedTypeProperty',
@@ -1125,8 +1106,7 @@ const getTransforms = (originalCode, opts) => {
           type: 'Variance',
           kind: 'plus'
         }) : null,
-        optional: node.optional === '+' ? 'PlusOptional' : node.optional === '-' ? 'MinusOptional' : // eslint-disable-next-line no-extra-boolean-cast
-        Boolean(node.optional) ? 'Optional' : null
+        optional: node.optional === '+' ? 'PlusOptional' : node.optional === '-' ? 'MinusOptional' : Boolean(node.optional) ? 'Optional' : null
       });
       return constructFlowNode({
         type: 'ObjectTypeAnnotation',
@@ -1425,8 +1405,6 @@ const getTransforms = (originalCode, opts) => {
         typeAnnotation: Transform.TSTypeAnnotation(node.typeAnnotation)
       });
     }
-    /** A very confusingly named object type */
-
 
     static TSTypeLiteralOrInterfaceBody(node) {
       const properties = [];
@@ -1471,7 +1449,6 @@ const getTransforms = (originalCode, opts) => {
             {
               var _prop$typeAnnotation;
 
-              // eslint-disable-next-line no-extra-boolean-cast
               const variance = Boolean(prop.readonly) ? constructFlowNode({
                 type: 'Variance',
                 kind: 'plus'
@@ -1532,7 +1509,6 @@ const getTransforms = (originalCode, opts) => {
     }
 
     static _translateIntoObjectProp(prop, properties, indexers) {
-      // eslint-disable-next-line no-extra-boolean-cast
       const variance = Boolean(prop.readonly) ? constructFlowNode({
         type: 'Variance',
         kind: 'plus'
@@ -1741,10 +1717,18 @@ const getTransforms = (originalCode, opts) => {
     static TSTypeQuery(node) {
       var _Transform$TSTypePara;
 
+      if (node.exprName.type === 'TSImportType') {
+        if (node.typeArguments != null) {
+          return unsupportedAnnotation(node, 'type query imports with type arguments');
+        }
+
+        return Transform.TSImportType(node.exprName);
+      }
+
       return constructFlowNode({
         type: 'TypeofTypeAnnotation',
         argument: Transform.EntityNameToTypeofIdentifier(node.exprName),
-        typeArguments: (_Transform$TSTypePara = Transform.TSTypeParameterInstantiationOpt(node.typeParameters)) != null ? _Transform$TSTypePara : undefined
+        typeArguments: (_Transform$TSTypePara = Transform.TSTypeParameterInstantiationOpt(node.typeArguments)) != null ? _Transform$TSTypePara : undefined
       });
     }
 
@@ -1784,7 +1768,6 @@ const getTransforms = (originalCode, opts) => {
         const id = Transform.Identifier(decl.id);
 
         if (id.typeAnnotation == null) {
-          // $FlowExpectedError[cannot-write]
           id.typeAnnotation = constructFlowNode({
             type: 'TypeAnnotation',
             typeAnnotation: constructFlowNode({

package/dist/TSDefToFlowDef.js.flow

@@ -23,7 +23,7 @@ import {
 } from './utils/ErrorUtils';
 import {EOL} from 'os';
 
-const DUMMY_LOC: FlowESTree.SourceLocation = (null: $FlowFixMe);
+const DUMMY_LOC: FlowESTree.SourceLocation = null as $FlowFixMe;
 const DUMMY_RANGE: [number, number] = [0, 0];
 const DUMMY_PARENT: $FlowFixMe = null;
 const DUMMY_COMMON = {
@@ -32,22 +32,22 @@ const DUMMY_COMMON = {
   parent: DUMMY_PARENT,
 };
 
-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),
+    ...(node as $FlowFixMe),
     ...DUMMY_COMMON,
   };
 }
 
 const makeCommentOwnLine =
   // $FlowExpectedError[incompatible-type] - trust me this re-type is 100% safe
-  (makeCommentOwnLineOriginal: (string, mixed) => string);
+  makeCommentOwnLineOriginal as (string, unknown) => string;
 
 export function TSDefToFlowDef(
   originalCode: string,
@@ -113,7 +113,7 @@ const getTransforms = (originalCode: string, opts: TranslationOptions) => {
     // $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,
@@ -330,13 +330,13 @@ const getTransforms = (originalCode: string, opts: TranslationOptions) => {
         case 'ClassDeclaration':
           declaration = Transform.ClassDeclarationWithName(
             // possibly missing id
-            (node.declaration: $FlowFixMe),
+            node.declaration as $FlowFixMe,
           );
           break;
         case 'FunctionDeclaration':
           declaration = Transform.FunctionDeclarationWithName(
             // possibly missing id
-            (node.declaration: $FlowFixMe),
+            node.declaration as $FlowFixMe,
           );
           break;
         case 'TSDeclareFunction':
@@ -369,7 +369,7 @@ const getTransforms = (originalCode: string, opts: TranslationOptions) => {
       | FlowESTree.ExportNamedDeclaration
       | FlowESTree.DeclareExportDeclarationNamedWithDeclaration
       | FlowESTree.DeclareExportDeclarationNamedWithSpecifiers
-      | $ReadOnlyArray<
+      | ReadonlyArray<
           | FlowESTree.DeclareExportDeclarationNamedWithDeclaration
           | FlowESTree.TypeAlias
           | FlowESTree.DeclareNamespace
@@ -379,7 +379,7 @@ const getTransforms = (originalCode: string, opts: TranslationOptions) => {
       if (node.declaration == null) {
         const source: FlowESTree.StringLiteral =
           node.source == null
-            ? (null: $FlowFixMe)
+            ? (null as $FlowFixMe)
             : constructFlowNode<FlowESTree.StringLiteral>({
                 type: 'Literal',
                 literalType: 'string',
@@ -410,7 +410,7 @@ const getTransforms = (originalCode: string, opts: TranslationOptions) => {
               type: 'DeclareExportDeclaration',
               declaration: Transform.ClassDeclarationWithName(
                 // possibly missing id
-                (node.declaration: $FlowFixMe),
+                node.declaration as $FlowFixMe,
               ),
               default: false,
               source: null,
@@ -423,7 +423,7 @@ const getTransforms = (originalCode: string, opts: TranslationOptions) => {
               type: 'DeclareExportDeclaration',
               declaration: Transform.FunctionDeclarationWithName(
                 // possibly missing id
-                (node.declaration: $FlowFixMe),
+                node.declaration as $FlowFixMe,
               ),
               default: false,
               source: null,
@@ -660,7 +660,7 @@ const getTransforms = (originalCode: string, opts: TranslationOptions) => {
           type: 'Literal',
           literalType: 'regexp',
           value: node.value,
-          regex: (null: $FlowFixMe),
+          regex: null as $FlowFixMe,
           raw: node.raw,
         });
       } else if (node.value == null) {
@@ -715,7 +715,7 @@ const getTransforms = (originalCode: string, opts: TranslationOptions) => {
         case 'regexp':
           return unsupportedAnnotation(node, 'regexp literal type');
         default:
-          (literal: empty);
+          literal as empty;
           throw 'unreachable';
       }
     }
@@ -725,7 +725,7 @@ const getTransforms = (originalCode: string, opts: TranslationOptions) => {
     ):
       | FlowESTree.Statement
       | FlowESTree.ModuleDeclaration
-      | $ReadOnlyArray<FlowESTree.Statement | FlowESTree.ModuleDeclaration> {
+      | ReadonlyArray<FlowESTree.Statement | FlowESTree.ModuleDeclaration> {
       switch (node.type) {
         case 'BlockStatement':
           return Transform.BlockStatement(node);
@@ -789,8 +789,8 @@ const getTransforms = (originalCode: string, opts: TranslationOptions) => {
 
     static Statement(
       node: TSESTree.Statement,
-    ): FlowESTree.Statement | $ReadOnlyArray<FlowESTree.Statement> {
-      return (Transform.AllStatement(node): $FlowFixMe);
+    ): FlowESTree.Statement | ReadonlyArray<FlowESTree.Statement> {
+      return Transform.AllStatement(node) as $FlowFixMe;
     }
 
     static TSAnyType(): FlowESTree.AnyTypeAnnotation {
@@ -935,7 +935,7 @@ const getTransforms = (originalCode: string, opts: TranslationOptions) => {
     }
 
     static _partitionAndTranslateTSFunctionParams(
-      tsParams: $ReadOnlyArray<TSESTree.Parameter>,
+      tsParams: ReadonlyArray<TSESTree.Parameter>,
     ): {
       thisParam: FlowESTree.FunctionTypeParam | null,
       restParam: FlowESTree.FunctionTypeParam | null,
@@ -1027,6 +1027,19 @@ const getTransforms = (originalCode: string, opts: TranslationOptions) => {
     static TSImportType(
       node: TSESTree.TSImportType,
     ): FlowESTree.TypeAnnotationType {
+      const source =
+        node.argument ??
+        (node.source == null
+          ? null
+          : ({
+              type: 'TSLiteralType',
+              loc: node.source.loc,
+              literal: node.source,
+            } as TSESTree.TSLiteralType));
+      if (source == null) {
+        return unsupportedAnnotation(node, 'import types without a source');
+      }
+
       let base: FlowESTree.TypeAnnotationType =
         constructFlowNode<FlowESTree.GenericTypeAnnotation>({
           type: 'GenericTypeAnnotation',
@@ -1039,15 +1052,15 @@ const getTransforms = (originalCode: string, opts: TranslationOptions) => {
           typeParameters:
             constructFlowNode<FlowESTree.TypeParameterInstantiation>({
               type: 'TypeParameterInstantiation',
-              params: [Transform.TSTypeAnnotation(node.argument)],
+              params: [Transform.TSTypeAnnotation(source)],
             }),
         });
+      if (node.typeArguments != null) {
+        return unsupportedAnnotation(node, 'import types with type arguments');
+      }
       if (node.qualifier == null) {
         return base;
       }
-      if (node.typeParameters != null) {
-        return unsupportedAnnotation(node, 'import types with type parameters');
-      }
       let qualifier = Transform.EntityNameToTypeIdentifier(node.qualifier);
       const namesRev: Array<string> = [];
       while (qualifier.type !== 'Identifier') {
@@ -1243,8 +1256,8 @@ const getTransforms = (originalCode: string, opts: TranslationOptions) => {
       node: TSESTree.TSMappedType,
     ): FlowESTree.ObjectTypeAnnotation {
       const keyTparam = Transform.TSTypeParameter(node.typeParameter);
-      const sourceType: FlowESTree.TypeAnnotationType = (keyTparam.bound
-        ?.typeAnnotation: $FlowFixMe);
+      const sourceType: FlowESTree.TypeAnnotationType = keyTparam.bound
+        ?.typeAnnotation as $FlowFixMe;
       // $FlowFixMe[cannot-write]
       keyTparam.bound = null;
       const prop = constructFlowNode<FlowESTree.ObjectTypeMappedTypeProperty>({
@@ -1303,7 +1316,7 @@ const getTransforms = (originalCode: string, opts: TranslationOptions) => {
       if (node.id.type === 'Literal') {
         return constructFlowNode<FlowESTree.DeclareModule>({
           type: 'DeclareModule',
-          id: (Transform.Literal(node.id): $FlowFixMe),
+          id: Transform.Literal(node.id) as $FlowFixMe,
           body,
         });
       }
@@ -1712,7 +1725,7 @@ const getTransforms = (originalCode: string, opts: TranslationOptions) => {
                   ? (constructFlowNode<FlowESTree.PrivateIdentifier>({
                       type: 'PrivateIdentifier',
                       name: key.name,
-                    }): $FlowFixMe)
+                    }) as $FlowFixMe)
                   : constructFlowNode<FlowESTree.StringLiteral>({
                       type: 'Literal',
                       literalType: 'string',
@@ -1767,7 +1780,7 @@ const getTransforms = (originalCode: string, opts: TranslationOptions) => {
             ? (constructFlowNode<FlowESTree.PrivateIdentifier>({
                 type: 'PrivateIdentifier',
                 name: originalKey.name,
-              }): $FlowFixMe)
+              }) as $FlowFixMe)
             : constructFlowNode<FlowESTree.StringLiteral>({
                 type: 'Literal',
                 literalType: 'string',
@@ -1960,12 +1973,22 @@ const getTransforms = (originalCode: string, opts: TranslationOptions) => {
 
     static TSTypeQuery(
       node: TSESTree.TSTypeQuery,
-    ): FlowESTree.TypeofTypeAnnotation {
+    ): FlowESTree.TypeAnnotationType {
+      if (node.exprName.type === 'TSImportType') {
+        if (node.typeArguments != null) {
+          return unsupportedAnnotation(
+            node,
+            'type query imports with type arguments',
+          );
+        }
+        return Transform.TSImportType(node.exprName);
+      }
+
       return constructFlowNode<FlowESTree.TypeofTypeAnnotation>({
         type: 'TypeofTypeAnnotation',
         argument: Transform.EntityNameToTypeofIdentifier(node.exprName),
         typeArguments:
-          Transform.TSTypeParameterInstantiationOpt(node.typeParameters) ??
+          Transform.TSTypeParameterInstantiationOpt(node.typeArguments) ??
           undefined,
       });
     }
@@ -2005,7 +2028,7 @@ const getTransforms = (originalCode: string, opts: TranslationOptions) => {
 
     static VariableDeclaration(
       node: TSESTree.VariableDeclaration,
-    ): $ReadOnlyArray<FlowESTree.DeclareVariable> {
+    ): ReadonlyArray<FlowESTree.DeclareVariable> {
       return node.declarations.map(decl => {
         if (decl.id.type !== 'Identifier') {
           throw translationError(