Factor out FindAllReferences.Core and use Definition/Entry to allow findReferencedSymbols and getImplementationsAtPosition to return different results

Author: Andy Hanson

src/compiler/types.ts

@@ -1849,7 +1849,6 @@ namespace ts {
     }
 
     export interface ExternalModuleReference extends Node {
-        parent: ImportEqualsDeclaration;
         kind: SyntaxKind.ExternalModuleReference;
         parent?: ImportEqualsDeclaration;
         expression?: Expression;
@@ -1909,7 +1908,6 @@ namespace ts {
     }
 
     export interface NamedExports extends Node {
-        parent: ExportDeclaration;
         kind: SyntaxKind.NamedExports;
         parent?: ExportDeclaration;
         elements: NodeArray<ExportSpecifier>;
@@ -1925,7 +1923,6 @@ namespace ts {
     }
 
     export interface ExportSpecifier extends Declaration {
-        parent: NamedExports;
         kind: SyntaxKind.ExportSpecifier;
         parent?: NamedExports;
         propertyName?: Identifier;  // Name preceding "as" keyword (or undefined when "as" is absent)

src/harness/fourslash.ts

@@ -992,7 +992,7 @@ namespace FourSlash {
 
             for (const startRange of toArray(startRanges)) {
                 this.goToRangeStart(startRange);
-                const fullActual = this.findReferencesAtCaret().map<ReferenceJson>(({ definition, references }) => ({
+                const fullActual = ts.map<ts.ReferencedSymbol, ReferenceJson>(this.findReferencesAtCaret(), ({ definition, references }) => ({
                     definition: definition.displayParts.map(d => d.text).join(""),
                     ranges: references
                 }));
@@ -2383,7 +2383,7 @@ namespace FourSlash {
             else {
                 if (actual === undefined) {
                     this.raiseError(`${name} failed - expected the template {newText: "${expected.newText}", caretOffset: "${expected.caretOffset}"} but got nothing instead`);
-                    
+
                 }
 
                 if (actual.newText !== expected.newText) {

src/services/documentHighlights.ts

@@ -21,19 +21,15 @@ namespace ts.DocumentHighlights {
         return referenceEntries && convertReferencedSymbols(referenceEntries);
     }
 
-    function convertReferencedSymbols(referenceEntries: ReferenceEntry[]): DocumentHighlights[] {
+    function convertReferencedSymbols(referenceEntries: FindAllReferences.Entry[]): DocumentHighlights[] {
         const fileNameToDocumentHighlights = createMap<HighlightSpan[]>();
-        for (const referenceEntry of referenceEntries) {
-            const fileName = referenceEntry.fileName;
+        for (const entry of referenceEntries) {
+            const { fileName, span } = FindAllReferences.toHighlightSpan(entry);
             let highlightSpans = fileNameToDocumentHighlights.get(fileName);
             if (!highlightSpans) {
                 fileNameToDocumentHighlights.set(fileName, highlightSpans = []);
             }
-
-            highlightSpans.push({
-                textSpan: referenceEntry.textSpan,
-                kind: referenceEntry.isWriteAccess ? HighlightSpanKind.writtenReference : HighlightSpanKind.reference
-            });
+            highlightSpans.push(span);
         }
 
         return arrayFrom(fileNameToDocumentHighlights.entries(), ([fileName, highlightSpans ]) => ({ fileName, highlightSpans }));

src/services/findAllReferences.ts

@@ -491,7 +491,7 @@ namespace ts.FindAllReferences {
     /** If at an export specifier, go to the symbol it refers to. */
     function skipExportSpecifierSymbol(symbol: Symbol, checker: TypeChecker): Symbol {
         // For `export { foo } from './bar", there's nothing to skip, because it does  not create a new alias. But `export { foo } does.
-        for (const declaration of symbol.declarations) {
+        if (symbol.declarations) for (const declaration of symbol.declarations) {
             if (isExportSpecifier(declaration) && !(declaration as ExportSpecifier).propertyName && !(declaration as ExportSpecifier).parent.parent.moduleSpecifier) {
                 return checker.getExportSpecifierLocalTargetSymbol(declaration);
             }

src/services/importTracker.ts

@@ -479,6 +479,7 @@ namespace ts {
         displayParts: SymbolDisplayPart[];
     }
 
+    //!!! internal implementation details leaked!!!
     export interface ReferencedSymbolOf<T extends DocumentSpan> {
         definition: ReferencedSymbolDefinitionInfo;
         references: T[];

src/services/types.ts

@@ -1132,6 +1132,21 @@ namespace ts {
                 return false;
         }
     }
+
+    /** True if the symbol is for an external module, as opposed to a namespace. */
+    export function isExternalModuleSymbol(moduleSymbol: Symbol): boolean {
+        Debug.assert(!!(moduleSymbol.flags & SymbolFlags.Module));
+        return moduleSymbol.name.charCodeAt(0) === CharacterCodes.doubleQuote;
+    }
+
+    /** Returns `true` the first time it encounters a node and `false` afterwards. */
+    export function nodeSeenTracker<T extends Node>(): (node: T) => boolean {
+        const seen: Array<true> = [];
+        return node => {
+            const id = getNodeId(node);
+            return !seen[id] && (seen[id] = true);
+        };
+    }
 }
 
 // Display-part writer helpers