Fixes getting destructured variables references(#31922)

Author: sisisin

src/services/importTracker.ts

@@ -582,6 +582,12 @@ namespace ts.FindAllReferences {
             return p.name !== node ? undefined :
                 p.parent.kind === SyntaxKind.CatchClause ? undefined : p.parent.parent.kind === SyntaxKind.VariableStatement ? p.parent.parent : undefined;
         }
+        else if (parent.parent && parent.parent.parent && parent.parent.parent.kind === SyntaxKind.VariableDeclaration) {
+          const p = parent.parent.parent as VariableDeclaration;
+          const binded = parent as BindingElement;
+          return binded.name !== node ? undefined :
+              p.parent.kind === SyntaxKind.CatchClause ? undefined : p.parent.parent.kind === SyntaxKind.VariableStatement ? p.parent.parent : undefined;
+        }
         else {
             return parent;
         }

src/testRunner/unittests/tsserver/getExportReferences.ts

@@ -1,22 +1,38 @@
 namespace ts.projectSystem {
     describe("unittests:: tsserver:: getExportReferences", () => {
-        it("should get const variable decralation references", () => {
-            const mainTs: File = {
-                path: "/main.ts",
-                content: 'import { value } from "./mod";',
-            };
-            const modTs: File = {
-                path: "/mod.ts",
-                content: "export const value = 0;",
-            };
-            const tsconfig: File = {
-                path: "/tsconfig.json",
-                content: "{}",
-            };
+        const mainTs: File = {
+            path: "/main.ts",
+            content: 'import { value, valueA, valueB, valueC, valueD } from "./mod";',
+        };
+        const modTs: File = {
+            path: "/mod.ts",
+            content: `export const value = 0;
+export const [valueA, valueB] = [0, 1];
+export const { valueC, valueD } = { valueC: 0, valueD: 1 };`,
+        };
+        const tsconfig: File = {
+            path: "/tsconfig.json",
+            content: "{}",
+        };
 
+        function makeSampleSession() {
             const host = createServerHost([mainTs, modTs, tsconfig]);
             const session = createSession(host);
             openFilesForSession([mainTs, modTs], session);
+            return session;
+        }
+
+        const referenceMainTs = (mainTs: File, text: string): protocol.ReferencesResponseItem =>
+            makeReferenceItem({
+                file: mainTs,
+                isDefinition: true,
+                lineText: 'import { value, valueA, valueB, valueC, valueD } from "./mod";',
+                contextText: 'import { value, valueA, valueB, valueC, valueD } from "./mod";',
+                text,
+            });
+
+        it("should get const variable decralation references", () => {
+            const session = makeSampleSession();
 
             const response = executeSessionRequest<protocol.ReferencesRequest, protocol.ReferencesResponse>(
                 session,
@@ -32,20 +48,83 @@ namespace ts.projectSystem {
                     contextText: "export const value = 0;",
                     text: "value",
                 });
-            const referenceMainTs = (mainTs: File): protocol.ReferencesResponseItem =>
+            const expectResponse = {
+                refs: [referenceModTs(modTs), referenceMainTs(mainTs, "value")],
+                symbolDisplayString: "const value: 0",
+                symbolName: "value",
+                symbolStartOffset: protocolLocationFromSubstring(modTs.content, "value").offset,
+            };
+
+            assert.deepEqual(response, expectResponse);
+        });
+
+        it("should get array destructuring decralation references", () => {
+            const session = makeSampleSession();
+            const response = executeSessionRequest<protocol.ReferencesRequest, protocol.ReferencesResponse>(
+                session,
+                protocol.CommandTypes.References,
+                protocolFileLocationFromSubstring(modTs, "valueA"),
+            );
+
+            const referenceModTs = (modTs: File): protocol.ReferencesResponseItem =>
                 makeReferenceItem({
-                    file: mainTs,
+                    file: modTs,
                     isDefinition: true,
-                    lineText: 'import { value } from "./mod";',
-                    contextText: 'import { value } from "./mod";',
-                    text: "value",
+                    lineText: "export const [valueA, valueB] = [0, 1];",
+                    contextText: "export const [valueA, valueB] = [0, 1];",
+                    text: "valueA",
                 });
 
             const expectResponse = {
-                refs: [referenceModTs(modTs), referenceMainTs(mainTs)],
-                symbolDisplayString: "const value: 0",
-                symbolName: "value",
-                symbolStartOffset: protocolLocationFromSubstring(modTs.content, "value").offset,
+                refs: [referenceModTs(modTs), referenceMainTs(mainTs, "valueA")],
+                symbolDisplayString: "const valueA: number",
+                symbolName: "valueA",
+                symbolStartOffset: protocolLocationFromSubstring(modTs.content, "valueA").offset,
+            };
+
+            assert.deepEqual(response, expectResponse);
+        });
+
+        it("should get object destructuring decralation references", () => {
+            const session = makeSampleSession();
+            const response = executeSessionRequest<protocol.ReferencesRequest, protocol.ReferencesResponse>(
+                session,
+                protocol.CommandTypes.References,
+                protocolFileLocationFromSubstring(modTs, "valueC"),
+            );
+
+            const referenceModTs = (
+                modTs: File,
+                opts: {
+                    contextText: string;
+                    options?: SpanFromSubstringOptions;
+                    contextOptions?: SpanFromSubstringOptions;
+                },
+            ): protocol.ReferencesResponseItem =>
+                makeReferenceItem({
+                    file: modTs,
+                    isDefinition: true,
+                    lineText: "export const { valueC, valueD } = { valueC: 0, valueD: 1 };",
+                    contextText: opts.contextText,
+                    text: "valueC",
+                    options: opts.options,
+                    contextOptions: opts.contextOptions,
+                });
+
+            const expectResponse = {
+                refs: [
+                    referenceModTs(modTs, {
+                        contextText: "export const { valueC, valueD } = { valueC: 0, valueD: 1 };",
+                    }),
+                    referenceMainTs(mainTs, "valueC"),
+                    referenceModTs(modTs, {
+                        contextText: "valueC: 0",
+                        options: { index: 1 },
+                    }),
+                ],
+                symbolDisplayString: "const valueC: number",
+                symbolName: "valueC",
+                symbolStartOffset: protocolLocationFromSubstring(modTs.content, "valueC").offset,
             };
 
             assert.deepEqual(response, expectResponse);