Support find-all-references for anonymous default exports

Author: Andy Hanson

src/compiler/checker.ts

@@ -22986,6 +22986,9 @@ namespace ts {
                         return getPropertyOfType(objectType, (<NumericLiteral>node).text as __String);
                     }
                     break;
+
+                case SyntaxKind.DefaultKeyword:
+                    return getSymbolOfNode(node.parent);
             }
             return undefined;
         }

src/services/findAllReferences.ts

@@ -176,7 +176,9 @@ namespace ts.FindAllReferences {
             fileName: node.getSourceFile().fileName,
             textSpan: getTextSpan(node),
             isWriteAccess: isWriteAccess(node),
-            isDefinition: isAnyDeclarationName(node) || isLiteralComputedPropertyDeclarationName(node),
+            isDefinition: node.kind === SyntaxKind.DefaultKeyword
+                || isAnyDeclarationName(node)
+                || isLiteralComputedPropertyDeclarationName(node),
             isInString
         };
     }
@@ -243,7 +245,7 @@ namespace ts.FindAllReferences {
 
     /** A node is considered a writeAccess iff it is a name of a declaration or a target of an assignment */
     function isWriteAccess(node: Node): boolean {
-        if (isAnyDeclarationName(node)) {
+        if (node.kind === SyntaxKind.DefaultKeyword || isAnyDeclarationName(node)) {
             return true;
         }
 
@@ -743,7 +745,7 @@ namespace ts.FindAllReferences.Core {
 
     function isValidReferencePosition(node: Node, searchSymbolName: string): boolean {
         // Compare the length so we filter out strict superstrings of the symbol we are looking for
-        switch (node && node.kind) {
+        switch (node.kind) {
             case SyntaxKind.Identifier:
                 return (node as Identifier).text.length === searchSymbolName.length;
 
@@ -754,6 +756,9 @@ namespace ts.FindAllReferences.Core {
             case SyntaxKind.NumericLiteral:
                 return isLiteralNameOfPropertyDeclarationOrIndexAccess(node) && (node as NumericLiteral).text.length === searchSymbolName.length;
 
+            case SyntaxKind.DefaultKeyword:
+                return "default".length === searchSymbolName.length;
+
             default:
                 return false;
         }

src/services/importTracker.ts

@@ -525,7 +525,11 @@ namespace ts.FindAllReferences {
                 importedSymbol = getExportEqualsLocalSymbol(importedSymbol, checker);
             }
 
-            if (symbolName(importedSymbol) === symbol.escapedName) { // If this is a rename import, do not continue searching.
+            // If the import has a different name than the export, do not continue searching.
+            // If `importedName` is undefined, do continue searching as the export is anonymous.
+            // (All imports returned from this function will be ignored anyway if we are in rename and this is a not a named export.)
+            const importedName = symbolName(importedSymbol);
+            if (importedName === undefined || importedName === symbol.escapedName) {
                 return { kind: ImportExport.Import, symbol: importedSymbol, ...isImport };
             }
         }

tests/cases/fourslash/findAllRefsForDefaultExport04.ts

@@ -2,15 +2,24 @@
 
 // @Filename: /a.ts
 ////const [|{| "isWriteAccess": true, "isDefinition": true |}a|] = 0;
-////export default [|a|];
+////export [|{| "isWriteAccess": true, "isDefinition": true |}default|] [|a|];
 
 // @Filename: /b.ts
 ////import [|{| "isWriteAccess": true, "isDefinition": true |}a|] from "./a";
 ////[|a|];
 
-const [r0, r1, r2, r3] = test.ranges();
-verify.referenceGroups([r0, r1], [
-    { definition: "const a: 0", ranges: [r0, r1] },
-    { definition: "import a", ranges: [r2, r3] }
+const [r0, r1, r2, r3, r4] = test.ranges();
+verify.referenceGroups([r0, r2], [
+    { definition: "const a: 0", ranges: [r0, r2] },
+    { definition: "import a", ranges: [r3, r4] }
+]);
+verify.referenceGroups(r1, [
+    // TODO:GH#17990
+    { definition: "import default", ranges: [r1] },
+    { definition: "import a", ranges: [r3, r4] },
+]);
+verify.referenceGroups([r3, r4], [
+    { definition: "import a", ranges: [r3, r4] },
+    // TODO:GH#17990
+    { definition: "import default", ranges: [r1] },
 ]);
-verify.singleReferenceGroup("import a", [r2, r3]);

tests/cases/fourslash/findAllRefsForDefaultExportAnonymous.ts

@@ -0,0 +1,21 @@
+/// <reference path='fourslash.ts' />
+
+// @Filename: /a.ts
+////export [|{| "isWriteAccess": true, "isDefinition": true |}default|] function() {}
+
+// @Filename: /b.ts
+////import [|{| "isWriteAccess": true, "isDefinition": true |}f|] from "./a";
+
+const [r0, r1] = test.ranges();
+verify.referenceGroups(r0, [
+    { definition: "function default(): void", ranges: [r0] },
+    { definition: "import f", ranges: [r1] },
+]);
+verify.referenceGroups(r1, [
+    { definition: "import f", ranges: [r1] },
+    { definition: "function default(): void", ranges: [r0] },
+]);
+
+// Verify that it doesn't try to rename "default"
+verify.renameInfoFailed(r0);
+verify.renameLocations(r1, [r1]);