Add Find References unit tests for ContainingTypeInfo and ContainingMemberInfo custom columns

Builds on #44240 to add FAR tests for more custom columns

src/EditorFeatures/Test2/FindReferences/FindReferencesTests.FieldSymbols.vb

@@ -446,6 +446,68 @@ class Definition:Program
         }
         </Document>
     </Project>
+</Workspace>
+            Await TestAPIAndFeature(input, kind, host)
+        End Function
+
+        <WpfTheory, CombinatorialData, Trait(Traits.Feature, Traits.Features.FindReferences)>
+        Public Async Function TestField_ContainingTypeInfo(kind As TestKind, host As TestHost) As Task
+            Dim input =
+<Workspace>
+    <Project Language="C#" CommonReferences="true">
+        <Document>
+        class C
+        {
+            int {|Definition:$$i|};
+
+            int P
+            {
+                get
+                {
+                    return {|AdditionalProperty.ContainingTypeInfo.C:[|i|]|}
+                }
+            }
+
+            int P2 => {|AdditionalProperty.ContainingTypeInfo.C:[|i|]|}
+
+            void Goo()
+            {
+                Console.WriteLine({|AdditionalProperty.ContainingTypeInfo.C:[|i|]|});
+            }
+        }
+        </Document>
+    </Project>
+</Workspace>
+            Await TestAPIAndFeature(input, kind, host)
+        End Function
+
+        <WpfTheory, CombinatorialData, Trait(Traits.Feature, Traits.Features.FindReferences)>
+        Public Async Function TestField_ContainingMemberInfo(kind As TestKind, host As TestHost) As Task
+            Dim input =
+<Workspace>
+    <Project Language="C#" CommonReferences="true">
+        <Document>
+        class C
+        {
+            int {|Definition:$$i|};
+
+            int P
+            {
+                get
+                {
+                    return {|AdditionalProperty.ContainingMemberInfo.P:[|i|]|}
+                }
+            }
+
+            int P2 => {|AdditionalProperty.ContainingMemberInfo.P2:[|i|]|}
+
+            void Goo()
+            {
+                Console.WriteLine({|AdditionalProperty.ContainingMemberInfo.Goo:[|i|]|});
+            }
+        }
+        </Document>
+    </Project>
 </Workspace>
             Await TestAPIAndFeature(input, kind, host)
         End Function

src/EditorFeatures/Test2/FindReferences/FindReferencesTests.NamedTypeSymbols.vb

@@ -2189,8 +2189,6 @@ public class D { }
 
         End Function
 
-
-
         <WpfTheory, CombinatorialData, Trait(Traits.Feature, Traits.Features.FindReferences)>
         Public Async Function TestNamedType_TypeOrNamespaceUsageInfo(kind As TestKind, host As TestHost) As Task
             Dim input =
@@ -2224,7 +2222,91 @@ public class D { }
 
             public class Class3: {|TypeOrNamespaceUsageInfo.Qualified,Base:[|Class1|]|}.Nested, I<{|TypeOrNamespaceUsageInfo.Qualified,TypeArgument:[|Class1|]|}.Nested>
             {
-                public static [|Class1|] M2() => new {|TypeOrNamespaceUsageInfo.ObjectCreation:[|Class1|]|}();
+                public static {|TypeOrNamespaceUsageInfo.None:[|Class1|]|} M2() => new {|TypeOrNamespaceUsageInfo.ObjectCreation:[|Class1|]|}();
+            }
+        }]]>
+        </Document>
+    </Project>
+</Workspace>
+            Await TestAPIAndFeature(input, kind, host)
+        End Function
+
+        <WpfTheory, CombinatorialData, Trait(Traits.Feature, Traits.Features.FindReferences)>
+        Public Async Function TestNamedType_ContainingTypeInfo(kind As TestKind, host As TestHost) As Task
+            Dim input =
+<Workspace>
+    <Project Language="C#" CommonReferences="true">
+        <Document><![CDATA[
+        namespace N1
+        {
+            using Alias1 = N2.{|AdditionalProperty.ContainingTypeInfo.:[|Class1|]|};
+        }
+
+        namespace N2
+        {
+            public interface I<T> { }
+
+            public class {|Definition:$$Class1|}
+            {
+                public static int Field;
+                public class Nested { }
+            }
+
+            public class Class2 : {|AdditionalProperty.ContainingTypeInfo.Class2:[|Class1|]|}, I<{|AdditionalProperty.ContainingTypeInfo.Class2:[|Class1|]|}>
+            {
+                public static int M() => {|AdditionalProperty.ContainingTypeInfo.Class2:[|Class1|]|}.Field;
+            }
+        }
+
+        namespace N2.N3
+        {
+            using Alias2 = N2.{|AdditionalProperty.ContainingTypeInfo.:[|Class1|]|}.Nested;
+
+            public class Class3: {|AdditionalProperty.ContainingTypeInfo.Class3:[|Class1|]|}.Nested, I<{|AdditionalProperty.ContainingTypeInfo.Class3:[|Class1|]|}.Nested>
+            {
+                public static {|AdditionalProperty.ContainingTypeInfo.Class3:[|Class1|]|} M2() => new {|AdditionalProperty.ContainingTypeInfo.Class3:[|Class1|]|}();
+            }
+        }]]>
+        </Document>
+    </Project>
+</Workspace>
+            Await TestAPIAndFeature(input, kind, host)
+        End Function
+
+        <WpfTheory, CombinatorialData, Trait(Traits.Feature, Traits.Features.FindReferences)>
+        Public Async Function TestNamedType_ContainingMemberInfo(kind As TestKind, host As TestHost) As Task
+            Dim input =
+<Workspace>
+    <Project Language="C#" CommonReferences="true">
+        <Document><![CDATA[
+        namespace N1
+        {
+            using Alias1 = N2.{|AdditionalProperty.ContainingMemberInfo.N1:[|Class1|]|};
+        }
+
+        namespace N2
+        {
+            public interface I<T> { }
+
+            public class {|Definition:$$Class1|}
+            {
+                public static int Field;
+                public class Nested { }
+            }
+
+            public class Class2 : {|AdditionalProperty.ContainingMemberInfo.Class2:[|Class1|]|}, I<{|AdditionalProperty.ContainingMemberInfo.Class2:[|Class1|]|}>
+            {
+                public static int M() => {|AdditionalProperty.ContainingMemberInfo.M:[|Class1|]|}.Field;
+            }
+        }
+
+        namespace N2.N3
+        {
+            using Alias2 = N2.{|AdditionalProperty.ContainingMemberInfo.N3:[|Class1|]|}.Nested;
+
+            public class Class3: {|AdditionalProperty.ContainingMemberInfo.Class3:[|Class1|]|}.Nested, I<{|AdditionalProperty.ContainingMemberInfo.Class3:[|Class1|]|}.Nested>
+            {
+                public static {|AdditionalProperty.ContainingMemberInfo.M2:[|Class1|]|} M2() => new {|AdditionalProperty.ContainingMemberInfo.M2:[|Class1|]|}();
             }
         }]]>
         </Document>

src/EditorFeatures/Test2/FindReferences/FindReferencesTests.vb

@@ -21,6 +21,7 @@ Namespace Microsoft.CodeAnalysis.Editor.UnitTests.FindReferences
         Private Const DefinitionKey As String = "Definition"
         Private Const ValueUsageInfoKey As String = "ValueUsageInfo."
         Private Const TypeOrNamespaceUsageInfoKey As String = "TypeOrNamespaceUsageInfo."
+        Private Const AdditionalPropertyKey As String = "AdditionalProperty."
 
         Private ReadOnly _outputHelper As ITestOutputHelper
 
@@ -129,10 +130,53 @@ Namespace Microsoft.CodeAnalysis.Editor.UnitTests.FindReferences
 
                         Assert.Equal(expected, actual)
                     Next
+
+                    Dim additionalPropertiesMap = GetExpectedAdditionalPropertiesMap(workspace)
+                    For Each kvp In additionalPropertiesMap
+                        Dim propertyName = kvp.Key
+                        For Each propertyValue In kvp.Value
+                            Dim annotationKey = AdditionalPropertyKey + propertyName + "." + propertyValue
+                            Dim expected =
+                                workspace.Documents.Where(Function(d) d.AnnotatedSpans.ContainsKey(annotationKey) AndAlso d.AnnotatedSpans(annotationKey).Any()).
+                                                OrderBy(Function(d) d.Name).
+                                                Select(Function(d) New FileNameAndSpans(
+                                                       d.Name, d.AnnotatedSpans(annotationKey).ToList())).ToList()
+                            Dim actual = GetFileNamesAndSpans(
+                                context.References.Where(Function(r)
+                                                             Dim actualValue As String = Nothing
+                                                             If r.AdditionalProperties.TryGetValue(propertyName, actualValue) Then
+                                                                 Return actualValue = propertyValue
+                                                             End If
+
+                                                             Return propertyValue.Length = 0
+                                                         End Function).Select(Function(r) r.SourceSpan))
+
+                            Assert.Equal(expected, actual)
+                        Next
+                    Next
                 Next
             End Using
         End Function
 
+        Private Shared Function GetExpectedAdditionalPropertiesMap(workspace As TestWorkspace) As Dictionary(Of String, HashSet(Of String))
+            Dim additionalPropertyKeys = workspace.Documents.SelectMany(Function(d) d.AnnotatedSpans.Keys.Where(Function(key) key.StartsWith(AdditionalPropertyKey)).Select(Function(key) key.Substring(AdditionalPropertyKey.Length)))
+            Dim additionalPropertiesMap As New Dictionary(Of String, HashSet(Of String))
+            For Each key In additionalPropertyKeys
+                Dim index = key.IndexOf(".")
+                Assert.True(index > 0)
+                Dim propertyName = key.Substring(0, index)
+                Dim propertyValue = key.Substring(index + 1)
+                Dim propertyValues As HashSet(Of String) = Nothing
+                If Not additionalPropertiesMap.TryGetValue(propertyName, propertyValues) Then
+                    propertyValues = New HashSet(Of String)()
+                    additionalPropertiesMap.Add(propertyName, propertyValues)
+                End If
+                propertyValues.Add(propertyValue)
+            Next
+
+            Return additionalPropertiesMap
+        End Function
+
         Private Function GetFileNamesAndSpans(items As IEnumerable(Of DocumentSpan)) As List(Of FileNameAndSpans)
             Return items.Where(Function(i) i.Document IsNot Nothing).
                          GroupBy(Function(i) i.Document).
@@ -314,6 +358,32 @@ Namespace Microsoft.CodeAnalysis.Editor.UnitTests.FindReferences
                             End If
                         Next
                     Next
+
+                    Dim additionalPropertiesMap = GetExpectedAdditionalPropertiesMap(workspace)
+                    For Each kvp In additionalPropertiesMap
+                        Dim propertyName = kvp.Key
+                        For Each propertyValue In kvp.Value
+                            Dim annotationKey = AdditionalPropertyKey + propertyName + "." + propertyValue
+                            For Each doc In documentsWithAnnotatedSpans.Where(Function(d) d.AnnotatedSpans.ContainsKey(annotationKey))
+
+                                Dim expectedSpans = doc.AnnotatedSpans(annotationKey).Order()
+
+                                actualReferences = GetActualReferences(result, uiVisibleOnly, options, document, workspace, Function(r)
+                                                                                                                                Dim actualValue As String = Nothing
+                                                                                                                                If r.AdditionalProperties.TryGetValue(propertyName, actualValue) Then
+                                                                                                                                    Return actualValue = propertyValue
+                                                                                                                                End If
+
+                                                                                                                                Return propertyValue.Length = 0
+                                                                                                                            End Function)
+                                Dim actualSpans = actualReferences(GetFilePathAndProjectLabel(workspace, doc)).Order()
+
+                                If Not TextSpansMatch(expectedSpans, actualSpans) Then
+                                    Assert.True(False, PrintSpans(expectedSpans, actualSpans, workspace.CurrentSolution.GetDocument(doc.Id), $"{{|{annotationKey}:", "|}"))
+                                End If
+                            Next
+                        Next
+                    Next
                 Next
             End Using
         End Function