FIXUP of range and modulus analysis.

Author: michaelnebel

csharp/ql/lib/semmle/code/csharp/dataflow/internal/rangeanalysis/ModulusAnalysisSpecific.qll

@@ -20,17 +20,17 @@ module Private {
 
   class ConditionalExpr = RU::ExprNode::ConditionalExpr;
 
-  class AddExpr = RU::ExprNode::AddExpr;
+  class AddExpr = RU::ExprNode::AddOperation;
 
-  class SubExpr = RU::ExprNode::SubExpr;
+  class SubExpr = RU::ExprNode::SubOperation;
 
-  class RemExpr = RU::ExprNode::RemExpr;
+  class RemExpr = RU::ExprNode::RemOperation;
 
-  class BitwiseAndExpr = RU::ExprNode::BitwiseAndExpr;
+  class BitwiseAndExpr = RU::ExprNode::BitwiseAndOperation;
 
-  class MulExpr = RU::ExprNode::MulExpr;
+  class MulExpr = RU::ExprNode::MulOperation;
 
-  class LeftShiftExpr = RU::ExprNode::LeftShiftExpr;
+  class LeftShiftExpr = RU::ExprNode::LeftShiftOperation;
 
   predicate guardControlsSsaRead = RU::guardControlsSsaRead/3;
 

csharp/ql/lib/semmle/code/csharp/dataflow/internal/rangeanalysis/RangeUtils.qll

@@ -52,15 +52,15 @@ private module Impl {
     e2.(ExprNode::PreDecrExpr).getOperand() = e1 and delta = -1
     or
     exists(ConstantIntegerExpr x |
-      e2.(ExprNode::AddExpr).getAnOperand() = e1 and
-      e2.(ExprNode::AddExpr).getAnOperand() = x and
+      e2.(ExprNode::AddOperation).getAnOperand() = e1 and
+      e2.(ExprNode::AddOperation).getAnOperand() = x and
       e1 != x and
       x.getIntValue() = delta
     )
     or
     exists(ConstantIntegerExpr x |
-      e2.(ExprNode::SubExpr).getLeftOperand() = e1 and
-      e2.(ExprNode::SubExpr).getRightOperand() = x and
+      e2.(ExprNode::SubOperation).getLeftOperand() = e1 and
+      e2.(ExprNode::SubOperation).getRightOperand() = x and
       x.getIntValue() = -delta
     )
     or
@@ -318,168 +318,80 @@ module ExprNode {
   }
 
   /** An addition operation. */
-  abstract private class AddExprImpl extends BinaryOperation {
-    override TAddOp getOp() { any() }
-  }
-
-  final class AddExpr = AddExprImpl;
-
-  private class AddAddExpr extends AddExprImpl {
-    override CS::AddExpr e;
-  }
+  class AddOperation extends BinaryOperation {
+    override CS::AddOperation e;
 
-  private class AddAssignAddExpr extends AddExprImpl, AssignOperation {
-    override CS::AssignAddExpr e;
+    override TAddOp getOp() { any() }
   }
 
   /** A subtraction operation. */
-  abstract private class SubExprImpl extends BinaryOperation {
-    override TSubOp getOp() { any() }
-  }
-
-  final class SubExpr = SubExprImpl;
+  class SubOperation extends BinaryOperation {
+    override CS::SubOperation e;
 
-  private class AddSubExpr extends SubExprImpl {
-    override CS::SubExpr e;
-  }
-
-  private class AddAssignSubExpr extends SubExprImpl, AssignOperation {
-    override CS::AssignSubExpr e;
+    override TSubOp getOp() { any() }
   }
 
   /** A multiplication operation. */
-  abstract private class MulExprImpl extends BinaryOperation {
-    override TMulOp getOp() { any() }
-  }
-
-  final class MulExpr = MulExprImpl;
-
-  private class AddMulExpr extends MulExprImpl {
-    override CS::MulExpr e;
-  }
+  class MulOperation extends BinaryOperation {
+    override CS::MulOperation e;
 
-  private class AddAssignMulExpr extends MulExprImpl, AssignOperation {
-    override CS::AssignMulExpr e;
+    override TMulOp getOp() { any() }
   }
 
   /** A division operation. */
-  abstract private class DivExprImpl extends BinaryOperation {
-    override TDivOp getOp() { any() }
-  }
-
-  final class DivExpr = DivExprImpl;
+  class DivOperation extends BinaryOperation {
+    override CS::DivOperation e;
 
-  private class AddDivExpr extends DivExprImpl {
-    override CS::DivExpr e;
-  }
-
-  private class AddAssignDivExpr extends DivExprImpl, AssignOperation {
-    override CS::AssignDivExpr e;
+    override TDivOp getOp() { any() }
   }
 
   /** A remainder operation. */
-  abstract private class RemExprImpl extends BinaryOperation {
-    override TRemOp getOp() { any() }
-  }
-
-  final class RemExpr = RemExprImpl;
-
-  private class AddRemExpr extends RemExprImpl {
-    override CS::RemExpr e;
-  }
+  class RemOperation extends BinaryOperation {
+    override CS::RemOperation e;
 
-  private class AddAssignRemExpr extends RemExprImpl, AssignOperation {
-    override CS::AssignRemExpr e;
+    override TRemOp getOp() { any() }
   }
 
   /** A bitwise-and operation. */
-  abstract private class BitwiseAndExprImpl extends BinaryOperation {
-    override TBitAndOp getOp() { any() }
-  }
-
-  final class BitwiseAndExpr = BitwiseAndExprImpl;
+  class BitwiseAndOperation extends BinaryOperation {
+    override CS::BitwiseAndOperation e;
 
-  private class AddBitwiseAndExpr extends BitwiseAndExprImpl {
-    override CS::BitwiseAndExpr e;
-  }
-
-  private class AddAssignAndExpr extends BitwiseAndExprImpl, AssignOperation {
-    override CS::AssignAndExpr e;
+    override TBitAndOp getOp() { any() }
   }
 
   /** A bitwise-or operation. */
-  abstract private class BitwiseOrExprImpl extends BinaryOperation {
-    override TBitOrOp getOp() { any() }
-  }
+  class BitwiseOrOperation extends BinaryOperation {
+    override CS::BitwiseOrOperation e;
 
-  final class BitwiseOrExpr = BitwiseOrExprImpl;
-
-  private class AddBitwiseOrExpr extends BitwiseOrExprImpl {
-    override CS::BitwiseOrExpr e;
-  }
-
-  private class AddAssignOrExpr extends BitwiseOrExprImpl, AssignOperation {
-    override CS::AssignOrExpr e;
+    override TBitOrOp getOp() { any() }
   }
 
   /** A bitwise-xor operation. */
-  abstract private class BitwiseXorExprImpl extends BinaryOperation {
-    override TBitXorOp getOp() { any() }
-  }
-
-  final class BitwiseXorExpr = BitwiseXorExprImpl;
-
-  private class AddBitwiseXorExpr extends BitwiseXorExprImpl {
-    override CS::BitwiseXorExpr e;
-  }
+  class BitwiseXorOperation extends BinaryOperation {
+    override CS::BitwiseXorOperation e;
 
-  private class AddAssignXorExpr extends BitwiseXorExprImpl, AssignOperation {
-    override CS::AssignXorExpr e;
+    override TBitXorOp getOp() { any() }
   }
 
   /** A left-shift operation. */
-  abstract private class LeftShiftExprImpl extends BinaryOperation {
-    override TLeftShiftOp getOp() { any() }
-  }
+  class LeftShiftOperation extends BinaryOperation {
+    override CS::LeftShiftOperation e;
 
-  final class LeftShiftExpr = LeftShiftExprImpl;
-
-  private class AddLeftShiftExpr extends LeftShiftExprImpl {
-    override CS::LeftShiftExpr e;
-  }
-
-  private class AddAssignLeftShiftExpr extends LeftShiftExprImpl, AssignOperation {
-    override CS::AssignLeftShiftExpr e;
+    override TLeftShiftOp getOp() { any() }
   }
 
   /** A right-shift operation. */
-  abstract private class RightShiftExprImpl extends BinaryOperation {
-    override TRightShiftOp getOp() { any() }
-  }
-
-  final class RightShiftExpr = RightShiftExprImpl;
-
-  private class AddRightShiftExpr extends RightShiftExprImpl {
-    override CS::RightShiftExpr e;
-  }
+  class RightShiftOperation extends BinaryOperation {
+    override CS::RightShiftOperation e;
 
-  private class AddAssignRightShiftExpr extends RightShiftExprImpl, AssignOperation {
-    override CS::AssignRightShiftExpr e;
+    override TRightShiftOp getOp() { any() }
   }
 
   /** An unsigned right-shift operation. */
-  abstract private class UnsignedRightShiftExprImpl extends BinaryOperation {
-    override TUnsignedRightShiftOp getOp() { any() }
-  }
+  class UnsignedRightShiftOperation extends BinaryOperation {
+    override CS::UnsignedRightShiftOperation e;
 
-  final class UnsignedRightShiftExpr = UnsignedRightShiftExprImpl;
-
-  private class AddUnsignedRightShiftExpr extends UnsignedRightShiftExprImpl {
-    override CS::UnsignedRightShiftExpr e;
-  }
-
-  private class AddAssignUnsignedRightShiftExpr extends UnsignedRightShiftExprImpl, AssignOperation {
-    override CS::AssignUnsighedRightShiftExpr e;
+    override TUnsignedRightShiftOp getOp() { any() }
   }
 
   /** A conditional expression. */

csharp/ql/lib/semmle/code/csharp/dataflow/internal/rangeanalysis/SignAnalysisSpecific.qll

@@ -41,7 +41,7 @@ module Private {
 
   class RealLiteral = RU::ExprNode::RealLiteral;
 
-  class DivExpr = RU::ExprNode::DivExpr;
+  class DivExpr = RU::ExprNode::DivOperation;
 
   class UnaryOperation = RU::ExprNode::UnaryOperation;
 

csharp/ql/lib/semmle/code/csharp/dataflow/internal/rangeanalysis/SsaUtils.qll

@@ -29,7 +29,7 @@ ExprNode getAnExplicitDefinitionRead(ExprNode src) {
 ExprNode ssaRead(Definition v, int delta) {
   exists(v.getAReadAtNode(result)) and delta = 0
   or
-  exists(ExprNode::AddExpr add, int d1, ConstantIntegerExpr c |
+  exists(ExprNode::AddOperation add, int d1, ConstantIntegerExpr c |
     result = add and
     delta = d1 - c.getIntValue()
   |
@@ -38,7 +38,7 @@ ExprNode ssaRead(Definition v, int delta) {
     add.getRightOperand() = ssaRead(v, d1) and add.getLeftOperand() = c
   )
   or
-  exists(ExprNode::SubExpr sub, int d1, ConstantIntegerExpr c |
+  exists(ExprNode::SubOperation sub, int d1, ConstantIntegerExpr c |
     result = sub and
     sub.getLeftOperand() = ssaRead(v, d1) and
     sub.getRightOperand() = c and