C#: Add field initializers to CFG for constructors

This commit adds field initializers to the CFG for non-static constructors. For
example, in

```
class C
{
    int Field1 = 0;
    int Field2 = Field1 + 1;
    int Field3;

    public C()
    {
        Field3 = 2;
    }

    public C(int i)
    {
        Field3 = 3;
    }
}
```

the initializer expressions `Field1 = 0` and `Field2 = Field1 + 1` are added
to the two constructors, mimicking

```
public C()
{
    Field1 = 0;
    Field2 = Field1 + 1;
    Field3 = 2;
}
```

and

```
public C()
{
    Field1 = 0;
    Field2 = Field1 + 1;
    Field3 = 3;
}
```

respectively. This means that we no longer have to synthesize calls, callables,
parameters, and arguments in the data flow library, so much of the work from
d175550 can be simplified.

Author: hvitved

csharp/ql/src/semmle/code/csharp/controlflow/BasicBlocks.qll

@@ -75,7 +75,7 @@ class BasicBlock extends TBasicBlockStart {
   ControlFlow::Node getLastNode() { result = getNode(length() - 1) }
 
   /** Gets the callable that this basic block belongs to. */
-  Callable getCallable() { result = this.getAPredecessor().getCallable() }
+  final Callable getCallable() { result = this.getFirstNode().getEnclosingCallable() }
 
   /** Gets the length of this basic block. */
   int length() { result = strictcount(getANode()) }
@@ -346,8 +346,6 @@ private import Internal
  */
 class EntryBasicBlock extends BasicBlock {
   EntryBasicBlock() { entryBB(this) }
-
-  override Callable getCallable() { result.getEntryPoint() = this.getFirstNode() }
 }
 
 /** Holds if `bb` is an entry basic block. */

csharp/ql/src/semmle/code/csharp/controlflow/ControlFlowGraph.qll

@@ -287,7 +287,11 @@ module ControlFlow {
 
       ElementNode() { this = TElementNode(cfe, splits) }
 
-      override Callable getEnclosingCallable() { result = cfe.getEnclosingCallable() }
+      override Callable getEnclosingCallable() {
+        result = cfe.getEnclosingCallable()
+        or
+        result = this.getASplit().(InitializerSplitting::InitializerSplitImpl).getConstructor()
+      }
 
       override ControlFlowElement getElement() { result = cfe }
 
@@ -1756,6 +1760,22 @@ module ControlFlow {
             result = first(ci.getConstructor().getBody())
           )
         or
+        exists(Constructor con, InitializerSplitting::InitializedInstanceMember m, int i |
+          cfe = last(m.getInitializer(), c) and
+          c instanceof NormalCompletion and
+          InitializerSplitting::constructorInitializeOrder(con, m, i)
+        |
+          // Flow from one member initializer to the next
+          exists(InitializerSplitting::InitializedInstanceMember next |
+            InitializerSplitting::constructorInitializeOrder(con, next, i + 1) and
+            result = first(next.getInitializer())
+          )
+          or
+          // Flow from last member initializer to constructor body
+          m = InitializerSplitting::lastConstructorInitializer(con) and
+          result = first(con.getBody())
+        )
+        or
         // Flow from element with `goto` completion to first element of relevant
         // target
         c = any(GotoCompletion gc |
@@ -1831,11 +1851,18 @@ module ControlFlow {
         p = any(Callable c |
             if exists(c.(Constructor).getInitializer())
             then result = first(c.(Constructor).getInitializer())
-            else result = first(c.getBody())
+            else
+              if InitializerSplitting::constructorInitializes(c, _)
+              then
+                result = first(any(InitializerSplitting::InitializedInstanceMember m |
+                      InitializerSplitting::constructorInitializeOrder(c, m, 0)
+                    ).getInitializer())
+              else result = first(c.getBody())
           )
         or
         expr_parent_top_level_adjusted(any(Expr e | result = first(e)), _, p) and
-        not p instanceof Callable
+        not p instanceof Callable and
+        not p instanceof InitializerSplitting::InitializedInstanceMember
       }
 
       /**
@@ -1845,6 +1872,12 @@ module ControlFlow {
       Callable succExit(ControlFlowElement cfe, Completion c) {
         cfe = last(result.getBody(), c) and
         not c instanceof GotoCompletion
+        or
+        exists(InitializerSplitting::InitializedInstanceMember m |
+          m = InitializerSplitting::lastConstructorInitializer(result) and
+          cfe = last(m.getInitializer(), c) and
+          not result.hasBody()
+        )
       }
     }
     import Successor