Swift: Create a custom "AST" version of the public CFG classes. This is

       necessary because the CFG library doesn't support the following
       two requirements simultaneously:
       1. Traverse AST classes by virtual dispatch
       2. Construct ControlFlowElements from non-AST classes

       Because the CFG trees derive from the a base type that must be a
       subtype of `ControlFlowElement`. So if we make `ControlFlowElement`
       an IPA type, we cannot write:
       ```
       class AssignTree extends PostOrderTree instanceof AssignExpr { ... }
       ```
       because `AssignExpr` is not a subtype of PostOrderTree (since
       PostOrderTree is now a subtype of the new IPA type).

       To fix this, Tom suggested the following (which is implemented in
       this PR):
       1. Create a copy of the CFG tree classes (i.e., Pre/PostOrderTree,
          LeafTree, etc.) and call them AstPreOrderTree/AstPostOrderTree,
          AstLeafTree, etc.
       2. For each tree AstTree from step 1, create a instance of the
          internal CFG library's appropriate class.
       3. In `ControlFlowGraphImpl`, proceed as normal with virtual
          dispatch using `instanceof`, but extend the AstTree classes
          from step 1 instead of the CFG's own tree classes.

       This works because each AstTree implements one of the CFG
       library's tree classes (as per step 2).
       This commit performs step 1 and 2. Step 3 will be the next commit.

Author: MathiasVP

swift/ql/lib/codeql/swift/controlflow/internal/AstControlFlowTrees.qll

@@ -0,0 +1,40 @@
+private import swift
+private import Completion
+private import ControlFlowGraphImplShared
+private import ControlFlowElements
+
+abstract class AstControlFlowTree extends ControlFlowTree {
+  AstNode ast;
+
+  AstControlFlowTree() { ast = this.asAstNode() }
+
+  AstNode getAst() { result = ast }
+}
+
+/**
+ * Holds if `first` is the first element executed within control flow
+ * element `cft`.
+ */
+predicate astFirst(AstNode cft, ControlFlowElement first) {
+  first(any(ControlFlowTree tree | cft = tree.asAstNode()), first)
+}
+
+/**
+ * Holds if `last` with completion `c` is a potential last element executed
+ * within control flow element `cft`.
+ */
+predicate astLast(AstNode cft, ControlFlowElement last, Completion c) {
+  last(any(ControlFlowTree tree | cft = tree.asAstNode()), last, c)
+}
+
+abstract class AstPreOrderTree extends AstControlFlowTree, PreOrderTree { }
+
+abstract class AstPostOrderTree extends AstControlFlowTree, PostOrderTree { }
+
+abstract class AstStandardTree extends AstControlFlowTree, StandardTree { }
+
+abstract class AstStandardPreOrderTree extends AstStandardTree, StandardPreOrderTree { }
+
+abstract class AstStandardPostOrderTree extends AstStandardTree, StandardPostOrderTree { }
+
+abstract class AstLeafTree extends AstPreOrderTree, AstPostOrderTree, LeafTree { }