findAllRefs: give entry for union its own definition (microsoft#22694)

Andy · web-flow · commit c7215a181cb2 · 2018-03-19T11:58:20.000-07:00
diff --git a/src/harness/fourslash.ts b/src/harness/fourslash.ts
@@ -1100,10 +1100,10 @@ namespace FourSlash {
                 references: ranges.map<ts.ReferenceEntry>(r => {
                     const { isWriteAccess = false, isDefinition = false, isInString } = (r.marker && r.marker.data || {}) as { isWriteAccess?: boolean, isDefinition?: boolean, isInString?: true };
                     return {
-                        isWriteAccess,
-                        isDefinition,
                         fileName: r.fileName,
                         textSpan: ts.createTextSpanFromRange(r),
+                        isWriteAccess,
+                        isDefinition,
                         ...(isInString ? { isInString: true } : undefined),
                     };
                 }),
@@ -1119,7 +1119,7 @@ namespace FourSlash {
                 const fullActual = ts.map<ts.ReferencedSymbol, ReferenceGroupJson>(this.findReferencesAtCaret(), ({ definition, references }, i) => {
                     const text = definition.displayParts.map(d => d.text).join("");
                     return {
-                        definition: typeof fullExpected[i].definition === "string" ? text : { text, range: definition.textSpan },
+                        definition: fullExpected.length > i && typeof fullExpected[i].definition === "string" ? text : { text, range: definition.textSpan },
                         references,
                     };
                 });
diff --git a/src/services/findAllReferences.ts b/src/services/findAllReferences.ts
@@ -1599,7 +1599,10 @@ namespace ts.FindAllReferences.Core {
             return firstDefined(checker.getRootSymbols(sym), rootSymbol => {
                 // if it is in the list, then we are done
                 if (search.includes(rootSymbol)) {
-                    return rootSymbol;
+                    // For a root symbol that is a component of a union or intersection, use the original (union/intersection) symbol.
+                    // That we when a symbol references the whole union we avoid claiming it references some particular member of the union.
+                    // For a transient symbol we want to use the root symbol instead.
+                    return getCheckFlags(sym) & CheckFlags.Synthetic ? sym : rootSymbol;
                 }
 
                 // Finally, try all properties with the same name in any type the containing type extended or implemented, and
@@ -1613,7 +1616,7 @@ namespace ts.FindAllReferences.Core {
 
                     const result: Symbol[] = [];
                     getPropertySymbolsFromBaseTypes(rootSymbol.parent, rootSymbol.name, result, /*previousIterationSymbolsCache*/ createSymbolTable(), checker);
-                    return find(result, search.includes);
+                    return result.some(search.includes) ? rootSymbol : undefined;
                 }
 
                 return undefined;
diff --git a/tests/cases/fourslash/findAllRefsForComputedProperties.ts b/tests/cases/fourslash/findAllRefsForComputedProperties.ts
@@ -1,26 +1,25 @@
 /// <reference path='fourslash.ts'/>
 
 ////interface I {
-////    ["[|{| "isDefinition": true |}prop1|]"]: () => void;
+////    [|["[|{| "isDefinition": true |}prop1|]"]|]: () => void;
 ////}
 ////
 ////class C implements I {
-////    ["[|{| "isDefinition": true |}prop1|]"]: any;
+////    [|["[|{| "isDefinition": true |}prop1|]"]|]: any;
 ////}
 ////
 ////var x: I = {
-////    ["[|{| "isDefinition": true |}prop1|]"]: function () { },
+////    [|["[|{| "isDefinition": true |}prop1|]"]|]: function () { },
 ////}
 
-const ranges = test.ranges();
-const [r0, r1, r2] = ranges;
-verify.referenceGroups(r0, [{ definition: '(property) I["prop1"]: () => void', ranges }]);
-verify.referenceGroups(r1, [
-    { definition: '(property) I["prop1"]: () => void', ranges: [r0, r2] },
-    { definition: '(property) C["prop1"]: any', ranges: [r1] }
+// TODO: GH#22690
+const [r0Big, r0, r1Big, r1, r2Big, r2] = test.ranges();
+verify.referenceGroups([r0, r1], [
+    { definition: { text: '(property) I["prop1"]: () => void', range: r0Big }, ranges: [r0, r2] },
+    { definition: { text: '(property) C["prop1"]: any', range: r1Big }, ranges: [r1] },
 ]);
 verify.referenceGroups(r2, [
-    { definition: '(property) I["prop1"]: () => void', ranges: [r0, r1] },
-    { definition: '(property) ["prop1"]: () => void', ranges: [r2] }
+    { definition: { text: '(property) I["prop1"]: () => void', range: r0Big }, ranges: [r0] },
+    { definition: { text: '(property) C["prop1"]: any', range: r1Big }, ranges: [r1] },
+    { definition: { text: '(property) ["prop1"]: () => void', range: r2Big }, ranges: [r2] },
 ]);
-
diff --git a/tests/cases/fourslash/findAllRefsForComputedProperties2.ts b/tests/cases/fourslash/findAllRefsForComputedProperties2.ts
@@ -1,25 +1,25 @@
 /// <reference path='fourslash.ts'/>
 
 ////interface I {
-////    [[|{| "isDefinition": true |}42|]](): void;
+////    [|[[|{| "isDefinition": true |}42|]]|](): void;
 ////}
 ////
 ////class C implements I {
-////    [[|{| "isDefinition": true |}42|]]: any;
+////    [|[[|{| "isDefinition": true |}42|]]|]: any;
 ////}
 ////
 ////var x: I = {
-////    ["[|{| "isDefinition": true |}42|]"]: function () { }
+////    [|["[|{| "isDefinition": true |}42|]"]|]: function () { }
 ////}
 
-const ranges = test.ranges();
-const [r0, r1, r2] = ranges;
-verify.referenceGroups(r0, [{ definition: "(method) I[42](): void", ranges }]);
-verify.referenceGroups(r1, [
-    { definition: "(method) I[42](): void", ranges: [r0, r2] },
-    { definition:  "(property) C[42]: any", ranges: [r1] }
+// TODO: GH#22690
+const [r0Big, r0, r1Big, r1, r2Big, r2] = test.ranges();
+verify.referenceGroups([r0, r1], [
+    { definition: { text: '(method) I[42](): void', range: r0Big }, ranges: [r0, r2] },
+    { definition: { text: '(property) C[42]: any', range: r1Big }, ranges: [r1] },
 ]);
 verify.referenceGroups(r2, [
-    { definition: "(method) I[42](): void", ranges: [r0, r1] },
-    { definition: '(property) ["42"]: () => void', ranges: [r2] }
+    { definition: { text: '(method) I[42](): void', range: r0Big }, ranges: [r0] },
+    { definition: { text: '(property) C[42]: any', range: r1Big }, ranges: [r1] },
+    { definition: { text: '(property) ["42"]: () => void', range: r2Big }, ranges: [r2] },
 ]);
diff --git a/tests/cases/fourslash/findAllRefsInClassExpression.ts b/tests/cases/fourslash/findAllRefsInClassExpression.ts
@@ -5,10 +5,8 @@
 ////   [|{| "isWriteAccess": true, "isDefinition": true |}boom|](){}
 ////}
 
-const ranges = test.ranges();
-const [r0, r1] = ranges;
-verify.referenceGroups(r0, [{ definition: "(method) I.boom(): void", ranges }]);
-verify.referenceGroups(r1, [
+const [r0, r1] = test.ranges();
+verify.referenceGroups([r0, r1], [
     { definition: "(method) I.boom(): void", ranges: [r0] },
     { definition: "(method) C.boom(): void", ranges: [r1] }
 ]);
diff --git a/tests/cases/fourslash/findAllRefsInheritedProperties3.ts b/tests/cases/fourslash/findAllRefsInheritedProperties3.ts
@@ -18,10 +18,22 @@
 //// v.[|propName|];   // r7
 
 const [r0, r1, r2, r3, r4, r5, r6, r7] = test.ranges();
-verify.referenceGroups(r0, [{ definition: "(method) class1.doStuff(): void", ranges: [r0, r4, r6] }]);
-verify.referenceGroups(r1, [{ definition: "(property) class1.propName: string", ranges: [r1, r5, r7] }]);
-verify.referenceGroups(r2, [{ definition: "(method) interface1.doStuff(): void", ranges: [r2, r4, r6] }]);
-verify.referenceGroups(r3, [{ definition: "(property) interface1.propName: string", ranges: [r3, r5, r7] }]);
+verify.referenceGroups(r0, [
+    { definition: "(method) class1.doStuff(): void", ranges: [r0] },
+    { definition: "(method) class2.doStuff(): void", ranges: [r4, r6] },
+]);
+verify.referenceGroups(r1, [
+    { definition: "(property) class1.propName: string", ranges: [r1] },
+    { definition: "(property) class2.propName: string", ranges: [r5, r7] },
+]);
+verify.referenceGroups(r2, [
+    { definition: "(method) interface1.doStuff(): void", ranges: [r2] },
+    { definition: "(method) class2.doStuff(): void", ranges: [r4, r6] },
+]);
+verify.referenceGroups(r3, [
+    { definition: "(property) interface1.propName: string", ranges: [r3] },
+    { definition: "(property) class2.propName: string", ranges: [r5, r7] },
+]);
 verify.referenceGroups([r4, r6], [
     { definition: "(method) class1.doStuff(): void", ranges: [r0] },
     { definition: "(method) interface1.doStuff(): void", ranges: [r2] },
diff --git a/tests/cases/fourslash/findAllRefsParameterPropertyDeclaration_inheritance.ts b/tests/cases/fourslash/findAllRefsParameterPropertyDeclaration_inheritance.ts
@@ -13,8 +13,9 @@
 
 const [r0, r1, r2, r3] = test.ranges();
 verify.referenceGroups(r0, [
-    { definition: "(property) C.x: string", ranges: [r0, r2, r3] },
+    { definition: "(property) C.x: string", ranges: [r0] },
     { definition: "(parameter) x: string", ranges: [r1] },
+    { definition: "(property) D.x: string", ranges: [r2, r3] },
 ]);
 verify.referenceGroups(r1, [
     { definition: "(property) C.x: string", ranges: [r0] },
diff --git a/tests/cases/fourslash/findAllRefsRedeclaredPropertyInDerivedInterface.ts b/tests/cases/fourslash/findAllRefsRedeclaredPropertyInDerivedInterface.ts
@@ -12,15 +12,13 @@
 ////const b: B = { [|{| "isWriteAccess": true, "isDefinition": true |}x|]: 0 };
 
 const [r0, r1, r2, r3] = test.ranges();
-verify.referenceGroups(r0, [
-    { definition: "(property) A.x: string | number", ranges: [r0, r1, r2, r3] },
-]);
-verify.referenceGroups(r1, [
+verify.referenceGroups([r0, r1], [
     { definition: "(property) A.x: string | number", ranges: [r0, r2] },
     { definition: "(property) B.x: number", ranges: [r1, r3] },
 ]);
 verify.referenceGroups(r2, [
-    { definition: "(property) A.x: string | number", ranges: [r0, r1, r3] },
+    { definition: "(property) A.x: string | number", ranges: [r0] },
+    { definition: "(property) B.x: number", ranges: [r1, r3] },
     { definition: "(property) x: number", ranges: [r2] },
 ]);
 verify.referenceGroups(r3, [
diff --git a/tests/cases/fourslash/findAllRefsRootSymbols.ts b/tests/cases/fourslash/findAllRefsRootSymbols.ts
@@ -6,11 +6,11 @@
 ////o.[|x|];
 
 const [r0, r1, r2, r3] = test.ranges();
-verify.referenceGroups(r0, [{ definition: "(property) I.x: {}", ranges: [r0, r3] }]);
-verify.referenceGroups(r1, [{ definition: "(property) J.x: {}", ranges: [r1, r3] }]);
-verify.referenceGroups(r2, [{ definition: "(property) x: string", ranges: [r2, r3] }]);
-verify.referenceGroups(r3, [
-	{ definition: "(property) I.x: {}", ranges: [r0, r3] },
-	{ definition: "(property) J.x: {}", ranges: [r1] },
-	{ definition: "(property) x: string", ranges: [r2] },
-]);
+const i = { definition: "(property) I.x: {}", ranges: [r0] };
+const j = { definition: "(property) J.x: {}", ranges: [r1] };
+const anon = { definition: "(property) x: string", ranges: [r2] };
+const intersect = { definition: "(property) x: string & {}", ranges: [r3] };
+verify.referenceGroups(r0, [i, intersect]);
+verify.referenceGroups(r1, [j, intersect]);
+verify.referenceGroups(r2, [anon, intersect]);
+verify.referenceGroups(r3, [i, j, anon, intersect]);
diff --git a/tests/cases/fourslash/findAllRefsUnionProperty.ts b/tests/cases/fourslash/findAllRefsUnionProperty.ts
@@ -4,13 +4,16 @@
 ////    | { [|{| "isWriteAccess": true, "isDefinition": true |}type|]: "a" }
 ////    | { [|{| "isWriteAccess": true, "isDefinition": true |}type|]: "b" };
 ////declare const t: T;
-////if (t.[|type|] !== "failure") {
+////if (t.[|type|] === "a") {
+////    t.[|type|];
+////} else {
 ////    t.[|type|];
 ////}
 
 const ranges = test.ranges();
-const [r0, r1, r2, r3] = ranges;
+const [r0, r1, r2, r3, r4] = ranges;
 verify.referenceGroups(ranges, [
-    { definition: '(property) type: "a"', ranges: [r0, r2, r3] }, // TODO: this have type `"a" | "b"`
-    { definition: '(property) type: "b"', ranges: [r1] },
+    { definition: { text: '(property) type: "a"',  range: r0 }, ranges: [r0, r3] },
+    { definition: { text: '(property) type: "b"', range: r1 }, ranges: [r1, r4] },
+    { definition: { text: '(property) type: "a" | "b"', range: r0 }, ranges: [r2] },
 ]);
diff --git a/tests/cases/fourslash/referencesForClassMembers.ts b/tests/cases/fourslash/referencesForClassMembers.ts
@@ -16,16 +16,14 @@
 const ranges = test.rangesByText();
 const properties = ranges.get("a");
 const [a0, a1, a2] = properties;
-verify.referenceGroups(a0, [{ definition: "(property) Base.a: number", ranges: properties }]);
-verify.referenceGroups([a1, a2], [
+verify.referenceGroups(properties, [
     { definition: "(property) Base.a: number", ranges: [a0] },
     { definition: "(property) MyClass.a: any", ranges: [a1, a2] }
 ]);
 
 const methods = ranges.get("method");
 const [m0, m1, m2] = methods;
-verify.referenceGroups(m0, [{ definition: "(method) Base.method(): void", ranges: methods }]);
-verify.referenceGroups([m1, m2], [
+verify.referenceGroups(methods, [
     { definition: "(method) Base.method(): void", ranges: [m0] },
     { definition: "(method) MyClass.method(): void", ranges: [m1, m2] }
 ]);
diff --git a/tests/cases/fourslash/referencesForClassMembersExtendingAbstractClass.ts b/tests/cases/fourslash/referencesForClassMembersExtendingAbstractClass.ts
@@ -16,16 +16,14 @@
 const ranges = test.rangesByText();
 const properties = ranges.get("a");
 const [a0, a1, a2] = properties;
-verify.referenceGroups(a0, [{ definition: "(property) Base.a: number", ranges: properties }]);
-verify.referenceGroups([a1, a2], [
+verify.referenceGroups(properties, [
     { definition: "(property) Base.a: number", ranges: [a0] },
     { definition: "(property) MyClass.a: any", ranges: [a1, a2] }
 ]);
 
 const methods = ranges.get("method");
 const [m0, m1, m2] = methods;
-verify.referenceGroups(m0, [{ definition: "(method) Base.method(): void", ranges: methods }]);
-verify.referenceGroups([m1, m2], [
+verify.referenceGroups(methods, [
     { definition: "(method) Base.method(): void", ranges: [m0] },
     { definition: "(method) MyClass.method(): void", ranges: [m1, m2] }
 ]);
diff --git a/tests/cases/fourslash/referencesForClassMembersExtendingGenericClass.ts b/tests/cases/fourslash/referencesForClassMembersExtendingGenericClass.ts
@@ -16,16 +16,14 @@
 const ranges = test.rangesByText();
 const properties = ranges.get("a");
 const [a0, a1, a2] = properties;
-verify.referenceGroups(a0, [{ definition: "(property) Base<T>.a: this", ranges: properties }]);
-verify.referenceGroups([a1, a2], [
+verify.referenceGroups(properties, [
     { definition: "(property) Base<T>.a: this", ranges: [a0] },
     { definition: "(property) MyClass.a: any", ranges: [a1, a2] }
 ]);
 
 const methods = ranges.get("method");
 const [m0, m1, m2] = methods;
-verify.referenceGroups(m0, [{ definition: "(method) Base<T>.method<U>(a?: T, b?: U): this", ranges: methods }]);
-verify.referenceGroups([m1, m2], [
+verify.referenceGroups(methods, [
     { definition: "(method) Base<T>.method<U>(a?: T, b?: U): this", ranges: [m0] },
     { definition: "(method) MyClass.method(): void", ranges: [m1, m2] }
 ]);
diff --git a/tests/cases/fourslash/referencesForContextuallyTypedUnionProperties.ts b/tests/cases/fourslash/referencesForContextuallyTypedUnionProperties.ts
@@ -36,14 +36,29 @@
 
 const all = test.ranges();
 const [aCommon, bCommon, ...unionRefs] = all;
-verify.referenceGroups(aCommon, [{ definition: "(property) A.common: string", ranges: [aCommon, ...unionRefs] }]);
-verify.referenceGroups(bCommon, [{ definition: "(property) B.common: number", ranges: [bCommon, ...unionRefs] }]);
+verify.referenceGroups(aCommon, [
+    { definition: "(property) A.common: string", ranges: [aCommon] },
+    { definition: "(property) common: string | number", ranges: unionRefs },
+]);
+verify.referenceGroups(bCommon, [
+    { definition: "(property) B.common: number", ranges: [bCommon] },
+    { definition: "(property) common: string | number", ranges: unionRefs },
+]);
 
 unionRefs.forEach((unionRef, idx) => {
     const type = unionRef.marker.data.type;
+    const last2 = [
+        { definition: `(property) common: string | number`, ranges: unionRefs.filter(u => u != unionRef) },
+        { definition: `(property) common: ${type}`, ranges: [unionRef] },
+    ];
+    if (idx === 0) {
+        const tmp = last2[0];
+        last2[0] = last2[1];
+        last2[1] = tmp;
+    }
     verify.referenceGroups(unionRef, [
-        { definition: "(property) A.common: string", ranges: all.filter(x => x !== bCommon && x !== unionRef) },
+        { definition: "(property) A.common: string", ranges: [aCommon] },
         { definition: "(property) B.common: number", ranges: [bCommon] },
-        { definition: `(property) common: ${type}`, ranges: [unionRef] }
+        ...last2,
     ]);
 });
diff --git a/tests/cases/fourslash/referencesForInheritedProperties.ts b/tests/cases/fourslash/referencesForInheritedProperties.ts
@@ -23,12 +23,7 @@
 
 const ranges = test.ranges();
 const [r0, r1, r2, r3] = ranges;
-verify.referenceGroups(r0, [{ definition: "(method) interface1.doStuff(): void", ranges }]);
-verify.referenceGroups(r1, [
-    { definition: "(method) interface1.doStuff(): void", ranges: [r0] },
-    { definition: "(method) interface2.doStuff(): void", ranges: [r1, r2, r3] }
-]);
-verify.referenceGroups([r2, r3], [
+verify.referenceGroups(ranges, [
     { definition: "(method) interface1.doStuff(): void", ranges: [r0] },
     { definition: "(method) interface2.doStuff(): void", ranges: [r1] },
     { definition: "(method) class1.doStuff(): void", ranges: [r2, r3] }
diff --git a/tests/cases/fourslash/referencesForInheritedProperties2.ts b/tests/cases/fourslash/referencesForInheritedProperties2.ts
@@ -28,12 +28,7 @@
 
 const ranges = test.ranges();
 const [r0, r1, r2, r3] = ranges;
-verify.referenceGroups(r0, [{ definition: "(method) interface1.doStuff(): void", ranges }]);
-verify.referenceGroups(r1, [
-    { definition: "(method) interface1.doStuff(): void", ranges: [r0] },
-    { definition: "(method) interface2.doStuff(): void", ranges: [r1, r2, r3] }
-]);
-verify.referenceGroups([r2, r3], [
+verify.referenceGroups(ranges, [
     { definition: "(method) interface1.doStuff(): void", ranges: [r0] },
     { definition: "(method) interface2.doStuff(): void", ranges: [r1] },
     { definition: "(method) class1.doStuff(): void", ranges: [r2, r3] }
diff --git a/tests/cases/fourslash/referencesForInheritedProperties5.ts b/tests/cases/fourslash/referencesForInheritedProperties5.ts
@@ -14,15 +14,16 @@
 //// v.[|doStuff|]();
 
 const ranges = test.rangesByText();
-const [m0, m1, m2] = ranges.get("doStuff");
-const [p0, p1, p2] = ranges.get("propName");
-verify.referenceGroups([m0, m2], [{ definition: "(method) interface1.doStuff(): void", ranges: [m0, m1, m2] }]);
-verify.referenceGroups(m1, [
+const methods = ranges.get("doStuff");
+const [m0, m1, m2] = methods;
+verify.referenceGroups(methods, [
     { definition: "(method) interface1.doStuff(): void", ranges: [m0, m2] },
     { definition: "(method) interface2.doStuff(): void", ranges: [m1] }
 ]);
-verify.referenceGroups([p0, p2], [{ definition: "(property) interface1.propName: string", ranges: [p0, p1, p2] }]);
-verify.referenceGroups(p1, [
+
+const props = ranges.get("propName");
+const [p0, p1, p2] = props;
+verify.referenceGroups(props, [
     { definition: "(property) interface1.propName: string", ranges: [p0, p2] },
     { definition: "(property) interface2.propName: string", ranges: [p1] }
 ]);
diff --git a/tests/cases/fourslash/referencesForInheritedProperties6.ts b/tests/cases/fourslash/referencesForInheritedProperties6.ts
diff --git a/tests/cases/fourslash/referencesForInheritedProperties7.ts b/tests/cases/fourslash/referencesForInheritedProperties7.ts
diff --git a/tests/cases/fourslash/referencesForOverrides.ts b/tests/cases/fourslash/referencesForOverrides.ts
diff --git a/tests/cases/fourslash/referencesForUnionProperties.ts b/tests/cases/fourslash/referencesForUnionProperties.ts
