flow-api-translator 0.20.1 → 0.21.1

package/dist/flowDefToTSDef.js.flow

@@ -30,6 +30,11 @@ import {EOL} from 'os';
 
 type DeclarationOrUnsupported<T> = T | TSESTree.TSTypeAliasDeclaration;
 
+const DUMMY_LOC: FlowESTree.SourceLocation = {
+  start: {line: 1, column: 0},
+  end: {line: 1, column: 0},
+};
+
 function constructFlowNode<T: FlowESTree.BaseNode>(
   node: $Diff<T, FlowESTree.BaseNode>,
 ): T {
@@ -62,6 +67,7 @@ function getReactIdentifier(hasReactImport: boolean) {
 
   return {
     type: 'Identifier',
+    loc: DUMMY_LOC,
     name: `React`,
   };
 }
@@ -77,6 +83,7 @@ export function flowDefToTSDef(
     type: 'Program',
     body: tsBody,
     sourceType: ast.sourceType,
+    loc: ast.loc,
     docblock:
       ast.docblock == null ? null : removeAtFlowFromDocblock(ast.docblock),
   };
@@ -110,16 +117,20 @@ export function flowDefToTSDef(
     tsBody.unshift({
       type: 'ImportDeclaration',
       assertions: [],
+      loc: DUMMY_LOC,
       source: {
         type: 'Literal',
+        loc: DUMMY_LOC,
         value: 'react',
         raw: "'react'",
       },
       specifiers: [
         {
           type: 'ImportNamespaceSpecifier',
+          loc: DUMMY_LOC,
           local: {
             type: 'Identifier',
+            loc: DUMMY_LOC,
             name: 'React',
           },
         },
@@ -150,8 +161,9 @@ const getTransforms = (
     return buildCodeFrame(node, message, code, false);
   }
   function addErrorComment(node: TSESTree.Node, message: string): void {
-    const comment = {
+    const comment: TSESTree.Comment = {
       type: 'Block',
+      loc: DUMMY_LOC,
       value: `*${EOL} * ${message.replace(
         new RegExp(EOL, 'g'),
         `${EOL} * `,
@@ -165,7 +177,6 @@ const getTransforms = (
     // $FlowExpectedError[prop-missing]
     // $FlowExpectedError[cannot-write]
     node.comments ??= [];
-    // $FlowExpectedError[prop-missing]
     // $FlowExpectedError[incompatible-cast]
     (node.comments: Array<TSESTree.Comment>).push(comment);
   }
@@ -176,8 +187,9 @@ const getTransforms = (
     const message = unsupportedFeatureMessage(thing);
     if (opts.recoverFromErrors) {
       const codeFrame = buildCodeFrameForComment(node, message);
-      const newNode = {
+      const newNode: TSESTree.TSAnyKeyword = {
         type: 'TSAnyKeyword',
+        loc: DUMMY_LOC,
       };
       addErrorComment(newNode, codeFrame);
       return newNode;
@@ -195,12 +207,14 @@ const getTransforms = (
     const message = unsupportedFeatureMessage(thing);
     if (opts.recoverFromErrors) {
       const codeFrame = buildCodeFrameForComment(node, message);
-      const newNode = {
+      const newNode: TSESTree.TSTypeAliasDeclaration = {
         type: 'TSTypeAliasDeclaration',
+        loc: DUMMY_LOC,
         declare,
         id: transform.Identifier(id, false),
         typeAnnotation: {
           type: 'TSAnyKeyword',
+          loc: DUMMY_LOC,
         },
         typeParameters:
           typeParameters == null
@@ -366,10 +380,12 @@ const getTransforms = (
           }
           members.push({
             type: 'TSEnumMember',
+            loc: DUMMY_LOC,
             computed: false,
             id: transform.Identifier(member.id, false),
             initializer: ({
               type: 'Literal',
+              loc: DUMMY_LOC,
               raw: `"${member.id.name}"`,
               value: member.id.name,
             }: TSESTree.StringLiteral),
@@ -381,6 +397,7 @@ const getTransforms = (
         case 'EnumStringMember':
           members.push({
             type: 'TSEnumMember',
+            loc: DUMMY_LOC,
             computed: false,
             id: transform.Identifier(member.id, false),
             initializer:
@@ -393,13 +410,14 @@ const getTransforms = (
 
     const bodyRepresentationType =
       body.type === 'EnumNumberBody'
-        ? {type: 'TSNumberKeyword'}
-        : {type: 'TSStringKeyword'};
+        ? {type: 'TSNumberKeyword', loc: DUMMY_LOC}
+        : {type: 'TSStringKeyword', loc: DUMMY_LOC};
 
     const enumName = transform.Identifier(node.id, false);
     return [
       {
         type: 'TSEnumDeclaration',
+        loc: DUMMY_LOC,
         const: false,
         declare: true,
         id: enumName,
@@ -421,18 +439,23 @@ const getTransforms = (
       */
       {
         type: 'TSModuleDeclaration',
+        loc: DUMMY_LOC,
         declare: true,
         id: enumName,
         body: {
           type: 'TSModuleBlock',
+          loc: DUMMY_LOC,
           body: [
             // export function cast(value: number | null | undefined): Foo
             {
               type: 'ExportNamedDeclaration',
+              loc: DUMMY_LOC,
               declaration: {
                 type: 'TSDeclareFunction',
+                loc: DUMMY_LOC,
                 id: {
                   type: 'Identifier',
+                  loc: DUMMY_LOC,
                   name: 'cast',
                 },
                 generator: false,
@@ -441,18 +464,23 @@ const getTransforms = (
                 params: [
                   {
                     type: 'Identifier',
+                    loc: DUMMY_LOC,
                     name: 'value',
                     typeAnnotation: {
                       type: 'TSTypeAnnotation',
+                      loc: DUMMY_LOC,
                       typeAnnotation: {
                         type: 'TSUnionType',
+                        loc: DUMMY_LOC,
                         types: [
                           bodyRepresentationType,
                           {
                             type: 'TSNullKeyword',
+                            loc: DUMMY_LOC,
                           },
                           {
                             type: 'TSUndefinedKeyword',
+                            loc: DUMMY_LOC,
                           },
                         ],
                       },
@@ -461,8 +489,10 @@ const getTransforms = (
                 ],
                 returnType: {
                   type: 'TSTypeAnnotation',
+                  loc: DUMMY_LOC,
                   typeAnnotation: {
                     type: 'TSTypeReference',
+                    loc: DUMMY_LOC,
                     typeName: enumName,
                   },
                 },
@@ -475,10 +505,13 @@ const getTransforms = (
             // export function isValid(value: number | null | undefined): value is Foo;
             {
               type: 'ExportNamedDeclaration',
+              loc: DUMMY_LOC,
               declaration: {
                 type: 'TSDeclareFunction',
+                loc: DUMMY_LOC,
                 id: {
                   type: 'Identifier',
+                  loc: DUMMY_LOC,
                   name: 'isValid',
                 },
                 generator: false,
@@ -487,18 +520,23 @@ const getTransforms = (
                 params: [
                   {
                     type: 'Identifier',
+                    loc: DUMMY_LOC,
                     name: 'value',
                     typeAnnotation: {
                       type: 'TSTypeAnnotation',
+                      loc: DUMMY_LOC,
                       typeAnnotation: {
                         type: 'TSUnionType',
+                        loc: DUMMY_LOC,
                         types: [
                           bodyRepresentationType,
                           {
                             type: 'TSNullKeyword',
+                            loc: DUMMY_LOC,
                           },
                           {
                             type: 'TSUndefinedKeyword',
+                            loc: DUMMY_LOC,
                           },
                         ],
                       },
@@ -507,17 +545,22 @@ const getTransforms = (
                 ],
                 returnType: {
                   type: 'TSTypeAnnotation',
+                  loc: DUMMY_LOC,
                   typeAnnotation: {
                     type: 'TSTypePredicate',
+                    loc: DUMMY_LOC,
                     asserts: false,
                     parameterName: {
                       type: 'Identifier',
+                      loc: DUMMY_LOC,
                       name: 'value',
                     },
                     typeAnnotation: {
                       type: 'TSTypeAnnotation',
+                      loc: DUMMY_LOC,
                       typeAnnotation: {
                         type: 'TSTypeReference',
+                        loc: DUMMY_LOC,
                         typeName: enumName,
                       },
                     },
@@ -532,10 +575,13 @@ const getTransforms = (
             // export function members(): IterableIterator<Foo>;
             {
               type: 'ExportNamedDeclaration',
+              loc: DUMMY_LOC,
               declaration: {
                 type: 'TSDeclareFunction',
+                loc: DUMMY_LOC,
                 id: {
                   type: 'Identifier',
+                  loc: DUMMY_LOC,
                   name: 'members',
                 },
                 generator: false,
@@ -544,17 +590,22 @@ const getTransforms = (
                 params: [],
                 returnType: {
                   type: 'TSTypeAnnotation',
+                  loc: DUMMY_LOC,
                   typeAnnotation: {
                     type: 'TSTypeReference',
+                    loc: DUMMY_LOC,
                     typeName: {
                       type: 'Identifier',
+                      loc: DUMMY_LOC,
                       name: 'IterableIterator',
                     },
                     typeParameters: {
                       type: 'TSTypeParameterInstantiation',
+                      loc: DUMMY_LOC,
                       params: [
                         {
                           type: 'TSTypeReference',
+                          loc: DUMMY_LOC,
                           typeName: enumName,
                         },
                       ],
@@ -570,10 +621,13 @@ const getTransforms = (
             // export function getName(value: Foo): string;
             {
               type: 'ExportNamedDeclaration',
+              loc: DUMMY_LOC,
               declaration: {
                 type: 'TSDeclareFunction',
+                loc: DUMMY_LOC,
                 id: {
                   type: 'Identifier',
+                  loc: DUMMY_LOC,
                   name: 'getName',
                 },
                 generator: false,
@@ -582,11 +636,14 @@ const getTransforms = (
                 params: [
                   {
                     type: 'Identifier',
+                    loc: DUMMY_LOC,
                     name: 'value',
                     typeAnnotation: {
                       type: 'TSTypeAnnotation',
+                      loc: DUMMY_LOC,
                       typeAnnotation: {
                         type: 'TSTypeReference',
+                        loc: DUMMY_LOC,
                         typeName: enumName,
                       },
                     },
@@ -594,8 +651,10 @@ const getTransforms = (
                 ],
                 returnType: {
                   type: 'TSTypeAnnotation',
+                  loc: DUMMY_LOC,
                   typeAnnotation: {
                     type: 'TSStringKeyword',
+                    loc: DUMMY_LOC,
                   },
                 },
               },
@@ -700,6 +759,7 @@ const getTransforms = (
     ): TSESTree.TSAnyKeyword {
       return {
         type: 'TSAnyKeyword',
+        loc: DUMMY_LOC,
       };
     },
     ArrayTypeAnnotation(
@@ -707,12 +767,14 @@ const getTransforms = (
     ): TSESTree.TSArrayType {
       return {
         type: 'TSArrayType',
+        loc: DUMMY_LOC,
         elementType: transformTypeAnnotationType(node.elementType),
       };
     },
     BigIntLiteral(node: FlowESTree.BigIntLiteral): TSESTree.BigIntLiteral {
       return {
         type: 'Literal',
+        loc: DUMMY_LOC,
         bigint: node.bigint,
         raw: node.raw,
         value: node.value,
@@ -734,8 +796,10 @@ const getTransforms = (
           .replace(/_/, '');
       return {
         type: 'TSLiteralType',
+        loc: DUMMY_LOC,
         literal: ({
           type: 'Literal',
+          loc: DUMMY_LOC,
           value: node.value,
           raw: node.raw,
           bigint,
@@ -747,11 +811,13 @@ const getTransforms = (
     ): TSESTree.TSBigIntKeyword {
       return {
         type: 'TSBigIntKeyword',
+        loc: DUMMY_LOC,
       };
     },
     BooleanLiteral(node: FlowESTree.BooleanLiteral): TSESTree.BooleanLiteral {
       return {
         type: 'Literal',
+        loc: DUMMY_LOC,
         raw: node.raw,
         value: node.value,
       };
@@ -761,8 +827,10 @@ const getTransforms = (
     ): TSESTree.TSLiteralType {
       return {
         type: 'TSLiteralType',
+        loc: DUMMY_LOC,
         literal: ({
           type: 'Literal',
+          loc: DUMMY_LOC,
           value: node.value,
           raw: node.raw,
         }: TSESTree.BooleanLiteral),
@@ -773,6 +841,7 @@ const getTransforms = (
     ): TSESTree.TSBooleanKeyword {
       return {
         type: 'TSBooleanKeyword',
+        loc: DUMMY_LOC,
       };
     },
     ClassImplements(
@@ -780,6 +849,7 @@ const getTransforms = (
     ): TSESTree.TSClassImplements {
       return {
         type: 'TSClassImplements',
+        loc: DUMMY_LOC,
         expression: transform.Identifier(node.id, false),
         typeParameters:
           node.typeParameters == null
@@ -828,10 +898,12 @@ const getTransforms = (
             if (isConstructor) {
               const newNode: TSESTree.MethodDefinitionAmbiguous = {
                 type: 'MethodDefinition',
+                loc: DUMMY_LOC,
                 accessibility: undefined,
                 computed: false,
                 key: {
                   type: 'Identifier',
+                  loc: DUMMY_LOC,
                   name: 'constructor',
                 },
                 kind: 'constructor',
@@ -840,6 +912,7 @@ const getTransforms = (
                 static: false,
                 value: {
                   type: 'TSEmptyBodyFunctionExpression',
+                  loc: DUMMY_LOC,
                   async: false,
                   body: null,
                   declare: false,
@@ -857,6 +930,7 @@ const getTransforms = (
             } else {
               const newNode: TSESTree.MethodDefinitionAmbiguous = {
                 type: 'MethodDefinition',
+                loc: DUMMY_LOC,
                 accessibility: member.accessibility,
                 computed: member.computed ?? false,
                 key: member.key,
@@ -866,6 +940,7 @@ const getTransforms = (
                 static: member.static ?? false,
                 value: {
                   type: 'TSEmptyBodyFunctionExpression',
+                  loc: DUMMY_LOC,
                   async: false,
                   body: null,
                   declare: false,
@@ -886,6 +961,7 @@ const getTransforms = (
           case 'TSPropertySignature': {
             const newNode: TSESTree.PropertyDefinitionAmbiguous = {
               type: 'PropertyDefinition',
+              loc: DUMMY_LOC,
               accessibility: member.accessibility,
               computed: member.computed ?? false,
               declare: false,
@@ -939,8 +1015,10 @@ const getTransforms = (
 
       return {
         type: 'ClassDeclaration',
+        loc: DUMMY_LOC,
         body: {
           type: 'ClassBody',
+          loc: DUMMY_LOC,
           body: classMembers,
         },
         declare: true,
@@ -952,7 +1030,8 @@ const getTransforms = (
         superClass:
           superClass == null
             ? null
-            : transform.Identifier(superClass.id, false),
+            : // Bug: superclass.id can be qualified
+              transform.Identifier((superClass.id: $FlowFixMe), false),
         superTypeParameters:
           superClass?.typeParameters == null
             ? undefined
@@ -991,8 +1070,10 @@ const getTransforms = (
               classDecl,
               {
                 type: 'ExportDefaultDeclaration',
+                loc: DUMMY_LOC,
                 declaration: {
                   type: 'Identifier',
+                  loc: DUMMY_LOC,
                   name,
                 },
                 exportKind: 'value',
@@ -1008,8 +1089,10 @@ const getTransforms = (
               functionDecl,
               {
                 type: 'ExportDefaultDeclaration',
+                loc: DUMMY_LOC,
                 declaration: {
                   type: 'Identifier',
+                  loc: DUMMY_LOC,
                   name,
                 },
                 exportKind: 'value',
@@ -1025,8 +1108,10 @@ const getTransforms = (
               functionDecl,
               {
                 type: 'ExportDefaultDeclaration',
+                loc: DUMMY_LOC,
                 declaration: {
                   type: 'Identifier',
+                  loc: DUMMY_LOC,
                   name,
                 },
                 exportKind: 'value',
@@ -1042,8 +1127,10 @@ const getTransforms = (
               functionDecl,
               {
                 type: 'ExportDefaultDeclaration',
+                loc: DUMMY_LOC,
                 declaration: {
                   type: 'Identifier',
+                  loc: DUMMY_LOC,
                   name,
                 },
                 exportKind: 'value',
@@ -1090,8 +1177,10 @@ const getTransforms = (
                     // there's already a variable defined to hold the type
                     return {
                       type: 'ExportDefaultDeclaration',
+                      loc: DUMMY_LOC,
                       declaration: {
                         type: 'Identifier',
+                        loc: DUMMY_LOC,
                         name: referencedId.name,
                       },
                       exportKind: 'value',
@@ -1132,14 +1221,18 @@ const getTransforms = (
             return [
               {
                 type: 'VariableDeclaration',
+                loc: DUMMY_LOC,
                 declarations: [
                   {
                     type: 'VariableDeclarator',
+                    loc: DUMMY_LOC,
                     id: {
                       type: 'Identifier',
+                      loc: DUMMY_LOC,
                       name: SPECIFIER,
                       typeAnnotation: {
                         type: 'TSTypeAnnotation',
+                        loc: DUMMY_LOC,
                         typeAnnotation:
                           transformTypeAnnotationType(declaration),
                       },
@@ -1152,8 +1245,10 @@ const getTransforms = (
               },
               {
                 type: 'ExportDefaultDeclaration',
+                loc: DUMMY_LOC,
                 declaration: {
                   type: 'Identifier',
+                  loc: DUMMY_LOC,
                   name: SPECIFIER,
                 },
                 exportKind: 'value',
@@ -1168,6 +1263,7 @@ const getTransforms = (
           if (node.declaration === null) {
             return ({
               type: 'ExportNamedDeclaration',
+              loc: DUMMY_LOC,
               // flow does not currently support assertions
               assertions: [],
               declaration: null,
@@ -1251,6 +1347,7 @@ const getTransforms = (
             ({declaration, exportKind}) =>
               ({
                 type: 'ExportNamedDeclaration',
+                loc: DUMMY_LOC,
                 // flow does not currently support assertions
                 assertions: [],
                 declaration,
@@ -1262,6 +1359,7 @@ const getTransforms = (
         } else {
           return ({
             type: 'ExportNamedDeclaration',
+            loc: DUMMY_LOC,
             // flow does not currently support assertions
             assertions: [],
             declaration: null,
@@ -1287,16 +1385,20 @@ const getTransforms = (
 
       // TS cannot support `renderType` so we always use ReactNode as the return type.
       const hasReactImport = isReactImport(node, 'React');
-      const returnType = {
+      const returnType: TSESTree.TSTypeAnnotation = {
         type: 'TSTypeAnnotation',
+        loc: DUMMY_LOC,
         // If no rendersType we assume its ReactNode type.
         typeAnnotation: {
           type: 'TSTypeReference',
+          loc: DUMMY_LOC,
           typeName: {
             type: 'TSQualifiedName',
+            loc: DUMMY_LOC,
             left: getReactIdentifier(hasReactImport),
             right: {
               type: 'Identifier',
+              loc: DUMMY_LOC,
               name: `ReactNode`,
             },
           },
@@ -1306,6 +1408,7 @@ const getTransforms = (
 
       return {
         type: 'TSDeclareFunction',
+        loc: DUMMY_LOC,
         async: false,
         body: undefined,
         declare: true,
@@ -1313,6 +1416,7 @@ const getTransforms = (
         generator: false,
         id: {
           type: 'Identifier',
+          loc: DUMMY_LOC,
           name: id.name,
         },
         params,
@@ -1328,9 +1432,11 @@ const getTransforms = (
         return [
           {
             type: 'Identifier',
+            loc: DUMMY_LOC,
             name: 'props',
             typeAnnotation: {
               type: 'TSTypeAnnotation',
+              loc: DUMMY_LOC,
               typeAnnotation: transformTypeAnnotationType(rest.typeAnnotation),
             },
             optional: false,
@@ -1392,9 +1498,11 @@ const getTransforms = (
       return [
         {
           type: 'Identifier',
+          loc: DUMMY_LOC,
           name: 'props',
           typeAnnotation: {
             type: 'TSTypeAnnotation',
+            loc: DUMMY_LOC,
             typeAnnotation: tsPropsObjectType,
           },
           optional: false,
@@ -1410,6 +1518,7 @@ const getTransforms = (
 
       return {
         type: 'TSDeclareFunction',
+        loc: DUMMY_LOC,
         async: false,
         body: undefined,
         declare: true,
@@ -1417,6 +1526,7 @@ const getTransforms = (
         generator: false,
         id: {
           type: 'Identifier',
+          loc: DUMMY_LOC,
           name: id.name,
         },
         params: functionInfo.params,
@@ -1435,6 +1545,7 @@ const getTransforms = (
 
       return {
         type: 'TSDeclareFunction',
+        loc: DUMMY_LOC,
         async: false,
         body: undefined,
         declare: true,
@@ -1442,6 +1553,7 @@ const getTransforms = (
         generator: false,
         id: {
           type: 'Identifier',
+          loc: DUMMY_LOC,
           name: id.name,
         },
         params: functionInfo.params,
@@ -1462,8 +1574,10 @@ const getTransforms = (
 
       return {
         type: 'TSInterfaceDeclaration',
+        loc: DUMMY_LOC,
         body: {
           type: 'TSInterfaceBody',
+          loc: DUMMY_LOC,
           body: transformedBody.members,
         },
         declare: node.type !== 'InterfaceDeclaration',
@@ -1480,6 +1594,7 @@ const getTransforms = (
     ): TSESTree.TSTypeAliasDeclaration {
       return {
         type: 'TSTypeAliasDeclaration',
+        loc: DUMMY_LOC,
         declare: node.type === 'DeclareTypeAlias',
         id: transform.Identifier(node.id, false),
         typeAnnotation: transformTypeAnnotationType(node.right),
@@ -1498,12 +1613,14 @@ const getTransforms = (
 
       return {
         type: 'TSTypeAliasDeclaration',
+        loc: DUMMY_LOC,
         declare: true,
         id: transform.Identifier(node.id, false),
         typeAnnotation:
           node.supertype == null
             ? {
                 type: 'TSUnknownKeyword',
+                loc: DUMMY_LOC,
               }
             : transformTypeAnnotationType(node.supertype),
         typeParameters:
@@ -1517,10 +1634,12 @@ const getTransforms = (
     ): TSESTree.VariableDeclaration {
       return {
         type: 'VariableDeclaration',
+        loc: DUMMY_LOC,
         declare: true,
         declarations: [
           {
             type: 'VariableDeclarator',
+            loc: DUMMY_LOC,
             declare: true,
             id: transform.Identifier(node.id, true),
             init: null,
@@ -1569,6 +1688,7 @@ const getTransforms = (
     ): TSESTree.ExportAllDeclaration {
       return {
         type: 'ExportAllDeclaration',
+        loc: DUMMY_LOC,
         // flow does not currently support import/export assertions
         assertions: [],
         exportKind: node.exportKind,
@@ -1586,6 +1706,7 @@ const getTransforms = (
         // can never have a declaration with a source
         return {
           type: 'ExportNamedDeclaration',
+          loc: DUMMY_LOC,
           // flow does not currently support import/export assertions
           assertions: [],
           declaration: null,
@@ -1629,6 +1750,7 @@ const getTransforms = (
 
       const mainExport = {
         type: 'ExportNamedDeclaration',
+        loc: DUMMY_LOC,
         assertions: [],
         declaration: exportedDeclaration,
         exportKind: node.exportKind,
@@ -1642,6 +1764,7 @@ const getTransforms = (
           mainExport,
           {
             type: 'ExportNamedDeclaration',
+            loc: DUMMY_LOC,
             assertions: [],
             declaration: mergedDeclaration,
             exportKind: node.exportKind,
@@ -1658,6 +1781,7 @@ const getTransforms = (
     ): TSESTree.ExportSpecifier {
       return {
         type: 'ExportSpecifier',
+        loc: DUMMY_LOC,
         exported: transform.Identifier(node.exported, false),
         local: transform.Identifier(node.local, false),
         // flow does not support inline exportKind for named exports
@@ -1671,9 +1795,11 @@ const getTransforms = (
       if (node.type === 'FunctionTypeAnnotation' && node.this != null) {
         params.unshift({
           type: 'Identifier',
+          loc: DUMMY_LOC,
           name: 'this',
           typeAnnotation: {
             type: 'TSTypeAnnotation',
+            loc: DUMMY_LOC,
             typeAnnotation: transformTypeAnnotationType(
               node.this.typeAnnotation,
             ),
@@ -1684,15 +1810,18 @@ const getTransforms = (
         const rest = node.rest;
         params.push({
           type: 'RestElement',
+          loc: DUMMY_LOC,
           argument:
             rest.name == null
               ? {
                   type: 'Identifier',
+                  loc: DUMMY_LOC,
                   name: '$$REST$$',
                 }
               : transform.Identifier(rest.name, false),
           typeAnnotation: {
             type: 'TSTypeAnnotation',
+            loc: DUMMY_LOC,
             typeAnnotation: transformTypeAnnotationType(rest.typeAnnotation),
           },
         });
@@ -1700,9 +1829,11 @@ const getTransforms = (
 
       return {
         type: 'TSFunctionType',
+        loc: DUMMY_LOC,
         params,
         returnType: {
           type: 'TSTypeAnnotation',
+          loc: DUMMY_LOC,
           typeAnnotation: transformTypeAnnotationType(node.returnType),
         },
         typeParameters:
@@ -1717,9 +1848,11 @@ const getTransforms = (
     ): TSESTree.Parameter {
       return {
         type: 'Identifier',
+        loc: DUMMY_LOC,
         name: node.name == null ? `$$PARAM_${idx}$$` : node.name.name,
         typeAnnotation: {
           type: 'TSTypeAnnotation',
+          loc: DUMMY_LOC,
           typeAnnotation: transformTypeAnnotationType(node.typeAnnotation),
         },
         optional: node.optional,
@@ -1819,30 +1952,38 @@ const getTransforms = (
           const params = assertHasExactlyNTypeParameters(2);
           return {
             type: 'TSTypeReference',
+            loc: DUMMY_LOC,
             typeName: {
               type: 'Identifier',
+              loc: DUMMY_LOC,
               name: 'Pick',
             },
             typeParameters: {
               type: 'TSTypeParameterInstantiation',
+              loc: DUMMY_LOC,
               params: [
                 params[0],
                 {
                   type: 'TSTypeReference',
+                  loc: DUMMY_LOC,
                   typeName: {
                     type: 'Identifier',
+                    loc: DUMMY_LOC,
                     name: 'Exclude',
                   },
                   typeParameters: {
                     type: 'TSTypeParameterInstantiation',
+                    loc: DUMMY_LOC,
                     params: [
                       {
                         type: 'TSTypeOperator',
+                        loc: DUMMY_LOC,
                         operator: 'keyof',
                         typeAnnotation: params[0],
                       },
                       {
                         type: 'TSTypeOperator',
+                        loc: DUMMY_LOC,
                         operator: 'keyof',
                         typeAnnotation: params[1],
                       },
@@ -1860,6 +2001,7 @@ const getTransforms = (
           const params = assertHasExactlyNTypeParameters(2);
           return {
             type: 'TSIndexedAccessType',
+            loc: DUMMY_LOC,
             objectType: params[0],
             indexType: params[1],
           };
@@ -1887,6 +2029,7 @@ const getTransforms = (
 
           return {
             type: 'TSImportType',
+            loc: DUMMY_LOC,
             isTypeOf: true,
             argument: moduleName,
             qualifier: null,
@@ -1898,6 +2041,7 @@ const getTransforms = (
           // `$FlowFixMe` => `any`
           return {
             type: 'TSAnyKeyword',
+            loc: DUMMY_LOC,
           };
         }
 
@@ -1905,14 +2049,18 @@ const getTransforms = (
           // `$KeyMirror<T>` => `{[K in keyof T]: K}`
           return {
             type: 'TSMappedType',
+            loc: DUMMY_LOC,
             typeParameter: {
               type: 'TSTypeParameter',
+              loc: DUMMY_LOC,
               name: {
                 type: 'Identifier',
+                loc: DUMMY_LOC,
                 name: 'K',
               },
               constraint: {
                 type: 'TSTypeOperator',
+                loc: DUMMY_LOC,
                 operator: 'keyof',
                 typeAnnotation: assertHasExactlyNTypeParameters(1)[0],
               },
@@ -1922,8 +2070,10 @@ const getTransforms = (
             nameType: null,
             typeAnnotation: {
               type: 'TSTypeReference',
+              loc: DUMMY_LOC,
               typeName: {
                 type: 'Identifier',
+                loc: DUMMY_LOC,
                 name: 'K',
               },
             },
@@ -1934,6 +2084,7 @@ const getTransforms = (
           // `$Keys<T>` => `keyof T`
           return {
             type: 'TSTypeOperator',
+            loc: DUMMY_LOC,
             operator: 'keyof',
             typeAnnotation: assertHasExactlyNTypeParameters(1)[0],
           };
@@ -1944,12 +2095,15 @@ const getTransforms = (
           // Not a great name because `NonNullable` also excludes `undefined`
           return {
             type: 'TSTypeReference',
+            loc: DUMMY_LOC,
             typeName: {
               type: 'Identifier',
+              loc: DUMMY_LOC,
               name: 'NonNullable',
             },
             typeParameters: {
               type: 'TSTypeParameterInstantiation',
+              loc: DUMMY_LOC,
               params: assertHasExactlyNTypeParameters(1),
             },
           };
@@ -1959,12 +2113,15 @@ const getTransforms = (
           // `$ReadOnly<T>` => `Readonly<T>`
           return {
             type: 'TSTypeReference',
+            loc: DUMMY_LOC,
             typeName: {
               type: 'Identifier',
+              loc: DUMMY_LOC,
               name: 'Readonly',
             },
             typeParameters: {
               type: 'TSTypeParameterInstantiation',
+              loc: DUMMY_LOC,
               params: assertHasExactlyNTypeParameters(1),
             },
           };
@@ -1977,12 +2134,15 @@ const getTransforms = (
           // TODO - maybe a config option?
           return {
             type: 'TSTypeReference',
+            loc: DUMMY_LOC,
             typeName: {
               type: 'Identifier',
+              loc: DUMMY_LOC,
               name: 'ReadonlyArray',
             },
             typeParameters: {
               type: 'TSTypeParameterInstantiation',
+              loc: DUMMY_LOC,
               params: assertHasExactlyNTypeParameters(1),
             },
           };
@@ -1991,12 +2151,15 @@ const getTransforms = (
         case '$ReadOnlyMap': {
           return {
             type: 'TSTypeReference',
+            loc: DUMMY_LOC,
             typeName: {
               type: 'Identifier',
+              loc: DUMMY_LOC,
               name: 'ReadonlyMap',
             },
             typeParameters: {
               type: 'TSTypeParameterInstantiation',
+              loc: DUMMY_LOC,
               params: assertHasExactlyNTypeParameters(2),
             },
           };
@@ -2005,12 +2168,15 @@ const getTransforms = (
         case '$ReadOnlySet': {
           return {
             type: 'TSTypeReference',
+            loc: DUMMY_LOC,
             typeName: {
               type: 'Identifier',
+              loc: DUMMY_LOC,
               name: 'ReadonlySet',
             },
             typeParameters: {
               type: 'TSTypeParameterInstantiation',
+              loc: DUMMY_LOC,
               params: assertHasExactlyNTypeParameters(1),
             },
           };
@@ -2021,9 +2187,11 @@ const getTransforms = (
           const transformedType = assertHasExactlyNTypeParameters(1)[0];
           return {
             type: 'TSIndexedAccessType',
+            loc: DUMMY_LOC,
             objectType: transformedType,
             indexType: {
               type: 'TSTypeOperator',
+              loc: DUMMY_LOC,
               operator: 'keyof',
               typeAnnotation: transformedType,
             },
@@ -2042,20 +2210,26 @@ const getTransforms = (
 
           return {
             type: 'TSConstructorType',
+            loc: DUMMY_LOC,
             abstract: false,
             params: [
               {
                 type: 'RestElement',
+                loc: DUMMY_LOC,
                 argument: {
                   type: 'Identifier',
+                  loc: DUMMY_LOC,
                   name: 'args',
                 },
                 typeAnnotation: {
                   type: 'TSTypeAnnotation',
+                  loc: DUMMY_LOC,
                   typeAnnotation: {
                     type: 'TSArrayType',
+                    loc: DUMMY_LOC,
                     elementType: {
                       type: 'TSAnyKeyword',
+                      loc: DUMMY_LOC,
                     },
                   },
                 },
@@ -2063,6 +2237,7 @@ const getTransforms = (
             ],
             returnType: {
               type: 'TSTypeAnnotation',
+              loc: DUMMY_LOC,
               typeAnnotation: param,
             },
           };
@@ -2085,16 +2260,20 @@ const getTransforms = (
             const [param] = assertHasExactlyNTypeParameters(1);
             return {
               type: 'TSUnionType',
+              loc: DUMMY_LOC,
               types: [
                 param,
                 {
                   type: 'TSTypeReference',
+                  loc: DUMMY_LOC,
                   typeName: {
                     type: 'Identifier',
+                    loc: DUMMY_LOC,
                     name: 'ReadonlyArray',
                   },
                   typeParameters: {
                     type: 'TSTypeParameterInstantiation',
+                    loc: DUMMY_LOC,
                     params: [param],
                   },
                 },
@@ -2122,16 +2301,20 @@ const getTransforms = (
 
             return {
               type: 'TSTypeReference',
+              loc: DUMMY_LOC,
               typeName: {
                 type: 'TSQualifiedName',
+                loc: DUMMY_LOC,
                 left: getReactIdentifier(hasReactImport),
                 right: {
                   type: 'Identifier',
+                  loc: DUMMY_LOC,
                   name: 'Component',
                 },
               },
               typeParameters: {
                 type: 'TSTypeParameterInstantiation',
+                loc: DUMMY_LOC,
                 params: params.map(param => transformTypeAnnotationType(param)),
               },
             };
@@ -2143,16 +2326,20 @@ const getTransforms = (
           case 'React.Context':
             return {
               type: 'TSTypeReference',
+              loc: DUMMY_LOC,
               typeName: {
                 type: 'TSQualifiedName',
+                loc: DUMMY_LOC,
                 left: getReactIdentifier(hasReactImport),
                 right: {
                   type: 'Identifier',
+                  loc: DUMMY_LOC,
                   name: `Context`,
                 },
               },
               typeParameters: {
                 type: 'TSTypeParameterInstantiation',
+                loc: DUMMY_LOC,
                 params: assertHasExactlyNTypeParameters(1),
               },
             };
@@ -2163,11 +2350,14 @@ const getTransforms = (
             assertHasExactlyNTypeParameters(0);
             return {
               type: 'TSTypeReference',
+              loc: DUMMY_LOC,
               typeName: {
                 type: 'TSQualifiedName',
+                loc: DUMMY_LOC,
                 left: getReactIdentifier(hasReactImport),
                 right: {
                   type: 'Identifier',
+                  loc: DUMMY_LOC,
                   name: 'Key',
                 },
               },
@@ -2179,11 +2369,14 @@ const getTransforms = (
             assertHasExactlyNTypeParameters(0);
             return {
               type: 'TSTypeReference',
+              loc: DUMMY_LOC,
               typeName: {
                 type: 'TSQualifiedName',
+                loc: DUMMY_LOC,
                 left: getReactIdentifier(hasReactImport),
                 right: {
                   type: 'Identifier',
+                  loc: DUMMY_LOC,
                   name: `ElementType`,
                 },
               },
@@ -2196,11 +2389,14 @@ const getTransforms = (
             assertHasExactlyNTypeParameters(0);
             return {
               type: 'TSTypeReference',
+              loc: DUMMY_LOC,
               typeName: {
                 type: 'TSQualifiedName',
+                loc: DUMMY_LOC,
                 left: getReactIdentifier(hasReactImport),
                 right: {
                   type: 'Identifier',
+                  loc: DUMMY_LOC,
                   name: `ReactNode`,
                 },
               },
@@ -2212,16 +2408,20 @@ const getTransforms = (
           case 'React.Element': {
             return {
               type: 'TSTypeReference',
+              loc: DUMMY_LOC,
               typeName: {
                 type: 'TSQualifiedName',
+                loc: DUMMY_LOC,
                 left: getReactIdentifier(hasReactImport),
                 right: {
                   type: 'Identifier',
+                  loc: DUMMY_LOC,
                   name: `ReactElement`,
                 },
               },
               typeParameters: {
                 type: 'TSTypeParameterInstantiation',
+                loc: DUMMY_LOC,
                 params: assertHasExactlyNTypeParameters(1),
               },
             };
@@ -2232,16 +2432,20 @@ const getTransforms = (
           case 'React.ElementRef':
             return {
               type: 'TSTypeReference',
+              loc: DUMMY_LOC,
               typeName: {
                 type: 'TSQualifiedName',
+                loc: DUMMY_LOC,
                 left: getReactIdentifier(hasReactImport),
                 right: {
                   type: 'Identifier',
+                  loc: DUMMY_LOC,
                   name: `ElementRef`,
                 },
               },
               typeParameters: {
                 type: 'TSTypeParameterInstantiation',
+                loc: DUMMY_LOC,
                 params: assertHasExactlyNTypeParameters(1),
               },
             };
@@ -2252,11 +2456,14 @@ const getTransforms = (
             assertHasExactlyNTypeParameters(0);
             return {
               type: 'TSTypeReference',
+              loc: DUMMY_LOC,
               typeName: {
                 type: 'TSQualifiedName',
+                loc: DUMMY_LOC,
                 left: getReactIdentifier(hasReactImport),
                 right: {
                   type: 'Identifier',
+                  loc: DUMMY_LOC,
                   name: `Fragment`,
                 },
               },
@@ -2267,14 +2474,18 @@ const getTransforms = (
             assertHasExactlyNTypeParameters(0);
             return {
               type: 'TSTypeReference',
+              loc: DUMMY_LOC,
               typeName: {
                 type: 'TSQualifiedName',
+                loc: DUMMY_LOC,
                 left: {
                   type: 'Identifier',
+                  loc: DUMMY_LOC,
                   name: 'JSX',
                 },
                 right: {
                   type: 'Identifier',
+                  loc: DUMMY_LOC,
                   name: 'Element',
                 },
               },
@@ -2287,16 +2498,20 @@ const getTransforms = (
           case 'React$ComponentType': {
             return {
               type: 'TSTypeReference',
+              loc: DUMMY_LOC,
               typeName: {
                 type: 'TSQualifiedName',
+                loc: DUMMY_LOC,
                 left: getReactIdentifier(hasReactImport),
                 right: {
                   type: 'Identifier',
+                  loc: DUMMY_LOC,
                   name: 'ComponentType',
                 },
               },
               typeParameters: {
                 type: 'TSTypeParameterInstantiation',
+                loc: DUMMY_LOC,
                 params: assertHasExactlyNTypeParameters(1),
               },
             };
@@ -2315,10 +2530,10 @@ const getTransforms = (
               );
             }
             const params = typeParameters.params;
-            if (params.length > 2) {
+            if (params.length > 3) {
               throw translationError(
                 node,
-                `Expected at no more than 2 type parameters with \`${fullTypeName}\``,
+                `Expected at no more than 3 type parameters with \`${fullTypeName}\``,
               );
             }
 
@@ -2327,28 +2542,35 @@ const getTransforms = (
                 return assertHasExactlyNTypeParameters(1);
               }
 
-              const [props, ref] = assertHasExactlyNTypeParameters(2);
+              const props = transformTypeAnnotationType(params[0]);
+              const ref = transformTypeAnnotationType(params[1]);
 
               return [
                 {
                   type: 'TSIntersectionType',
+                  loc: DUMMY_LOC,
                   types: [
                     props,
                     {
                       type: 'TSTypeReference',
+                      loc: DUMMY_LOC,
                       typeName: {
                         type: 'TSQualifiedName',
+                        loc: DUMMY_LOC,
                         left: {
                           type: 'Identifier',
+                          loc: DUMMY_LOC,
                           name: 'React',
                         },
                         right: {
                           type: 'Identifier',
+                          loc: DUMMY_LOC,
                           name: 'RefAttributes',
                         },
                       },
                       typeParameters: {
                         type: 'TSTypeParameterInstantiation',
+                        loc: DUMMY_LOC,
                         params: [ref],
                       },
                     },
@@ -2359,16 +2581,20 @@ const getTransforms = (
 
             return {
               type: 'TSTypeReference',
+              loc: DUMMY_LOC,
               typeName: {
                 type: 'TSQualifiedName',
+                loc: DUMMY_LOC,
                 left: getReactIdentifier(hasReactImport),
                 right: {
                   type: 'Identifier',
+                  loc: DUMMY_LOC,
                   name: 'ComponentType',
                 },
               },
               typeParameters: {
                 type: 'TSTypeParameterInstantiation',
+                loc: DUMMY_LOC,
                 params: newParams,
               },
             };
@@ -2379,16 +2605,20 @@ const getTransforms = (
           case 'React$ElementProps': {
             return {
               type: 'TSTypeReference',
+              loc: DUMMY_LOC,
               typeName: {
                 type: 'TSQualifiedName',
+                loc: DUMMY_LOC,
                 left: getReactIdentifier(hasReactImport),
                 right: {
                   type: 'Identifier',
+                  loc: DUMMY_LOC,
                   name: 'ComponentProps',
                 },
               },
               typeParameters: {
                 type: 'TSTypeParameterInstantiation',
+                loc: DUMMY_LOC,
                 params: assertHasExactlyNTypeParameters(1),
               },
             };
@@ -2400,33 +2630,42 @@ const getTransforms = (
             const [param] = assertHasExactlyNTypeParameters(1);
             return {
               type: 'TSTypeReference',
+              loc: DUMMY_LOC,
               typeName: {
                 type: 'TSQualifiedName',
+                loc: DUMMY_LOC,
                 left: {
                   type: 'Identifier',
+                  loc: DUMMY_LOC,
                   name: 'JSX',
                 },
                 right: {
                   type: 'Identifier',
+                  loc: DUMMY_LOC,
                   name: 'LibraryManagedAttributes',
                 },
               },
               typeParameters: {
                 type: 'TSTypeParameterInstantiation',
+                loc: DUMMY_LOC,
                 params: [
                   param,
                   {
                     type: 'TSTypeReference',
+                    loc: DUMMY_LOC,
                     typeName: {
                       type: 'TSQualifiedName',
+                      loc: DUMMY_LOC,
                       left: getReactIdentifier(hasReactImport),
                       right: {
                         type: 'Identifier',
+                        loc: DUMMY_LOC,
                         name: `ComponentProps`,
                       },
                     },
                     typeParameters: {
                       type: 'TSTypeParameterInstantiation',
+                      loc: DUMMY_LOC,
                       params: [param],
                     },
                   },
@@ -2440,36 +2679,46 @@ const getTransforms = (
           case 'React$Ref':
             return {
               type: 'TSTypeReference',
+              loc: DUMMY_LOC,
               typeName: {
                 type: 'Identifier',
+                loc: DUMMY_LOC,
                 name: 'NonNullable',
               },
               typeParameters: {
                 type: 'TSTypeParameterInstantiation',
+                loc: DUMMY_LOC,
                 params: [
                   {
                     type: 'TSUnionType',
+                    loc: DUMMY_LOC,
                     types: [
                       {
                         type: 'TSTypeReference',
+                        loc: DUMMY_LOC,
                         typeName: {
                           type: 'TSQualifiedName',
+                          loc: DUMMY_LOC,
                           left: getReactIdentifier(hasReactImport),
                           right: {
                             type: 'Identifier',
+                            loc: DUMMY_LOC,
                             name: 'Ref',
                           },
                         },
                         typeParameters: {
                           type: 'TSTypeParameterInstantiation',
+                          loc: DUMMY_LOC,
                           params: assertHasExactlyNTypeParameters(1),
                         },
                       },
                       {
                         type: 'TSStringKeyword',
+                        loc: DUMMY_LOC,
                       },
                       {
                         type: 'TSNumberKeyword',
+                        loc: DUMMY_LOC,
                       },
                     ],
                   },
@@ -2483,6 +2732,7 @@ const getTransforms = (
 
       return {
         type: 'TSTypeReference',
+        loc: DUMMY_LOC,
         typeName:
           node.id.type === 'Identifier'
             ? transform.Identifier(node.id, false)
@@ -2499,6 +2749,7 @@ const getTransforms = (
     ): TSESTree.Identifier {
       return {
         type: 'Identifier',
+        loc: DUMMY_LOC,
         name: node.name,
         ...(includeTypeAnnotation && node.typeAnnotation != null
           ? {
@@ -2512,6 +2763,7 @@ const getTransforms = (
     ): TSESTree.TSIndexedAccessType {
       return {
         type: 'TSIndexedAccessType',
+        loc: DUMMY_LOC,
         objectType: transformTypeAnnotationType(node.objectType),
         indexType: transformTypeAnnotationType(node.indexType),
       };
@@ -2526,6 +2778,7 @@ const getTransforms = (
     ): TSESTree.ImportAttribute {
       return {
         type: 'ImportAttribute',
+        loc: DUMMY_LOC,
         key:
           node.key.type === 'Identifier'
             ? transform.Identifier(node.key)
@@ -2539,20 +2792,23 @@ const getTransforms = (
       const importKind = node.importKind;
 
       const specifiers = [];
-      const unsupportedSpecifiers = [];
+      const unsupportedSpecifiers: Array<TSESTree.TSTypeAliasDeclaration> = [];
       node.specifiers.forEach(spec => {
         let id = (() => {
           if (node.importKind === 'typeof' || spec.importKind === 'typeof') {
             const id = {
               type: 'Identifier',
+              loc: DUMMY_LOC,
               name: getPlaceholderNameForTypeofImport(),
             };
 
             unsupportedSpecifiers.push({
               type: 'TSTypeAliasDeclaration',
+              loc: DUMMY_LOC,
               id: transform.Identifier(spec.local, false),
               typeAnnotation: {
                 type: 'TSTypeQuery',
+                loc: DUMMY_LOC,
                 exprName: id,
               },
             });
@@ -2567,6 +2823,7 @@ const getTransforms = (
           case 'ImportDefaultSpecifier':
             specifiers.push({
               type: 'ImportDefaultSpecifier',
+              loc: DUMMY_LOC,
               local: id,
             });
             return;
@@ -2574,6 +2831,7 @@ const getTransforms = (
           case 'ImportNamespaceSpecifier':
             specifiers.push({
               type: 'ImportNamespaceSpecifier',
+              loc: DUMMY_LOC,
               local: id,
             });
             return;
@@ -2581,6 +2839,7 @@ const getTransforms = (
           case 'ImportSpecifier':
             specifiers.push({
               type: 'ImportSpecifier',
+              loc: DUMMY_LOC,
               importKind:
                 spec.importKind === 'typeof' || spec.importKind === 'type'
                   ? 'type'
@@ -2592,10 +2851,11 @@ const getTransforms = (
         }
       });
 
-      const out = specifiers.length
+      const out: Array<TSESTree.ImportDeclaration> = specifiers.length
         ? [
             {
               type: 'ImportDeclaration',
+              loc: DUMMY_LOC,
               assertions: node.assertions.map(transform.ImportAttribute),
               importKind:
                 importKind === 'typeof' ? 'type' : importKind ?? 'value',
@@ -2612,7 +2872,9 @@ const getTransforms = (
     ): TSESTree.TSInterfaceHeritage {
       return {
         type: 'TSInterfaceHeritage',
-        expression: transform.Identifier(node.id, false),
+        loc: DUMMY_LOC,
+        // Bug: node.id can be qualified
+        expression: transform.Identifier((node.id: $FlowFixMe), false),
         typeParameters:
           node.typeParameters == null
             ? undefined
@@ -2628,10 +2890,13 @@ const getTransforms = (
         // type T = U & V & { ... }
         return {
           type: 'TSIntersectionType',
+          loc: DUMMY_LOC,
           types: [
             ...node.extends.map(ex => ({
               type: 'TSTypeReference',
-              typeName: transform.Identifier(ex.id, false),
+              loc: DUMMY_LOC,
+              // Bug: ex.id can be qualified
+              typeName: transform.Identifier((ex.id: $FlowFixMe), false),
               typeParameters:
                 ex.typeParameters == null
                   ? undefined
@@ -2649,6 +2914,7 @@ const getTransforms = (
     ): TSESTree.TSIntersectionType {
       return {
         type: 'TSIntersectionType',
+        loc: DUMMY_LOC,
         types: node.types.map(transformTypeAnnotationType),
       };
     },
@@ -2673,11 +2939,13 @@ const getTransforms = (
     ): TSESTree.TSUnknownKeyword {
       return {
         type: 'TSUnknownKeyword',
+        loc: DUMMY_LOC,
       };
     },
     NullLiteral(_node: FlowESTree.NullLiteral): TSESTree.NullLiteral {
       return {
         type: 'Literal',
+        loc: DUMMY_LOC,
         raw: 'null',
         value: null,
       };
@@ -2687,6 +2955,7 @@ const getTransforms = (
     ): TSESTree.TSNullKeyword {
       return {
         type: 'TSNullKeyword',
+        loc: DUMMY_LOC,
       };
     },
     NullableTypeAnnotation(
@@ -2696,12 +2965,15 @@ const getTransforms = (
       // `?T` becomes `null | undefined | T`
       return {
         type: 'TSUnionType',
+        loc: DUMMY_LOC,
         types: [
           {
             type: 'TSNullKeyword',
+            loc: DUMMY_LOC,
           },
           {
             type: 'TSUndefinedKeyword',
+            loc: DUMMY_LOC,
           },
           transformTypeAnnotationType(node.typeAnnotation),
         ],
@@ -2712,8 +2984,10 @@ const getTransforms = (
     ): TSESTree.TSLiteralType {
       return {
         type: 'TSLiteralType',
+        loc: DUMMY_LOC,
         literal: ({
           type: 'Literal',
+          loc: DUMMY_LOC,
           value: node.value,
           raw: node.raw,
         }: TSESTree.NumberLiteral),
@@ -2724,11 +2998,13 @@ const getTransforms = (
     ): TSESTree.TSNumberKeyword {
       return {
         type: 'TSNumberKeyword',
+        loc: DUMMY_LOC,
       };
     },
     NumericLiteral(node: FlowESTree.NumericLiteral): TSESTree.NumberLiteral {
       return {
         type: 'Literal',
+        loc: DUMMY_LOC,
         raw: node.raw,
         value: node.value,
       };
@@ -2749,10 +3025,13 @@ const getTransforms = (
           node.properties[0];
         const tsProp: TSESTree.TSMappedType = {
           type: 'TSMappedType',
+          loc: DUMMY_LOC,
           typeParameter: {
             type: 'TSTypeParameter',
+            loc: DUMMY_LOC,
             name: {
               type: 'Identifier',
+              loc: DUMMY_LOC,
               name: prop.keyTparam.name,
             },
             constraint: transformTypeAnnotationType(prop.sourceType),
@@ -2824,6 +3103,7 @@ const getTransforms = (
 
         return {
           type: 'TSTypeLiteral',
+          loc: DUMMY_LOC,
           members: tsBody,
         };
       } else {
@@ -2942,6 +3222,7 @@ const getTransforms = (
           .map(({node}) => node);
         const objectType = {
           type: 'TSTypeLiteral',
+          loc: DUMMY_LOC,
           members: tsBody,
         };
 
@@ -2951,19 +3232,24 @@ const getTransforms = (
           const remainingTypes = typesToIntersect.slice(i + 1);
           intersectionMembers.push({
             type: 'TSTypeReference',
+            loc: DUMMY_LOC,
             typeName: {
               type: 'Identifier',
+              loc: DUMMY_LOC,
               name: 'Omit',
             },
             typeParameters: {
               type: 'TSTypeParameterInstantiation',
+              loc: DUMMY_LOC,
               params: [
                 currentType,
                 {
                   type: 'TSTypeOperator',
+                  loc: DUMMY_LOC,
                   operator: 'keyof',
                   typeAnnotation: {
                     type: 'TSUnionType',
+                    loc: DUMMY_LOC,
                     types: [...remainingTypes, objectType],
                   },
                 },
@@ -2975,6 +3261,7 @@ const getTransforms = (
 
         return {
           type: 'TSIntersectionType',
+          loc: DUMMY_LOC,
           types: intersectionMembers,
         };
       }
@@ -2986,6 +3273,7 @@ const getTransforms = (
       const func = transform.FunctionTypeAnnotation(node.value);
       return {
         type: 'TSCallSignatureDeclaration',
+        loc: DUMMY_LOC,
         params: func.params,
         returnType: func.returnType,
         typeParameters: func.typeParameters,
@@ -2996,12 +3284,15 @@ const getTransforms = (
     ): TSESTree.TSIndexSignature {
       return {
         type: 'TSIndexSignature',
+        loc: DUMMY_LOC,
         parameters: [
           {
             type: 'Identifier',
+            loc: DUMMY_LOC,
             name: node.id == null ? '$$Key$$' : node.id.name,
             typeAnnotation: {
               type: 'TSTypeAnnotation',
+              loc: DUMMY_LOC,
               typeAnnotation: transformTypeAnnotationType(node.key),
             },
           },
@@ -3010,6 +3301,7 @@ const getTransforms = (
         static: node.static,
         typeAnnotation: {
           type: 'TSTypeAnnotation',
+          loc: DUMMY_LOC,
           typeAnnotation: transformTypeAnnotationType(node.value),
         },
       };
@@ -3028,6 +3320,7 @@ const getTransforms = (
         const func = transform.FunctionTypeAnnotation(node.value);
         return {
           type: 'TSMethodSignature',
+          loc: DUMMY_LOC,
           computed: false,
           key,
           kind: node.kind === 'init' ? 'method' : node.kind,
@@ -3045,6 +3338,7 @@ const getTransforms = (
         const func = transform.FunctionTypeAnnotation(node.value);
         return {
           type: 'TSMethodSignature',
+          loc: DUMMY_LOC,
           computed: false,
           key,
           kind: node.kind,
@@ -3060,6 +3354,7 @@ const getTransforms = (
 
       return {
         type: 'TSPropertySignature',
+        loc: DUMMY_LOC,
         computed: false,
         key,
         optional: node.optional,
@@ -3067,6 +3362,7 @@ const getTransforms = (
         static: node.static,
         typeAnnotation: {
           type: 'TSTypeAnnotation',
+          loc: DUMMY_LOC,
           typeAnnotation: transformTypeAnnotationType(node.value),
         },
       };
@@ -3088,14 +3384,18 @@ const getTransforms = (
       // `T?.[K]` becomes `NonNullable<T>[K]`
       return {
         type: 'TSIndexedAccessType',
+        loc: DUMMY_LOC,
         objectType: {
           type: 'TSTypeReference',
+          loc: DUMMY_LOC,
           typeName: {
             type: 'Identifier',
+            loc: DUMMY_LOC,
             name: 'NonNullable',
           },
           typeParameters: {
             type: 'TSTypeParameterInstantiation',
+            loc: DUMMY_LOC,
             params: [transformTypeAnnotationType(node.objectType)],
           },
         },
@@ -3109,6 +3409,7 @@ const getTransforms = (
 
       return {
         type: 'TSQualifiedName',
+        loc: DUMMY_LOC,
         left:
           qual.type === 'Identifier'
             ? transform.Identifier(qual, false)
@@ -3123,6 +3424,7 @@ const getTransforms = (
 
       return {
         type: 'TSQualifiedName',
+        loc: DUMMY_LOC,
         left:
           qual.type === 'Identifier'
             ? transform.Identifier(qual, false)
@@ -3133,6 +3435,7 @@ const getTransforms = (
     RegExpLiteral(node: FlowESTree.RegExpLiteral): TSESTree.RegExpLiteral {
       return {
         type: 'Literal',
+        loc: DUMMY_LOC,
         raw: node.raw,
         regex: {
           pattern: node.regex.pattern,
@@ -3144,6 +3447,7 @@ const getTransforms = (
     StringLiteral(node: FlowESTree.StringLiteral): TSESTree.StringLiteral {
       return {
         type: 'Literal',
+        loc: DUMMY_LOC,
         raw: node.raw,
         value: node.value,
       };
@@ -3153,8 +3457,10 @@ const getTransforms = (
     ): TSESTree.TSLiteralType {
       return {
         type: 'TSLiteralType',
+        loc: DUMMY_LOC,
         literal: ({
           type: 'Literal',
+          loc: DUMMY_LOC,
           value: node.value,
           raw: node.raw,
         }: TSESTree.StringLiteral),
@@ -3165,6 +3471,7 @@ const getTransforms = (
     ): TSESTree.TSStringKeyword {
       return {
         type: 'TSStringKeyword',
+        loc: DUMMY_LOC,
       };
     },
     SymbolTypeAnnotation(
@@ -3172,6 +3479,7 @@ const getTransforms = (
     ): TSESTree.TSSymbolKeyword {
       return {
         type: 'TSSymbolKeyword',
+        loc: DUMMY_LOC,
       };
     },
     ThisTypeAnnotation(
@@ -3179,6 +3487,7 @@ const getTransforms = (
     ): TSESTree.TSThisType {
       return {
         type: 'TSThisType',
+        loc: DUMMY_LOC,
       };
     },
     TupleTypeAnnotation(
@@ -3192,8 +3501,9 @@ const getTransforms = (
             element.variance != null &&
             element.variance.kind === 'plus',
         );
-      const tupleAnnot = {
+      const tupleAnnot: TSESTree.TSTupleType = {
         type: 'TSTupleType',
+        loc: DUMMY_LOC,
         elementTypes: node.types.map(element => {
           switch (element.type) {
             case 'TupleTypeLabeledElement':
@@ -3205,6 +3515,7 @@ const getTransforms = (
               }
               return {
                 type: 'TSNamedTupleMember',
+                loc: DUMMY_LOC,
                 label: transform.Identifier(element.label),
                 optional: element.optional,
                 elementType: transformTypeAnnotationType(element.elementType),
@@ -3213,10 +3524,12 @@ const getTransforms = (
               const annot = transformTypeAnnotationType(element.typeAnnotation);
               return {
                 type: 'TSRestType',
+                loc: DUMMY_LOC,
                 typeAnnotation:
                   element.label != null
                     ? {
                         type: 'TSNamedTupleMember',
+                        loc: DUMMY_LOC,
                         label: transform.Identifier(element.label),
                         optional: false,
                         elementType: annot,
@@ -3232,6 +3545,7 @@ const getTransforms = (
       return allReadOnly
         ? {
             type: 'TSTypeOperator',
+            loc: DUMMY_LOC,
             operator: 'readonly',
             typeAnnotation: tupleAnnot,
           }
@@ -3243,6 +3557,7 @@ const getTransforms = (
     TypeAnnotation(node: FlowESTree.TypeAnnotation): TSESTree.TSTypeAnnotation {
       return {
         type: 'TSTypeAnnotation',
+        loc: DUMMY_LOC,
         typeAnnotation: transformTypeAnnotationType(node.typeAnnotation),
       };
     },
@@ -3253,12 +3568,14 @@ const getTransforms = (
         case 'Identifier':
           return {
             type: 'TSTypeQuery',
+            loc: DUMMY_LOC,
             exprName: transform.Identifier(node.argument),
             typeParameters: undefined,
           };
         case 'QualifiedTypeofIdentifier':
           return {
             type: 'TSTypeQuery',
+            loc: DUMMY_LOC,
             exprName: transform.QualifiedTypeofIdentifier(node.argument),
             typeParameters: undefined,
           };
@@ -3288,8 +3605,10 @@ const getTransforms = (
       */
       return {
         type: 'TSTypeParameter',
+        loc: DUMMY_LOC,
         name: {
           type: 'Identifier',
+          loc: DUMMY_LOC,
           name: node.name,
         },
         constraint:
@@ -3311,6 +3630,7 @@ const getTransforms = (
     ): TSESTree.TSTypeParameterDeclaration {
       return {
         type: 'TSTypeParameterDeclaration',
+        loc: DUMMY_LOC,
         params: node.params.map(transform.TypeParameter),
       };
     },
@@ -3319,6 +3639,7 @@ const getTransforms = (
     ): TSESTree.TSTypeParameterInstantiation {
       return {
         type: 'TSTypeParameterInstantiation',
+        loc: DUMMY_LOC,
         params: node.params.map(transformTypeAnnotationType),
       };
     },
@@ -3327,6 +3648,7 @@ const getTransforms = (
     ): TSESTree.TSUnionType {
       return {
         type: 'TSUnionType',
+        loc: DUMMY_LOC,
         types: node.types.map(transformTypeAnnotationType),
       };
     },
@@ -3335,6 +3657,7 @@ const getTransforms = (
     ): TSESTree.TSVoidKeyword {
       return {
         type: 'TSVoidKeyword',
+        loc: DUMMY_LOC,
       };
     },
     ConditionalTypeAnnotation(
@@ -3342,6 +3665,7 @@ const getTransforms = (
     ): TSESTree.TSConditionalType {
       return {
         type: 'TSConditionalType',
+        loc: DUMMY_LOC,
         checkType: transformTypeAnnotationType(node.checkType),
         extendsType: transformTypeAnnotationType(node.extendsType),
         trueType: transformTypeAnnotationType(node.trueType),
@@ -3353,10 +3677,12 @@ const getTransforms = (
     ): TSESTree.TSTypePredicate {
       return {
         type: 'TSTypePredicate',
-        asserts: node.asserts,
+        loc: DUMMY_LOC,
+        asserts: node.kind != null && node.kind === 'asserts',
         parameterName: transform.Identifier(node.parameterName, false),
         typeAnnotation: node.typeAnnotation && {
           type: 'TSTypeAnnotation',
+          loc: DUMMY_LOC,
           typeAnnotation: transformTypeAnnotationType(node.typeAnnotation),
         },
       };
@@ -3366,6 +3692,7 @@ const getTransforms = (
     ): TSESTree.TSInferType {
       return {
         type: 'TSInferType',
+        loc: DUMMY_LOC,
         typeParameter: transform.TypeParameter(node.typeParameter),
       };
     },
@@ -3374,6 +3701,7 @@ const getTransforms = (
     ): TSESTree.TSTypeOperator {
       return {
         type: 'TSTypeOperator',
+        loc: DUMMY_LOC,
         operator: 'keyof',
         typeAnnotation: transformTypeAnnotationType(node.argument),
       };
@@ -3386,11 +3714,14 @@ const getTransforms = (
           const hasReactImport = isReactImport(node, 'React');
           return {
             type: 'TSTypeReference',
+            loc: DUMMY_LOC,
             typeName: {
               type: 'TSQualifiedName',
+              loc: DUMMY_LOC,
               left: getReactIdentifier(hasReactImport),
               right: {
                 type: 'Identifier',
+                loc: DUMMY_LOC,
                 name: `ReactNode`,
               },
             },
@@ -3413,14 +3744,18 @@ const getTransforms = (
       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,
           typeName: {
             type: 'TSQualifiedName',
+            loc: DUMMY_LOC,
             left: getReactIdentifier(hasReactImport),
             right: {
               type: 'Identifier',
+              loc: DUMMY_LOC,
               name: `ReactNode`,
             },
           },
@@ -3430,6 +3765,7 @@ const getTransforms = (
 
       return {
         type: 'TSFunctionType',
+        loc: DUMMY_LOC,
         typeParameters,
         params,
         returnType,