C#: Use shared SuccessorType.

Author: aschackmull

csharp/ql/lib/semmle/code/csharp/Caching.qll

@@ -10,7 +10,6 @@ module Stages {
   cached
   module ControlFlowStage {
     private import semmle.code.csharp.controlflow.internal.Splitting
-    private import semmle.code.csharp.controlflow.internal.SuccessorType
     private import semmle.code.csharp.controlflow.Guards as Guards
 
     cached
@@ -20,8 +19,6 @@ module Stages {
     private predicate forceCachingInSameStageRev() {
       exists(Split s)
       or
-      exists(SuccessorType st)
-      or
       exists(ControlFlow::Node n)
       or
       Guards::Internal::isCustomNullCheck(_, _, _, _)

csharp/ql/lib/semmle/code/csharp/commons/Constants.qll

@@ -6,9 +6,7 @@ private import semmle.code.csharp.commons.StructuralComparison as StructuralComp
 
 pragma[noinline]
 private predicate isConstantCondition0(ControlFlow::Node cfn, boolean b) {
-  exists(
-    cfn.getASuccessorByType(any(ControlFlow::SuccessorTypes::BooleanSuccessor t | t.getValue() = b))
-  ) and
+  exists(cfn.getASuccessorByType(any(ControlFlow::BooleanSuccessor t | t.getValue() = b))) and
   strictcount(ControlFlow::SuccessorType t | exists(cfn.getASuccessorByType(t))) = 1
 }
 

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

@@ -3,7 +3,7 @@
  */
 
 import csharp
-private import ControlFlow::SuccessorTypes
+private import ControlFlow
 private import semmle.code.csharp.controlflow.internal.ControlFlowGraphImpl as CfgImpl
 private import CfgImpl::BasicBlocks as BasicBlocksImpl
 

csharp/ql/lib/semmle/code/csharp/controlflow/ControlFlowElement.qll

@@ -5,7 +5,6 @@ private import semmle.code.csharp.ExprOrStmtParent
 private import semmle.code.csharp.commons.Compilation
 private import ControlFlow
 private import ControlFlow::BasicBlocks
-private import SuccessorTypes
 private import semmle.code.csharp.Caching
 private import internal.ControlFlowGraphImpl as Impl
 

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

@@ -6,7 +6,6 @@ import csharp
 module ControlFlow {
   private import semmle.code.csharp.controlflow.BasicBlocks as BBs
   import semmle.code.csharp.controlflow.internal.SuccessorType
-  private import SuccessorTypes
   private import internal.ControlFlowGraphImpl as Impl
   private import internal.Splitting as Splitting
 

csharp/ql/lib/semmle/code/csharp/controlflow/Guards.qll

@@ -3,7 +3,7 @@
  */
 
 import csharp
-private import ControlFlow::SuccessorTypes
+private import ControlFlow
 private import semmle.code.csharp.commons.Assertions
 private import semmle.code.csharp.commons.ComparisonTest
 private import semmle.code.csharp.commons.StructuralComparison as SC

csharp/ql/lib/semmle/code/csharp/controlflow/internal/Completion.qll

@@ -26,7 +26,6 @@ private import semmle.code.csharp.frameworks.System
 private import ControlFlowGraphImpl
 private import NonReturning
 private import SuccessorType
-private import SuccessorTypes
 
 private newtype TCompletion =
   TSimpleCompletion() or
@@ -575,7 +574,7 @@ abstract private class NonNestedNormalCompletion extends NormalCompletion { }
 
 /** A simple (normal) completion. */
 class SimpleCompletion extends NonNestedNormalCompletion, TSimpleCompletion {
-  override NormalSuccessor getAMatchingSuccessorType() { any() }
+  override DirectSuccessor getAMatchingSuccessorType() { any() }
 
   override string toString() { result = "normal" }
 }
@@ -759,7 +758,7 @@ class NestedCompletion extends Completion, TNestedCompletion {
  *
  * The `break` on line 3 completes with a `TBreakCompletion`, therefore
  * the `while` loop can complete with a `NestedBreakCompletion`, so we
- * get an edge `break --break--> return`. (If we instead used a
+ * get an edge `break --jump--> return`. (If we instead used a
  * `TSimpleCompletion`, we would get a less precise edge
  * `break --normal--> return`.)
  */
@@ -782,7 +781,7 @@ class NestedBreakCompletion extends NormalCompletion, NestedCompletion {
 
   override SuccessorType getAMatchingSuccessorType() {
     outer instanceof SimpleCompletion and
-    result instanceof BreakSuccessor
+    result instanceof JumpSuccessor
     or
     result = outer.(ConditionalCompletion).getAMatchingSuccessorType()
   }
@@ -817,7 +816,7 @@ class BreakCompletion extends Completion {
     this = TNestedCompletion(_, TBreakCompletion(), _)
   }
 
-  override BreakSuccessor getAMatchingSuccessorType() { any() }
+  override JumpSuccessor getAMatchingSuccessorType() { any() }
 
   override string toString() {
     // `NestedCompletion` defines `toString()` for the other case
@@ -836,7 +835,7 @@ class ContinueCompletion extends Completion {
     this = TNestedCompletion(_, TContinueCompletion(), _)
   }
 
-  override ContinueSuccessor getAMatchingSuccessorType() { any() }
+  override JumpSuccessor getAMatchingSuccessorType() { any() }
 
   override string toString() {
     // `NestedCompletion` defines `toString()` for the other case
@@ -859,7 +858,7 @@ class GotoCompletion extends Completion {
   /** Gets the label of the `goto` completion. */
   string getLabel() { result = label }
 
-  override GotoSuccessor getAMatchingSuccessorType() { result.getLabel() = label }
+  override JumpSuccessor getAMatchingSuccessorType() { any() }
 
   override string toString() {
     // `NestedCompletion` defines `toString()` for the other case
@@ -882,7 +881,7 @@ class ThrowCompletion extends Completion {
   /** Gets the type of the exception being thrown. */
   ExceptionClass getExceptionClass() { result = ec }
 
-  override ExceptionSuccessor getAMatchingSuccessorType() { result.getExceptionClass() = ec }
+  override ExceptionSuccessor getAMatchingSuccessorType() { any() }
 
   override string toString() {
     // `NestedCompletion` defines `toString()` for the other case

csharp/ql/lib/semmle/code/csharp/controlflow/internal/ControlFlowGraphImpl.qll

@@ -83,17 +83,13 @@ private module CfgInput implements CfgShared::InputSig<Location> {
 
   SuccessorType getAMatchingSuccessorType(Completion c) { result = c.getAMatchingSuccessorType() }
 
-  predicate successorTypeIsSimple(SuccessorType t) {
-    t instanceof ST::SuccessorTypes::NormalSuccessor
-  }
+  predicate successorTypeIsSimple(SuccessorType t) { t instanceof ST::DirectSuccessor }
 
-  predicate successorTypeIsCondition(SuccessorType t) {
-    t instanceof ST::SuccessorTypes::ConditionalSuccessor
-  }
+  predicate successorTypeIsCondition(SuccessorType t) { t instanceof ST::ConditionalSuccessor }
 
   predicate isAbnormalExitType(SuccessorType t) {
-    t instanceof ST::SuccessorTypes::ExceptionSuccessor or
-    t instanceof ST::SuccessorTypes::ExitSuccessor
+    t instanceof ST::ExceptionSuccessor or
+    t instanceof ST::ExitSuccessor
   }
 
   int idOfAstNode(AstNode node) { result = node.getId() }

csharp/ql/lib/semmle/code/csharp/controlflow/internal/PreBasicBlocks.qll

@@ -119,7 +119,7 @@ class ConditionBlock extends PreBasicBlock {
   }
 
   pragma[nomagic]
-  predicate controls(PreBasicBlock controlled, Cfg::SuccessorTypes::ConditionalSuccessor s) {
+  predicate controls(PreBasicBlock controlled, Cfg::ConditionalSuccessor s) {
     exists(PreBasicBlock succ, ConditionalCompletion c | this.immediatelyControls(succ, c) |
       succ.dominates(controlled) and
       s = c.getAMatchingSuccessorType()

csharp/ql/lib/semmle/code/csharp/controlflow/internal/Splitting.qll

@@ -470,16 +470,18 @@ module FinallySplitting {
    * then the `finally` block must end with a `return` as well (provided that
    * the `finally` block exits normally).
    */
-  class FinallySplitType extends Cfg::SuccessorType {
-    FinallySplitType() { not this instanceof Cfg::SuccessorTypes::ConditionalSuccessor }
+  class FinallySplitType instanceof Cfg::SuccessorType {
+    FinallySplitType() { not this instanceof Cfg::ConditionalSuccessor }
+
+    string toString() { result = super.toString() }
 
     /** Holds if this split type matches entry into a `finally` block with completion `c`. */
     predicate isSplitForEntryCompletion(Completion c) {
       if c instanceof NormalCompletion
       then
         // If the entry into the `finally` block completes with any normal completion,
         // it simply means normal execution after the `finally` block
-        this instanceof Cfg::SuccessorTypes::NormalSuccessor
+        this instanceof Cfg::DirectSuccessor
       else this = c.getAMatchingSuccessorType()
     }
   }
@@ -533,7 +535,7 @@ module FinallySplitting {
     int getNestLevel() { result = nestLevel }
 
     override string toString() {
-      if type instanceof Cfg::SuccessorTypes::NormalSuccessor
+      if type instanceof Cfg::DirectSuccessor
       then result = ""
       else
         if nestLevel > 0
@@ -617,14 +619,14 @@ module FinallySplitting {
             or
             not c instanceof NormalCompletion
             or
-            type instanceof Cfg::SuccessorTypes::NormalSuccessor
+            type instanceof Cfg::DirectSuccessor
           )
         else (
           // Finally block can exit with completion `c` inherited from try/catch
           // block: must match this split
           inherited = true and
           type = c.getAMatchingSuccessorType() and
-          not type instanceof Cfg::SuccessorTypes::NormalSuccessor
+          not type instanceof Cfg::DirectSuccessor
         )
       )
       or
@@ -657,7 +659,7 @@ module FinallySplitting {
       exists(FinallySplit outer |
         outer.getNestLevel() = super.getNestLevel() - 1 and
         outer.(FinallySplitImpl).exit(pred, c, inherited) and
-        super.getType() instanceof Cfg::SuccessorTypes::NormalSuccessor and
+        super.getType() instanceof Cfg::DirectSuccessor and
         inherited = true
       )
     }