Merge pull request github#3797 from hvitved/csharp/dataflow/more-collection-tests

C#: More data-flow collection tests

Author: calumgrant

csharp/ql/test/library-tests/dataflow/collections/CollectionFlow.cs

@@ -7,6 +7,8 @@ public class CollectionFlow
 {
     public class A { }
 
+    public A[] As;
+
     public void ArrayInitializerFlow()
     {
         var a = new A();
@@ -25,6 +27,24 @@ public void ArrayInitializerNoFlow(A other)
         Sink(First(@as)); // no flow
     }
 
+    public void ArrayInitializerCSharp6Flow()
+    {
+        var a = new A();
+        var c = new CollectionFlow() { As = { [0] = a } };
+        Sink(c.As[0]); // flow [MISSING]
+        SinkElem(c.As); // flow [MISSING]
+        Sink(First(c.As)); // flow [MISSING]
+    }
+
+    public void ArrayInitializerCSharp6NoFlow(A other)
+    {
+        var a = new A();
+        var c = new CollectionFlow() { As = { [0] = other } };
+        Sink(c.As[0]); // no flow
+        SinkElem(c.As); // no flow
+        Sink(First(c.As)); // no flow
+    }
+
     public void ArrayAssignmentFlow()
     {
         var a = new A();
@@ -144,6 +164,28 @@ public void DictionaryValueInitializerNoFlow(A other)
         Sink(DictValuesFirst(dict)); // no flow
     }
 
+    public void DictionaryValueInitializerCSharp6Flow()
+    {
+        var a = new A();
+        var dict = new Dictionary<int, A>() { [0] = a };
+        Sink(dict[0]); // flow [MISSING]
+        SinkDictValue(dict); // flow [MISSING]
+        Sink(DictIndexZero(dict)); // flow [MISSING]
+        Sink(DictFirstValue(dict)); // flow [MISSING]
+        Sink(DictValuesFirst(dict)); // flow [MISSING]
+    }
+
+    public void DictionaryValueInitializerCSharp6NoFlow(A other)
+    {
+        var a = new A();
+        var dict = new Dictionary<int, A>() { [0] = other };
+        Sink(dict[0]); // no flow
+        SinkDictValue(dict); // no flow
+        Sink(DictIndexZero(dict)); // no flow
+        Sink(DictFirstValue(dict)); // no flow
+        Sink(DictValuesFirst(dict)); // no flow
+    }
+
     public void DictionaryKeyInitializerFlow()
     {
         var a = new A();
@@ -163,6 +205,25 @@ public void DictionaryKeyInitializerNoFlow(A other)
         Sink(DictFirstKey(dict)); // no flow
     }
 
+    public void DictionaryKeyInitializerCSharp6Flow()
+    {
+        var a = new A();
+        var dict = new Dictionary<A, int>() { [a] = 0 };
+        Sink(dict.Keys.First()); // flow [MISSING]
+        SinkDictKey(dict); // flow [MISSING]
+        Sink(DictKeysFirst(dict)); // flow [MISSING]
+        Sink(DictFirstKey(dict)); // flow [MISSING]
+    }
+
+    public void DictionaryKeyInitializerCSharp6NoFlow(A other)
+    {
+        var dict = new Dictionary<A, int>() { [other] = 0 };
+        Sink(dict.Keys.First()); // no flow
+        SinkDictKey(dict); // no flow
+        Sink(DictKeysFirst(dict)); // no flow
+        Sink(DictFirstKey(dict)); // no flow
+    }
+
     public void ForeachFlow()
     {
         var a = new A();
@@ -205,6 +266,98 @@ public void ListGetEnumeratorFlow()
             Sink(enumerator.Current); // flow [MISSING]
     }
 
+    public void ListGetEnumeratorNoFlow(A other)
+    {
+        var list = new List<A>();
+        list.Add(other);
+        var enumerator = list.GetEnumerator();
+        while (enumerator.MoveNext())
+            Sink(enumerator.Current); // no flow
+    }
+
+    public void SelectFlow()
+    {
+        var a = new A();
+        var list = new List<KeyValuePair<A, int>>();
+        list.Add(new KeyValuePair<A, int>(a, 0));
+        list.Select(kvp =>
+        {
+            Sink(kvp.Key); // flow
+            return kvp.Value;
+        });
+    }
+
+    public void SelectNoFlow()
+    {
+        var a = new A();
+        var list = new List<KeyValuePair<A, int>>();
+        list.Add(new KeyValuePair<A, int>(a, 0));
+        list.Select(kvp =>
+        {
+            Sink(kvp.Value); // no flow
+            return kvp.Value;
+        });
+    }
+
+    void SetArray(A[] array, A element) => array[0] = element;
+
+    public void ArraySetterFlow()
+    {
+        var a = new A();
+        var @as = new A[1];
+        SetArray(@as, a);
+        Sink(@as[0]); // flow [MISSING]
+        SinkElem(@as); // flow [MISSING]
+        Sink(First(@as)); // flow [MISSING]
+    }
+
+    public void ArraySetterNoFlow(A other)
+    {
+        var a = new A();
+        var @as = new A[1];
+        SetArray(@as, other);
+        Sink(@as[0]); // no flow
+        SinkElem(@as); // no flow
+        Sink(First(@as)); // no flow
+    }
+
+    void SetList(List<A> list, A element) => list.Add(element);
+
+    public void ListSetterFlow()
+    {
+        var a = new A();
+        var list = new List<A>();
+        SetList(list, a);
+        Sink(list[0]); // flow
+        SinkListElem(list); // flow
+        Sink(ListFirst(list)); // flow
+    }
+
+    public void ListSetterNoFlow(A other)
+    {
+        var list = new List<A>();
+        SetList(list, other);
+        Sink(list[0]); // no flow
+        SinkListElem(list); // no flow
+        Sink(ListFirst(list)); // no flow
+    }
+
+    public void ParamsFlow()
+    {
+        SinkParams(new A()); // flow [MISSING]
+        SinkParams(null, new A()); // flow [MISSING]
+        SinkParams(null, new A(), null); // flow [MISSING]
+        SinkParams(new A[] { new A() }); // flow
+    }
+
+    public void ParamsNoFlow(A other)
+    {
+        SinkParams(other); // no flow
+        SinkParams(null, other); // no flow
+        SinkParams(null, other, null); // no flow
+        SinkParams(new A[] { other }); // no flow
+    }
+
     public static void Sink<T>(T t) { }
 
     public static void SinkElem<T>(T[] ts) => Sink(ts[0]);
@@ -228,4 +381,6 @@ public static void Sink<T>(T t) { }
     public static T DictKeysFirst<T>(IDictionary<T, int> dict) => dict.Keys.First();
 
     public static T DictFirstKey<T>(IDictionary<T, int> dict) => dict.First().Key;
+
+    public static void SinkParams<T>(params T[] args) => Sink(args[0]);
 }