C#: Improve CFG for assignments

Write accesses in assignments, such as the access to `x` in `x = 0` are not
evaluated, so they should not have entries in the control flow graph. However,
qualifiers (and indexer arguments) should still be evaluated, for example in

```
x.Foo.Bar = 0;
```

the CFG should be `x --> x.Foo --> 0 --> x.Foo.Bar = 0` (as opposed to
`x --> x.Foo --> x.Foo.Bar --> 0 --> x.Foo.Bar = 0`, prior to this change).

A special case is assignments via acessors (properties, indexers, and event
adders), where we do want to include the access in the control flow graph,
as it represents the accessor call:

```
x.Prop = 0;
```

But instead of `x --> x.set_Prop --> 0 --> x.Prop = 0` the CFG should be
`x --> 0 --> x.set_Prop --> x.Prop = 0`, as the setter is called *after* the
assigned value has been evaluated.

An even more special case is tuple assignments via accessors:

```
(x.Prop1, y.Prop2) = (0, 1);
```

Here the CFG should be
`x --> y --> 0 --> 1 --> x.set_Prop1 --> y.set_Prop2 --> (x.Prop1, y.Prop2) = (0, 1)`.

Author: hvitved

csharp/ql/src/semmle/code/csharp/Assignable.qll

@@ -601,20 +601,19 @@ module AssignableDefinitions {
     /** Gets the underlying call. */
     Call getCall() { result.getAnArgument() = aa }
 
+    private int getPosition() { aa = this.getCall().getArgument(result) }
+
     /**
      * Gets the index of this definition among the other definitions in the
      * `out`/`ref` assignment. For example, in `M(out x, ref y)` the index of
      * the definitions of `x` and `y` are 0 and 1, respectively.
      */
     int getIndex() {
-      exists(ControlFlow::BasicBlock bb, int i | bb.getNode(i).getElement() = aa |
-        i = rank[result + 1](int j, OutRefDefinition def |
-            bb.getNode(j).getElement() = def.getTargetAccess() and
-            this.getCall() = def.getCall()
-          |
-            j
-          )
-      )
+      this = rank[result + 1](OutRefDefinition def |
+          def.getCall() = this.getCall()
+        |
+          def order by def.getPosition()
+        )
     }
 
     override predicate isCertain() { not isUncertainRefCall(this.getTargetAccess()) }