flow-api-translator 0.20.1 → 0.21.1

package/dist/flowDefToTSDef.js

@@ -30,6 +30,17 @@ function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "functio
 
 function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
 
+const DUMMY_LOC = {
+  start: {
+    line: 1,
+    column: 0
+  },
+  end: {
+    line: 1,
+    column: 0
+  }
+};
+
 function constructFlowNode(node) {
   // $FlowFixMe[prop-missing]
   return node;
@@ -55,6 +66,7 @@ function getReactIdentifier(hasReactImport) {
 
   return {
     type: 'Identifier',
+    loc: DUMMY_LOC,
     name: `React`
   };
 }
@@ -65,6 +77,7 @@ function flowDefToTSDef(originalCode, ast, scopeManager, opts) {
     type: 'Program',
     body: tsBody,
     sourceType: ast.sourceType,
+    loc: ast.loc,
     docblock: ast.docblock == null ? null : (0, _DocblockUtils.removeAtFlowFromDocblock)(ast.docblock)
   };
   shouldAddReactImport = null;
@@ -89,15 +102,19 @@ function flowDefToTSDef(originalCode, ast, scopeManager, opts) {
     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'
         }
       }],
@@ -136,6 +153,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
 
     const comment = {
       type: 'Block',
+      loc: DUMMY_LOC,
       value: `*${_os.EOL} * ${message.replace(new RegExp(_os.EOL, 'g'), `${_os.EOL} * `)}${_os.EOL}*`,
       leading: true,
       printed: false
@@ -143,8 +161,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
     code = makeCommentOwnLine(code, comment); // $FlowExpectedError[prop-missing]
     // $FlowExpectedError[cannot-write]
 
-    (_node$comments = node.comments) != null ? _node$comments : node.comments = []; // $FlowExpectedError[prop-missing]
-    // $FlowExpectedError[incompatible-cast]
+    (_node$comments = node.comments) != null ? _node$comments : node.comments = []; // $FlowExpectedError[incompatible-cast]
 
     node.comments.push(comment);
   }
@@ -155,7 +172,8 @@ const getTransforms = (originalCode, scopeManager, opts) => {
     if (opts.recoverFromErrors) {
       const codeFrame = buildCodeFrameForComment(node, message);
       const newNode = {
-        type: 'TSAnyKeyword'
+        type: 'TSAnyKeyword',
+        loc: DUMMY_LOC
       };
       addErrorComment(newNode, codeFrame);
       return newNode;
@@ -171,10 +189,12 @@ const getTransforms = (originalCode, scopeManager, opts) => {
       const codeFrame = buildCodeFrameForComment(node, message);
       const newNode = {
         type: 'TSTypeAliasDeclaration',
+        loc: DUMMY_LOC,
         declare,
         id: transform.Identifier(id, false),
         typeAnnotation: {
-          type: 'TSAnyKeyword'
+          type: 'TSAnyKeyword',
+          loc: DUMMY_LOC
         },
         typeParameters: typeParameters == null ? undefined : transform.TypeParameterDeclaration(typeParameters)
       };
@@ -320,10 +340,12 @@ const getTransforms = (originalCode, scopeManager, opts) => {
 
             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
               }
@@ -335,6 +357,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         case 'EnumStringMember':
           members.push({
             type: 'TSEnumMember',
+            loc: DUMMY_LOC,
             computed: false,
             id: transform.Identifier(member.id, false),
             initializer: member.init.literalType === 'string' ? transform.StringLiteral(member.init) : transform.NumericLiteral(member.init)
@@ -343,13 +366,16 @@ const getTransforms = (originalCode, scopeManager, opts) => {
     }
 
     const bodyRepresentationType = body.type === 'EnumNumberBody' ? {
-      type: 'TSNumberKeyword'
+      type: 'TSNumberKeyword',
+      loc: DUMMY_LOC
     } : {
-      type: 'TSStringKeyword'
+      type: 'TSStringKeyword',
+      loc: DUMMY_LOC
     };
     const enumName = transform.Identifier(node.id, false);
     return [{
       type: 'TSEnumDeclaration',
+      loc: DUMMY_LOC,
       const: false,
       declare: true,
       id: enumName,
@@ -371,17 +397,22 @@ const getTransforms = (originalCode, scopeManager, opts) => {
     */
     {
       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,
@@ -389,23 +420,30 @@ const getTransforms = (originalCode, scopeManager, opts) => {
             async: false,
             params: [{
               type: 'Identifier',
+              loc: DUMMY_LOC,
               name: 'value',
               typeAnnotation: {
                 type: 'TSTypeAnnotation',
+                loc: DUMMY_LOC,
                 typeAnnotation: {
                   type: 'TSUnionType',
+                  loc: DUMMY_LOC,
                   types: [bodyRepresentationType, {
-                    type: 'TSNullKeyword'
+                    type: 'TSNullKeyword',
+                    loc: DUMMY_LOC
                   }, {
-                    type: 'TSUndefinedKeyword'
+                    type: 'TSUndefinedKeyword',
+                    loc: DUMMY_LOC
                   }]
                 }
               }
             }],
             returnType: {
               type: 'TSTypeAnnotation',
+              loc: DUMMY_LOC,
               typeAnnotation: {
                 type: 'TSTypeReference',
+                loc: DUMMY_LOC,
                 typeName: enumName
               }
             }
@@ -417,10 +455,13 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         }, // 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,
@@ -428,32 +469,42 @@ const getTransforms = (originalCode, scopeManager, opts) => {
             async: false,
             params: [{
               type: 'Identifier',
+              loc: DUMMY_LOC,
               name: 'value',
               typeAnnotation: {
                 type: 'TSTypeAnnotation',
+                loc: DUMMY_LOC,
                 typeAnnotation: {
                   type: 'TSUnionType',
+                  loc: DUMMY_LOC,
                   types: [bodyRepresentationType, {
-                    type: 'TSNullKeyword'
+                    type: 'TSNullKeyword',
+                    loc: DUMMY_LOC
                   }, {
-                    type: 'TSUndefinedKeyword'
+                    type: 'TSUndefinedKeyword',
+                    loc: DUMMY_LOC
                   }]
                 }
               }
             }],
             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
                   }
                 }
@@ -467,10 +518,13 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         }, // 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,
@@ -479,16 +533,21 @@ const getTransforms = (originalCode, scopeManager, opts) => {
             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
                   }]
                 }
@@ -502,10 +561,13 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         }, // 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,
@@ -513,19 +575,24 @@ const getTransforms = (originalCode, scopeManager, opts) => {
             async: false,
             params: [{
               type: 'Identifier',
+              loc: DUMMY_LOC,
               name: 'value',
               typeAnnotation: {
                 type: 'TSTypeAnnotation',
+                loc: DUMMY_LOC,
                 typeAnnotation: {
                   type: 'TSTypeReference',
+                  loc: DUMMY_LOC,
                   typeName: enumName
                 }
               }
             }],
             returnType: {
               type: 'TSTypeAnnotation',
+              loc: DUMMY_LOC,
               typeAnnotation: {
-                type: 'TSStringKeyword'
+                type: 'TSStringKeyword',
+                loc: DUMMY_LOC
               }
             }
           },
@@ -658,13 +725,15 @@ const getTransforms = (originalCode, scopeManager, opts) => {
   const transform = {
     AnyTypeAnnotation(_node) {
       return {
-        type: 'TSAnyKeyword'
+        type: 'TSAnyKeyword',
+        loc: DUMMY_LOC
       };
     },
 
     ArrayTypeAnnotation(node) {
       return {
         type: 'TSArrayType',
+        loc: DUMMY_LOC,
         elementType: transformTypeAnnotationType(node.elementType)
       };
     },
@@ -672,6 +741,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
     BigIntLiteral(node) {
       return {
         type: 'Literal',
+        loc: DUMMY_LOC,
         bigint: node.bigint,
         raw: node.raw,
         value: node.value
@@ -690,8 +760,10 @@ const getTransforms = (originalCode, scopeManager, opts) => {
       .replace(/_/, '');
       return {
         type: 'TSLiteralType',
+        loc: DUMMY_LOC,
         literal: {
           type: 'Literal',
+          loc: DUMMY_LOC,
           value: node.value,
           raw: node.raw,
           bigint
@@ -701,13 +773,15 @@ const getTransforms = (originalCode, scopeManager, opts) => {
 
     BigIntTypeAnnotation(_node) {
       return {
-        type: 'TSBigIntKeyword'
+        type: 'TSBigIntKeyword',
+        loc: DUMMY_LOC
       };
     },
 
     BooleanLiteral(node) {
       return {
         type: 'Literal',
+        loc: DUMMY_LOC,
         raw: node.raw,
         value: node.value
       };
@@ -716,8 +790,10 @@ const getTransforms = (originalCode, scopeManager, opts) => {
     BooleanLiteralTypeAnnotation(node) {
       return {
         type: 'TSLiteralType',
+        loc: DUMMY_LOC,
         literal: {
           type: 'Literal',
+          loc: DUMMY_LOC,
           value: node.value,
           raw: node.raw
         }
@@ -726,13 +802,15 @@ const getTransforms = (originalCode, scopeManager, opts) => {
 
     BooleanTypeAnnotation(_node) {
       return {
-        type: 'TSBooleanKeyword'
+        type: 'TSBooleanKeyword',
+        loc: DUMMY_LOC
       };
     },
 
     ClassImplements(node) {
       return {
         type: 'TSClassImplements',
+        loc: DUMMY_LOC,
         expression: transform.Identifier(node.id, false),
         typeParameters: node.typeParameters == null ? undefined : transform.TypeParameterInstantiation(node.typeParameters)
       };
@@ -771,10 +849,12 @@ const getTransforms = (originalCode, scopeManager, opts) => {
               if (isConstructor) {
                 const newNode = {
                   type: 'MethodDefinition',
+                  loc: DUMMY_LOC,
                   accessibility: undefined,
                   computed: false,
                   key: {
                     type: 'Identifier',
+                    loc: DUMMY_LOC,
                     name: 'constructor'
                   },
                   kind: 'constructor',
@@ -783,6 +863,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                   static: false,
                   value: {
                     type: 'TSEmptyBodyFunctionExpression',
+                    loc: DUMMY_LOC,
                     async: false,
                     body: null,
                     declare: false,
@@ -802,6 +883,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
 
                 const newNode = {
                   type: 'MethodDefinition',
+                  loc: DUMMY_LOC,
                   accessibility: member.accessibility,
                   computed: (_member$computed = member.computed) != null ? _member$computed : false,
                   key: member.key,
@@ -811,6 +893,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                   static: (_member$static = member.static) != null ? _member$static : false,
                   value: {
                     type: 'TSEmptyBodyFunctionExpression',
+                    loc: DUMMY_LOC,
                     async: false,
                     body: null,
                     declare: false,
@@ -835,6 +918,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
 
               const newNode = {
                 type: 'PropertyDefinition',
+                loc: DUMMY_LOC,
                 accessibility: member.accessibility,
                 computed: (_member$computed2 = member.computed) != null ? _member$computed2 : false,
                 declare: false,
@@ -881,14 +965,17 @@ const getTransforms = (originalCode, scopeManager, opts) => {
       const superClass = node.extends.length > 0 ? node.extends[0] : undefined;
       return {
         type: 'ClassDeclaration',
+        loc: DUMMY_LOC,
         body: {
           type: 'ClassBody',
+          loc: DUMMY_LOC,
           body: classMembers
         },
         declare: true,
         id: transform.Identifier(node.id, false),
         implements: node.implements == null ? undefined : node.implements.map(transform.ClassImplements),
-        superClass: superClass == null ? null : transform.Identifier(superClass.id, false),
+        superClass: superClass == null ? null : // Bug: superclass.id can be qualified
+        transform.Identifier(superClass.id, false),
         superTypeParameters: (superClass == null ? void 0 : superClass.typeParameters) == null ? undefined : transform.TypeParameterInstantiation(superClass.typeParameters),
         typeParameters: node.typeParameters == null ? undefined : transform.TypeParameterDeclaration(node.typeParameters) // TODO - mixins??
 
@@ -907,8 +994,10 @@ const getTransforms = (originalCode, scopeManager, opts) => {
               const name = declaration.id.name;
               return [classDecl, {
                 type: 'ExportDefaultDeclaration',
+                loc: DUMMY_LOC,
                 declaration: {
                   type: 'Identifier',
+                  loc: DUMMY_LOC,
                   name
                 },
                 exportKind: 'value'
@@ -922,8 +1011,10 @@ const getTransforms = (originalCode, scopeManager, opts) => {
               const name = declaration.id.name;
               return [functionDecl, {
                 type: 'ExportDefaultDeclaration',
+                loc: DUMMY_LOC,
                 declaration: {
                   type: 'Identifier',
+                  loc: DUMMY_LOC,
                   name
                 },
                 exportKind: 'value'
@@ -937,8 +1028,10 @@ const getTransforms = (originalCode, scopeManager, opts) => {
               const name = declaration.id.name;
               return [functionDecl, {
                 type: 'ExportDefaultDeclaration',
+                loc: DUMMY_LOC,
                 declaration: {
                   type: 'Identifier',
+                  loc: DUMMY_LOC,
                   name
                 },
                 exportKind: 'value'
@@ -952,8 +1045,10 @@ const getTransforms = (originalCode, scopeManager, opts) => {
               const name = declaration.id.name;
               return [functionDecl, {
                 type: 'ExportDefaultDeclaration',
+                loc: DUMMY_LOC,
                 declaration: {
                   type: 'Identifier',
+                  loc: DUMMY_LOC,
                   name
                 },
                 exportKind: 'value'
@@ -999,8 +1094,10 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                       // 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'
@@ -1037,13 +1134,17 @@ const getTransforms = (originalCode, scopeManager, opts) => {
               const SPECIFIER = '$$EXPORT_DEFAULT_DECLARATION$$';
               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)
                     }
                   },
@@ -1053,8 +1154,10 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                 kind: 'const'
               }, {
                 type: 'ExportDefaultDeclaration',
+                loc: DUMMY_LOC,
                 declaration: {
                   type: 'Identifier',
+                  loc: DUMMY_LOC,
                   name: SPECIFIER
                 },
                 exportKind: 'value'
@@ -1068,6 +1171,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
           if (node.declaration === null) {
             return {
               type: 'ExportNamedDeclaration',
+              loc: DUMMY_LOC,
               // flow does not currently support assertions
               assertions: [],
               declaration: null,
@@ -1144,6 +1248,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
             exportKind
           }) => ({
             type: 'ExportNamedDeclaration',
+            loc: DUMMY_LOC,
             // flow does not currently support assertions
             assertions: [],
             declaration,
@@ -1154,6 +1259,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         } else {
           return {
             type: 'ExportNamedDeclaration',
+            loc: DUMMY_LOC,
             // flow does not currently support assertions
             assertions: [],
             declaration: null,
@@ -1174,14 +1280,18 @@ const getTransforms = (originalCode, scopeManager, opts) => {
       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`
             }
           },
@@ -1190,6 +1300,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
       };
       return {
         type: 'TSDeclareFunction',
+        loc: DUMMY_LOC,
         async: false,
         body: undefined,
         declare: true,
@@ -1197,6 +1308,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         generator: false,
         id: {
           type: 'Identifier',
+          loc: DUMMY_LOC,
           name: id.name
         },
         params,
@@ -1209,9 +1321,11 @@ const getTransforms = (originalCode, scopeManager, opts) => {
       if (params.length === 0 && rest != null) {
         return [{
           type: 'Identifier',
+          loc: DUMMY_LOC,
           name: 'props',
           typeAnnotation: {
             type: 'TSTypeAnnotation',
+            loc: DUMMY_LOC,
             typeAnnotation: transformTypeAnnotationType(rest.typeAnnotation)
           },
           optional: false
@@ -1264,9 +1378,11 @@ const getTransforms = (originalCode, scopeManager, opts) => {
       }));
       return [{
         type: 'Identifier',
+        loc: DUMMY_LOC,
         name: 'props',
         typeAnnotation: {
           type: 'TSTypeAnnotation',
+          loc: DUMMY_LOC,
           typeAnnotation: tsPropsObjectType
         },
         optional: false
@@ -1279,6 +1395,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
       const functionInfo = transform.FunctionTypeAnnotation(node.id.typeAnnotation.typeAnnotation);
       return {
         type: 'TSDeclareFunction',
+        loc: DUMMY_LOC,
         async: false,
         body: undefined,
         declare: true,
@@ -1286,6 +1403,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         generator: false,
         id: {
           type: 'Identifier',
+          loc: DUMMY_LOC,
           name: id.name
         },
         params: functionInfo.params,
@@ -1300,6 +1418,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
       const functionInfo = transform.FunctionTypeAnnotation(node.id.typeAnnotation.typeAnnotation);
       return {
         type: 'TSDeclareFunction',
+        loc: DUMMY_LOC,
         async: false,
         body: undefined,
         declare: true,
@@ -1307,6 +1426,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         generator: false,
         id: {
           type: 'Identifier',
+          loc: DUMMY_LOC,
           name: id.name
         },
         params: functionInfo.params,
@@ -1324,8 +1444,10 @@ const getTransforms = (originalCode, scopeManager, opts) => {
 
       return {
         type: 'TSInterfaceDeclaration',
+        loc: DUMMY_LOC,
         body: {
           type: 'TSInterfaceBody',
+          loc: DUMMY_LOC,
           body: transformedBody.members
         },
         declare: node.type !== 'InterfaceDeclaration',
@@ -1338,6 +1460,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
     DeclareTypeAlias(node) {
       return {
         type: 'TSTypeAliasDeclaration',
+        loc: DUMMY_LOC,
         declare: node.type === 'DeclareTypeAlias',
         id: transform.Identifier(node.id, false),
         typeAnnotation: transformTypeAnnotationType(node.right),
@@ -1351,10 +1474,12 @@ const getTransforms = (originalCode, scopeManager, opts) => {
       // Examples - https://basarat.gitbook.io/typescript/main-1/nominaltyping
       return {
         type: 'TSTypeAliasDeclaration',
+        loc: DUMMY_LOC,
         declare: true,
         id: transform.Identifier(node.id, false),
         typeAnnotation: node.supertype == null ? {
-          type: 'TSUnknownKeyword'
+          type: 'TSUnknownKeyword',
+          loc: DUMMY_LOC
         } : transformTypeAnnotationType(node.supertype),
         typeParameters: node.typeParameters == null ? undefined : transform.TypeParameterDeclaration(node.typeParameters)
       };
@@ -1363,9 +1488,11 @@ const getTransforms = (originalCode, scopeManager, opts) => {
     DeclareVariable(node) {
       return {
         type: 'VariableDeclaration',
+        loc: DUMMY_LOC,
         declare: true,
         declarations: [{
           type: 'VariableDeclarator',
+          loc: DUMMY_LOC,
           declare: true,
           id: transform.Identifier(node.id, true),
           init: null
@@ -1403,6 +1530,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
     ExportAllDeclaration(node) {
       return {
         type: 'ExportAllDeclaration',
+        loc: DUMMY_LOC,
         // flow does not currently support import/export assertions
         assertions: [],
         exportKind: node.exportKind,
@@ -1416,6 +1544,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         // 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,
@@ -1459,6 +1588,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
 
       const mainExport = {
         type: 'ExportNamedDeclaration',
+        loc: DUMMY_LOC,
         assertions: [],
         declaration: exportedDeclaration,
         exportKind: node.exportKind,
@@ -1470,6 +1600,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         // for cases where there is a merged declaration, TS enforces BOTH are exported
         return [mainExport, {
           type: 'ExportNamedDeclaration',
+          loc: DUMMY_LOC,
           assertions: [],
           declaration: mergedDeclaration,
           exportKind: node.exportKind,
@@ -1484,6 +1615,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
     ExportSpecifier(node) {
       return {
         type: 'ExportSpecifier',
+        loc: DUMMY_LOC,
         exported: transform.Identifier(node.exported, false),
         local: transform.Identifier(node.local, false),
         // flow does not support inline exportKind for named exports
@@ -1497,9 +1629,11 @@ const getTransforms = (originalCode, scopeManager, opts) => {
       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)
           }
         });
@@ -1509,12 +1643,15 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         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)
           }
         });
@@ -1522,9 +1659,11 @@ const getTransforms = (originalCode, scopeManager, opts) => {
 
       return {
         type: 'TSFunctionType',
+        loc: DUMMY_LOC,
         params,
         returnType: {
           type: 'TSTypeAnnotation',
+          loc: DUMMY_LOC,
           typeAnnotation: transformTypeAnnotationType(node.returnType)
         },
         typeParameters: node.typeParameters == null ? undefined : transform.TypeParameterDeclaration(node.typeParameters)
@@ -1534,9 +1673,11 @@ const getTransforms = (originalCode, scopeManager, opts) => {
     FunctionTypeParam(node, idx = 0) {
       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
@@ -1626,26 +1767,34 @@ const getTransforms = (originalCode, scopeManager, opts) => {
             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]
                     }]
@@ -1662,6 +1811,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
             const params = assertHasExactlyNTypeParameters(2);
             return {
               type: 'TSIndexedAccessType',
+              loc: DUMMY_LOC,
               objectType: params[0],
               indexType: params[1]
             };
@@ -1685,6 +1835,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
 
             return {
               type: 'TSImportType',
+              loc: DUMMY_LOC,
               isTypeOf: true,
               argument: moduleName,
               qualifier: null,
@@ -1696,7 +1847,8 @@ const getTransforms = (originalCode, scopeManager, opts) => {
           {
             // `$FlowFixMe` => `any`
             return {
-              type: 'TSAnyKeyword'
+              type: 'TSAnyKeyword',
+              loc: DUMMY_LOC
             };
           }
 
@@ -1705,14 +1857,18 @@ const getTransforms = (originalCode, scopeManager, opts) => {
             // `$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]
                 },
@@ -1722,8 +1878,10 @@ const getTransforms = (originalCode, scopeManager, opts) => {
               nameType: null,
               typeAnnotation: {
                 type: 'TSTypeReference',
+                loc: DUMMY_LOC,
                 typeName: {
                   type: 'Identifier',
+                  loc: DUMMY_LOC,
                   name: 'K'
                 }
               }
@@ -1735,6 +1893,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
             // `$Keys<T>` => `keyof T`
             return {
               type: 'TSTypeOperator',
+              loc: DUMMY_LOC,
               operator: 'keyof',
               typeAnnotation: assertHasExactlyNTypeParameters(1)[0]
             };
@@ -1746,12 +1905,15 @@ const getTransforms = (originalCode, scopeManager, opts) => {
             // 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)
               }
             };
@@ -1762,12 +1924,15 @@ const getTransforms = (originalCode, scopeManager, opts) => {
             // `$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)
               }
             };
@@ -1781,12 +1946,15 @@ const getTransforms = (originalCode, scopeManager, opts) => {
             // 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)
               }
             };
@@ -1796,12 +1964,15 @@ const getTransforms = (originalCode, scopeManager, opts) => {
           {
             return {
               type: 'TSTypeReference',
+              loc: DUMMY_LOC,
               typeName: {
                 type: 'Identifier',
+                loc: DUMMY_LOC,
                 name: 'ReadonlyMap'
               },
               typeParameters: {
                 type: 'TSTypeParameterInstantiation',
+                loc: DUMMY_LOC,
                 params: assertHasExactlyNTypeParameters(2)
               }
             };
@@ -1811,12 +1982,15 @@ const getTransforms = (originalCode, scopeManager, opts) => {
           {
             return {
               type: 'TSTypeReference',
+              loc: DUMMY_LOC,
               typeName: {
                 type: 'Identifier',
+                loc: DUMMY_LOC,
                 name: 'ReadonlySet'
               },
               typeParameters: {
                 type: 'TSTypeParameterInstantiation',
+                loc: DUMMY_LOC,
                 params: assertHasExactlyNTypeParameters(1)
               }
             };
@@ -1828,9 +2002,11 @@ const getTransforms = (originalCode, scopeManager, opts) => {
             const transformedType = assertHasExactlyNTypeParameters(1)[0];
             return {
               type: 'TSIndexedAccessType',
+              loc: DUMMY_LOC,
               objectType: transformedType,
               indexType: {
                 type: 'TSTypeOperator',
+                loc: DUMMY_LOC,
                 operator: 'keyof',
                 typeAnnotation: transformedType
               }
@@ -1848,25 +2024,32 @@ const getTransforms = (originalCode, scopeManager, opts) => {
 
             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'
+                      type: 'TSAnyKeyword',
+                      loc: DUMMY_LOC
                     }
                   }
                 }
               }],
               returnType: {
                 type: 'TSTypeAnnotation',
+                loc: DUMMY_LOC,
                 typeAnnotation: param
               }
             };
@@ -1891,14 +2074,18 @@ const getTransforms = (originalCode, scopeManager, opts) => {
               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]
                   }
                 }]
@@ -1924,16 +2111,20 @@ const getTransforms = (originalCode, scopeManager, opts) => {
 
               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))
                 }
               };
@@ -1945,16 +2136,20 @@ const getTransforms = (originalCode, scopeManager, opts) => {
           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)
               }
             };
@@ -1966,11 +2161,14 @@ const getTransforms = (originalCode, scopeManager, opts) => {
             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'
                 }
               }
@@ -1984,11 +2182,14 @@ const getTransforms = (originalCode, scopeManager, opts) => {
               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`
                   }
                 },
@@ -2003,11 +2204,14 @@ const getTransforms = (originalCode, scopeManager, opts) => {
               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`
                   }
                 },
@@ -2021,16 +2225,20 @@ const getTransforms = (originalCode, scopeManager, opts) => {
             {
               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)
                 }
               };
@@ -2042,16 +2250,20 @@ const getTransforms = (originalCode, scopeManager, opts) => {
           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)
               }
             };
@@ -2063,11 +2275,14 @@ const getTransforms = (originalCode, scopeManager, opts) => {
             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`
                 }
               }
@@ -2080,14 +2295,18 @@ const getTransforms = (originalCode, scopeManager, opts) => {
               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'
                   }
                 },
@@ -2102,16 +2321,20 @@ const getTransforms = (originalCode, scopeManager, opts) => {
             {
               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)
                 }
               };
@@ -2132,8 +2355,8 @@ const getTransforms = (originalCode, scopeManager, opts) => {
 
               const params = typeParameters.params;
 
-              if (params.length > 2) {
-                throw translationError(node, `Expected at no more than 2 type parameters with \`${fullTypeName}\``);
+              if (params.length > 3) {
+                throw translationError(node, `Expected at no more than 3 type parameters with \`${fullTypeName}\``);
               }
 
               const newParams = (() => {
@@ -2141,24 +2364,31 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                   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]
                     }
                   }]
@@ -2167,16 +2397,20 @@ const getTransforms = (originalCode, scopeManager, opts) => {
 
               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
                 }
               };
@@ -2189,16 +2423,20 @@ const getTransforms = (originalCode, scopeManager, opts) => {
             {
               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)
                 }
               };
@@ -2212,31 +2450,40 @@ const getTransforms = (originalCode, scopeManager, opts) => {
               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]
                     }
                   }]
@@ -2250,32 +2497,42 @@ const getTransforms = (originalCode, scopeManager, opts) => {
           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'
+                    type: 'TSStringKeyword',
+                    loc: DUMMY_LOC
                   }, {
-                    type: 'TSNumberKeyword'
+                    type: 'TSNumberKeyword',
+                    loc: DUMMY_LOC
                   }]
                 }]
               }
@@ -2288,6 +2545,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
 
       return {
         type: 'TSTypeReference',
+        loc: DUMMY_LOC,
         typeName: node.id.type === 'Identifier' ? transform.Identifier(node.id, false) : transform.QualifiedTypeIdentifier(node.id),
         typeParameters: node.typeParameters == null ? undefined : transform.TypeParameterInstantiation(node.typeParameters)
       };
@@ -2296,6 +2554,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
     Identifier(node, includeTypeAnnotation = true) {
       return {
         type: 'Identifier',
+        loc: DUMMY_LOC,
         name: node.name,
         ...(includeTypeAnnotation && node.typeAnnotation != null ? {
           typeAnnotation: transform.TypeAnnotation(node.typeAnnotation)
@@ -2306,6 +2565,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
     IndexedAccessType(node) {
       return {
         type: 'TSIndexedAccessType',
+        loc: DUMMY_LOC,
         objectType: transformTypeAnnotationType(node.objectType),
         indexType: transformTypeAnnotationType(node.indexType)
       };
@@ -2318,6 +2578,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
     ImportAttribute(node) {
       return {
         type: 'ImportAttribute',
+        loc: DUMMY_LOC,
         key: node.key.type === 'Identifier' ? transform.Identifier(node.key) : transform.Literal(node.key),
         value: transform.Literal(node.value)
       };
@@ -2332,13 +2593,16 @@ const getTransforms = (originalCode, scopeManager, opts) => {
           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
               }
             });
@@ -2352,6 +2616,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
           case 'ImportDefaultSpecifier':
             specifiers.push({
               type: 'ImportDefaultSpecifier',
+              loc: DUMMY_LOC,
               local: id
             });
             return;
@@ -2359,6 +2624,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
           case 'ImportNamespaceSpecifier':
             specifiers.push({
               type: 'ImportNamespaceSpecifier',
+              loc: DUMMY_LOC,
               local: id
             });
             return;
@@ -2366,6 +2632,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
           case 'ImportSpecifier':
             specifiers.push({
               type: 'ImportSpecifier',
+              loc: DUMMY_LOC,
               importKind: spec.importKind === 'typeof' || spec.importKind === 'type' ? 'type' : null,
               imported: transform.Identifier(spec.imported, false),
               local: id
@@ -2375,6 +2642,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
       });
       const out = specifiers.length ? [{
         type: 'ImportDeclaration',
+        loc: DUMMY_LOC,
         assertions: node.assertions.map(transform.ImportAttribute),
         importKind: importKind === 'typeof' ? 'type' : importKind != null ? importKind : 'value',
         source: transform.StringLiteral(node.source),
@@ -2386,6 +2654,8 @@ const getTransforms = (originalCode, scopeManager, opts) => {
     InterfaceExtends(node) {
       return {
         type: 'TSInterfaceHeritage',
+        loc: DUMMY_LOC,
+        // Bug: node.id can be qualified
         expression: transform.Identifier(node.id, false),
         typeParameters: node.typeParameters == null ? undefined : transform.TypeParameterInstantiation(node.typeParameters)
       };
@@ -2398,8 +2668,11 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         // type T = U & V & { ... }
         return {
           type: 'TSIntersectionType',
+          loc: DUMMY_LOC,
           types: [...node.extends.map(ex => ({
             type: 'TSTypeReference',
+            loc: DUMMY_LOC,
+            // Bug: ex.id can be qualified
             typeName: transform.Identifier(ex.id, false),
             typeParameters: ex.typeParameters == null ? undefined : transform.TypeParameterInstantiation(ex.typeParameters)
           })), transform.ObjectTypeAnnotation(node.body)]
@@ -2412,6 +2685,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
     IntersectionTypeAnnotation(node) {
       return {
         type: 'TSIntersectionType',
+        loc: DUMMY_LOC,
         types: node.types.map(transformTypeAnnotationType)
       };
     },
@@ -2440,13 +2714,15 @@ const getTransforms = (originalCode, scopeManager, opts) => {
 
     MixedTypeAnnotation(_node) {
       return {
-        type: 'TSUnknownKeyword'
+        type: 'TSUnknownKeyword',
+        loc: DUMMY_LOC
       };
     },
 
     NullLiteral(_node) {
       return {
         type: 'Literal',
+        loc: DUMMY_LOC,
         raw: 'null',
         value: null
       };
@@ -2454,7 +2730,8 @@ const getTransforms = (originalCode, scopeManager, opts) => {
 
     NullLiteralTypeAnnotation(_node) {
       return {
-        type: 'TSNullKeyword'
+        type: 'TSNullKeyword',
+        loc: DUMMY_LOC
       };
     },
 
@@ -2463,10 +2740,13 @@ const getTransforms = (originalCode, scopeManager, opts) => {
       // `?T` becomes `null | undefined | T`
       return {
         type: 'TSUnionType',
+        loc: DUMMY_LOC,
         types: [{
-          type: 'TSNullKeyword'
+          type: 'TSNullKeyword',
+          loc: DUMMY_LOC
         }, {
-          type: 'TSUndefinedKeyword'
+          type: 'TSUndefinedKeyword',
+          loc: DUMMY_LOC
         }, transformTypeAnnotationType(node.typeAnnotation)]
       };
     },
@@ -2474,8 +2754,10 @@ const getTransforms = (originalCode, scopeManager, opts) => {
     NumberLiteralTypeAnnotation(node) {
       return {
         type: 'TSLiteralType',
+        loc: DUMMY_LOC,
         literal: {
           type: 'Literal',
+          loc: DUMMY_LOC,
           value: node.value,
           raw: node.raw
         }
@@ -2484,13 +2766,15 @@ const getTransforms = (originalCode, scopeManager, opts) => {
 
     NumberTypeAnnotation(_node) {
       return {
-        type: 'TSNumberKeyword'
+        type: 'TSNumberKeyword',
+        loc: DUMMY_LOC
       };
     },
 
     NumericLiteral(node) {
       return {
         type: 'Literal',
+        loc: DUMMY_LOC,
         raw: node.raw,
         value: node.value
       };
@@ -2504,10 +2788,13 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         const prop = node.properties[0];
         const tsProp = {
           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),
@@ -2575,6 +2862,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         }) => node);
         return {
           type: 'TSTypeLiteral',
+          loc: DUMMY_LOC,
           members: tsBody
         };
       } else {
@@ -2674,6 +2962,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         }) => node);
         const objectType = {
           type: 'TSTypeLiteral',
+          loc: DUMMY_LOC,
           members: tsBody
         };
         const intersectionMembers = [];
@@ -2683,17 +2972,22 @@ const getTransforms = (originalCode, scopeManager, opts) => {
           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]
                 }
               }]
@@ -2704,6 +2998,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         intersectionMembers.push(objectType);
         return {
           type: 'TSIntersectionType',
+          loc: DUMMY_LOC,
           types: intersectionMembers
         };
       }
@@ -2714,6 +3009,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
       const func = transform.FunctionTypeAnnotation(node.value);
       return {
         type: 'TSCallSignatureDeclaration',
+        loc: DUMMY_LOC,
         params: func.params,
         returnType: func.returnType,
         typeParameters: func.typeParameters
@@ -2725,11 +3021,14 @@ const getTransforms = (originalCode, scopeManager, opts) => {
 
       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)
           }
         }],
@@ -2737,6 +3036,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         static: node.static,
         typeAnnotation: {
           type: 'TSTypeAnnotation',
+          loc: DUMMY_LOC,
           typeAnnotation: transformTypeAnnotationType(node.value)
         }
       };
@@ -2753,6 +3053,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         const func = transform.FunctionTypeAnnotation(node.value);
         return {
           type: 'TSMethodSignature',
+          loc: DUMMY_LOC,
           computed: false,
           key,
           kind: node.kind === 'init' ? 'method' : node.kind,
@@ -2770,6 +3071,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         const func = transform.FunctionTypeAnnotation(node.value);
         return {
           type: 'TSMethodSignature',
+          loc: DUMMY_LOC,
           computed: false,
           key,
           kind: node.kind,
@@ -2785,6 +3087,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
 
       return {
         type: 'TSPropertySignature',
+        loc: DUMMY_LOC,
         computed: false,
         key,
         optional: node.optional,
@@ -2792,6 +3095,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         static: node.static,
         typeAnnotation: {
           type: 'TSTypeAnnotation',
+          loc: DUMMY_LOC,
           typeAnnotation: transformTypeAnnotationType(node.value)
         }
       };
@@ -2813,14 +3117,18 @@ const getTransforms = (originalCode, scopeManager, opts) => {
 
       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)]
           }
         },
@@ -2832,6 +3140,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
       const qual = node.qualification;
       return {
         type: 'TSQualifiedName',
+        loc: DUMMY_LOC,
         left: qual.type === 'Identifier' ? transform.Identifier(qual, false) : transform.QualifiedTypeIdentifier(qual),
         right: transform.Identifier(node.id, false)
       };
@@ -2841,6 +3150,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
       const qual = node.qualification;
       return {
         type: 'TSQualifiedName',
+        loc: DUMMY_LOC,
         left: qual.type === 'Identifier' ? transform.Identifier(qual, false) : transform.QualifiedTypeofIdentifier(qual),
         right: transform.Identifier(node.id, false)
       };
@@ -2849,6 +3159,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
     RegExpLiteral(node) {
       return {
         type: 'Literal',
+        loc: DUMMY_LOC,
         raw: node.raw,
         regex: {
           pattern: node.regex.pattern,
@@ -2861,6 +3172,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
     StringLiteral(node) {
       return {
         type: 'Literal',
+        loc: DUMMY_LOC,
         raw: node.raw,
         value: node.value
       };
@@ -2869,8 +3181,10 @@ const getTransforms = (originalCode, scopeManager, opts) => {
     StringLiteralTypeAnnotation(node) {
       return {
         type: 'TSLiteralType',
+        loc: DUMMY_LOC,
         literal: {
           type: 'Literal',
+          loc: DUMMY_LOC,
           value: node.value,
           raw: node.raw
         }
@@ -2879,19 +3193,22 @@ const getTransforms = (originalCode, scopeManager, opts) => {
 
     StringTypeAnnotation(_node) {
       return {
-        type: 'TSStringKeyword'
+        type: 'TSStringKeyword',
+        loc: DUMMY_LOC
       };
     },
 
     SymbolTypeAnnotation(_node) {
       return {
-        type: 'TSSymbolKeyword'
+        type: 'TSSymbolKeyword',
+        loc: DUMMY_LOC
       };
     },
 
     ThisTypeAnnotation(_node) {
       return {
-        type: 'TSThisType'
+        type: 'TSThisType',
+        loc: DUMMY_LOC
       };
     },
 
@@ -2899,6 +3216,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
       const allReadOnly = node.types.length > 0 && node.types.every(element => element.type === 'TupleTypeLabeledElement' && element.variance != null && element.variance.kind === 'plus');
       const tupleAnnot = {
         type: 'TSTupleType',
+        loc: DUMMY_LOC,
         elementTypes: node.types.map(element => {
           switch (element.type) {
             case 'TupleTypeLabeledElement':
@@ -2908,6 +3226,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
 
               return {
                 type: 'TSNamedTupleMember',
+                loc: DUMMY_LOC,
                 label: transform.Identifier(element.label),
                 optional: element.optional,
                 elementType: transformTypeAnnotationType(element.elementType)
@@ -2918,8 +3237,10 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                 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
@@ -2934,6 +3255,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
       };
       return allReadOnly ? {
         type: 'TSTypeOperator',
+        loc: DUMMY_LOC,
         operator: 'readonly',
         typeAnnotation: tupleAnnot
       } : tupleAnnot;
@@ -2946,6 +3268,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
     TypeAnnotation(node) {
       return {
         type: 'TSTypeAnnotation',
+        loc: DUMMY_LOC,
         typeAnnotation: transformTypeAnnotationType(node.typeAnnotation)
       };
     },
@@ -2955,6 +3278,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         case 'Identifier':
           return {
             type: 'TSTypeQuery',
+            loc: DUMMY_LOC,
             exprName: transform.Identifier(node.argument),
             typeParameters: undefined
           };
@@ -2962,6 +3286,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         case 'QualifiedTypeofIdentifier':
           return {
             type: 'TSTypeQuery',
+            loc: DUMMY_LOC,
             exprName: transform.QualifiedTypeofIdentifier(node.argument),
             typeParameters: undefined
           };
@@ -2990,8 +3315,10 @@ const getTransforms = (originalCode, scopeManager, opts) => {
       */
       return {
         type: 'TSTypeParameter',
+        loc: DUMMY_LOC,
         name: {
           type: 'Identifier',
+          loc: DUMMY_LOC,
           name: node.name
         },
         constraint: node.bound == null ? undefined : transformTypeAnnotationType(node.bound.typeAnnotation),
@@ -3006,6 +3333,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
     TypeParameterDeclaration(node) {
       return {
         type: 'TSTypeParameterDeclaration',
+        loc: DUMMY_LOC,
         params: node.params.map(transform.TypeParameter)
       };
     },
@@ -3013,6 +3341,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
     TypeParameterInstantiation(node) {
       return {
         type: 'TSTypeParameterInstantiation',
+        loc: DUMMY_LOC,
         params: node.params.map(transformTypeAnnotationType)
       };
     },
@@ -3020,19 +3349,22 @@ const getTransforms = (originalCode, scopeManager, opts) => {
     UnionTypeAnnotation(node) {
       return {
         type: 'TSUnionType',
+        loc: DUMMY_LOC,
         types: node.types.map(transformTypeAnnotationType)
       };
     },
 
     VoidTypeAnnotation(_node) {
       return {
-        type: 'TSVoidKeyword'
+        type: 'TSVoidKeyword',
+        loc: DUMMY_LOC
       };
     },
 
     ConditionalTypeAnnotation(node) {
       return {
         type: 'TSConditionalType',
+        loc: DUMMY_LOC,
         checkType: transformTypeAnnotationType(node.checkType),
         extendsType: transformTypeAnnotationType(node.extendsType),
         trueType: transformTypeAnnotationType(node.trueType),
@@ -3043,10 +3375,12 @@ const getTransforms = (originalCode, scopeManager, opts) => {
     TypePredicateAnnotation(node) {
       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)
         }
       };
@@ -3055,6 +3389,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
     InferTypeAnnotation(node) {
       return {
         type: 'TSInferType',
+        loc: DUMMY_LOC,
         typeParameter: transform.TypeParameter(node.typeParameter)
       };
     },
@@ -3062,6 +3397,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
     KeyofTypeAnnotation(node) {
       return {
         type: 'TSTypeOperator',
+        loc: DUMMY_LOC,
         operator: 'keyof',
         typeAnnotation: transformTypeAnnotationType(node.argument)
       };
@@ -3076,11 +3412,14 @@ const getTransforms = (originalCode, scopeManager, opts) => {
             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`
                 }
               },
@@ -3097,14 +3436,18 @@ const getTransforms = (originalCode, scopeManager, opts) => {
       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`
             }
           },
@@ -3113,6 +3456,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
       };
       return {
         type: 'TSFunctionType',
+        loc: DUMMY_LOC,
         typeParameters,
         params,
         returnType