Find-all-references: Don't crash on 'typeof import' (microsoft#23448)

Andy · web-flow · commit f5101e21c36f · 2018-04-17T15:01:36.000-07:00
* Find-all-references: Don't crash on 'typeof import'

* Move `| ImportTypeNode` out of `AnyImportOrReExport`
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
@@ -3193,7 +3193,8 @@ namespace ts {
     export type AnyValidImportOrReExport =
         | (ImportDeclaration | ExportDeclaration) & { moduleSpecifier: StringLiteral }
         | ImportEqualsDeclaration & { moduleReference: ExternalModuleReference & { expression: StringLiteral } }
-        | RequireOrImportCall;
+        | RequireOrImportCall
+        | ImportTypeNode & { argument: LiteralType };
 
     /* @internal */
     export type RequireOrImportCall = CallExpression & { arguments: [StringLiteralLike] };
diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts
@@ -1710,8 +1710,10 @@ namespace ts {
                 return (node.parent as ExternalModuleReference).parent as AnyValidImportOrReExport;
             case SyntaxKind.CallExpression:
                 return node.parent as AnyValidImportOrReExport;
+            case SyntaxKind.LiteralType:
+                return cast(node.parent.parent, isImportTypeNode) as ImportTypeNode & { argument: LiteralType };
             default:
-                return Debug.fail(Debug.showSyntaxKind(node));
+                return Debug.fail(Debug.showSyntaxKind(node.parent));
         }
     }
 
@@ -4926,6 +4928,10 @@ namespace ts {
         return node.kind === SyntaxKind.LiteralType;
     }
 
+    export function isImportTypeNode(node: Node): node is ImportTypeNode {
+        return node.kind === SyntaxKind.ImportType;
+    }
+
     // Binding patterns
 
     export function isObjectBindingPattern(node: Node): node is ObjectBindingPattern {
diff --git a/src/services/importTracker.ts b/src/services/importTracker.ts
@@ -33,7 +33,7 @@ namespace ts.FindAllReferences {
     interface AmbientModuleDeclaration extends ModuleDeclaration { body?: ModuleBlock; }
     type SourceFileLike = SourceFile | AmbientModuleDeclaration;
     // Identifier for the case of `const x = require("y")`.
-    type Importer = AnyImportOrReExport | Identifier;
+    type Importer = AnyImportOrReExport | ImportTypeNode | Identifier;
     type ImporterOrCallExpression = Importer | CallExpression;
 
     /** Returns import statements that directly reference the exporting module, and a list of files that may access the module through a namespace. */
@@ -215,6 +215,10 @@ namespace ts.FindAllReferences {
                 return;
             }
 
+            if (decl.kind === SyntaxKind.ImportType) {
+                return;
+            }
+
             // Ignore if there's a grammar error
             if (decl.moduleSpecifier.kind !== SyntaxKind.StringLiteral) {
                 return;
diff --git a/tests/baselines/reference/api/tsserverlibrary.d.ts b/tests/baselines/reference/api/tsserverlibrary.d.ts
@@ -3169,6 +3169,7 @@ declare namespace ts {
     function isIndexedAccessTypeNode(node: Node): node is IndexedAccessTypeNode;
     function isMappedTypeNode(node: Node): node is MappedTypeNode;
     function isLiteralTypeNode(node: Node): node is LiteralTypeNode;
+    function isImportTypeNode(node: Node): node is ImportTypeNode;
     function isObjectBindingPattern(node: Node): node is ObjectBindingPattern;
     function isArrayBindingPattern(node: Node): node is ArrayBindingPattern;
     function isBindingElement(node: Node): node is BindingElement;
diff --git a/tests/baselines/reference/api/typescript.d.ts b/tests/baselines/reference/api/typescript.d.ts
@@ -3169,6 +3169,7 @@ declare namespace ts {
     function isIndexedAccessTypeNode(node: Node): node is IndexedAccessTypeNode;
     function isMappedTypeNode(node: Node): node is MappedTypeNode;
     function isLiteralTypeNode(node: Node): node is LiteralTypeNode;
+    function isImportTypeNode(node: Node): node is ImportTypeNode;
     function isObjectBindingPattern(node: Node): node is ObjectBindingPattern;
     function isArrayBindingPattern(node: Node): node is ArrayBindingPattern;
     function isBindingElement(node: Node): node is BindingElement;
diff --git a/tests/cases/fourslash/findAllRefsTypeofImport.ts b/tests/cases/fourslash/findAllRefsTypeofImport.ts
@@ -0,0 +1,8 @@
+/// <reference path='fourslash.ts' />
+
+// @Filename: /a.ts
+////export const [|{| "isWriteAccess": true, "isDefinition": true |}x|] = 0;
+////declare const a: typeof import("./a");
+////a.[|x|];
+
+verify.singleReferenceGroup("const x: 0");

Original file line number	Diff line number	Diff line change
`@@ -1710,8 +1710,10 @@ namespace ts {`
`1710`	`1710`	`return (node.parent as ExternalModuleReference).parent as AnyValidImportOrReExport;`
`1711`	`1711`	`case SyntaxKind.CallExpression:`
`1712`	`1712`	`return node.parent as AnyValidImportOrReExport;`
	`1713`	`+ case SyntaxKind.LiteralType:`
	`1714`	`+ return cast(node.parent.parent, isImportTypeNode) as ImportTypeNode & { argument: LiteralType };`
`1713`	`1715`	`default:`
`1714`		`- return Debug.fail(Debug.showSyntaxKind(node));`
	`1716`	`+ return Debug.fail(Debug.showSyntaxKind(node.parent));`
`1715`	`1717`	`}`
`1716`	`1718`	`}`
`1717`	`1719`
`@@ -4926,6 +4928,10 @@ namespace ts {`
`4926`	`4928`	`return node.kind === SyntaxKind.LiteralType;`
`4927`	`4929`	`}`
`4928`	`4930`
	`4931`	`+ export function isImportTypeNode(node: Node): node is ImportTypeNode {`
	`4932`	`+ return node.kind === SyntaxKind.ImportType;`
	`4933`	`+ }`
	`4934`	`+`
`4929`	`4935`	`// Binding patterns`
`4930`	`4936`
`4931`	`4937`	`export function isObjectBindingPattern(node: Node): node is ObjectBindingPattern {`