Add test case that renames destructured property

Author: sisisin

src/testRunner/unittests/tsserver/getExportReferences.ts

@@ -1,14 +1,19 @@
 namespace ts.projectSystem {
     describe("unittests:: tsserver:: getExportReferences", () => {
+        const exportVariable = "export const value = 0;";
+        const exportArrayDestructured = "export const [valueA, valueB] = [0, 1];";
+        const exportObjectDestructured = "export const { valueC, valueD: renamedD } = { valueC: 0, valueD: 1 };";
+
         const mainTs: File = {
             path: "/main.ts",
-            content: 'import { value, valueA, valueB, valueC, valueD } from "./mod";',
+            content: 'import { value, valueA, valueB, valueC, renamedD } 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 };`,
+            content: `${exportVariable}
+${exportArrayDestructured}
+${exportObjectDestructured}
+`,
         };
         const tsconfig: File = {
             path: "/tsconfig.json",
@@ -26,11 +31,22 @@ export const { valueC, valueD } = { valueC: 0, valueD: 1 };`,
             makeReferenceItem({
                 file: mainTs,
                 isDefinition: true,
-                lineText: 'import { value, valueA, valueB, valueC, valueD } from "./mod";',
-                contextText: 'import { value, valueA, valueB, valueC, valueD } from "./mod";',
+                lineText: mainTs.content,
+                contextText: mainTs.content,
                 text,
             });
 
+        const referenceModTs = (
+            texts: { text: string; lineText: string; contextText?: string },
+            override: Partial<MakeReferenceItem> = {},
+        ): protocol.ReferencesResponseItem =>
+            makeReferenceItem({
+                file: modTs,
+                isDefinition: true,
+                ...texts,
+                ...override,
+            });
+
         it("should get const variable decralation references", () => {
             const session = makeSampleSession();
 
@@ -40,16 +56,11 @@ export const { valueC, valueD } = { valueC: 0, valueD: 1 };`,
                 protocolFileLocationFromSubstring(modTs, "value"),
             );
 
-            const referenceModTs = (modTs: File): protocol.ReferencesResponseItem =>
-                makeReferenceItem({
-                    file: modTs,
-                    isDefinition: true,
-                    lineText: "export const value = 0;",
-                    contextText: "export const value = 0;",
-                    text: "value",
-                });
             const expectResponse = {
-                refs: [referenceModTs(modTs), referenceMainTs(mainTs, "value")],
+                refs: [
+                    referenceModTs({ text: "value", lineText: exportVariable, contextText: exportVariable }),
+                    referenceMainTs(mainTs, "value"),
+                ],
                 symbolDisplayString: "const value: 0",
                 symbolName: "value",
                 symbolStartOffset: protocolLocationFromSubstring(modTs.content, "value").offset,
@@ -66,17 +77,15 @@ export const { valueC, valueD } = { valueC: 0, valueD: 1 };`,
                 protocolFileLocationFromSubstring(modTs, "valueA"),
             );
 
-            const referenceModTs = (modTs: File): protocol.ReferencesResponseItem =>
-                makeReferenceItem({
-                    file: modTs,
-                    isDefinition: true,
-                    lineText: "export const [valueA, valueB] = [0, 1];",
-                    contextText: "export const [valueA, valueB] = [0, 1];",
-                    text: "valueA",
-                });
-
             const expectResponse = {
-                refs: [referenceModTs(modTs), referenceMainTs(mainTs, "valueA")],
+                refs: [
+                    referenceModTs({
+                        text: "valueA",
+                        lineText: exportArrayDestructured,
+                        contextText: exportArrayDestructured,
+                    }),
+                    referenceMainTs(mainTs, "valueA"),
+                ],
                 symbolDisplayString: "const valueA: number",
                 symbolName: "valueA",
                 symbolStartOffset: protocolLocationFromSubstring(modTs.content, "valueA").offset,
@@ -92,35 +101,18 @@ export const { valueC, valueD } = { valueC: 0, valueD: 1 };`,
                 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 };",
+                    referenceModTs({
+                        text: "valueC",
+                        lineText: exportObjectDestructured,
+                        contextText: exportObjectDestructured,
                     }),
                     referenceMainTs(mainTs, "valueC"),
-                    referenceModTs(modTs, {
-                        contextText: "valueC: 0",
-                        options: { index: 1 },
-                    }),
+                    referenceModTs(
+                        { text: "valueC", lineText: exportObjectDestructured, contextText: "valueC: 0" },
+                        { options: { index: 1 } },
+                    ),
                 ],
                 symbolDisplayString: "const valueC: number",
                 symbolName: "valueC",
@@ -129,5 +121,30 @@ export const { valueC, valueD } = { valueC: 0, valueD: 1 };`,
 
             assert.deepEqual(response, expectResponse);
         });
+
+        it("should get object decralation references that renames destructured property", () => {
+            const session = makeSampleSession();
+            const response = executeSessionRequest<protocol.ReferencesRequest, protocol.ReferencesResponse>(
+                session,
+                protocol.CommandTypes.References,
+                protocolFileLocationFromSubstring(modTs, "renamedD"),
+            );
+
+            const expectResponse = {
+                refs: [
+                    referenceModTs({
+                        text: "renamedD",
+                        lineText: exportObjectDestructured,
+                        contextText: exportObjectDestructured,
+                    }),
+                    referenceMainTs(mainTs, "renamedD"),
+                ],
+                symbolDisplayString: "const renamedD: number",
+                symbolName: "renamedD",
+                symbolStartOffset: protocolLocationFromSubstring(modTs.content, "renamedD").offset,
+            };
+
+            assert.deepEqual(response, expectResponse);
+        });
     });
 }

src/testRunner/unittests/tsserver/helpers.ts

@@ -727,7 +727,7 @@ namespace ts.projectSystem {
         }
     }
 
-    interface MakeReferenceItem extends DocumentSpanFromSubstring {
+    export interface MakeReferenceItem extends DocumentSpanFromSubstring {
         isDefinition: boolean;
         lineText: string;
     }