Fixup of range and modulus analysis.

Author: michaelnebel

csharp/ql/lib/semmle/code/csharp/dataflow/ModulusAnalysis.qll

@@ -28,7 +28,7 @@ private predicate valueFlowStepSsa(SsaVariable v, SsaReadPosition pos, Expr e, i
  * `ConstantIntegerExpr`s.
  */
 private predicate nonConstAddition(Expr add, Expr larg, Expr rarg) {
-  exists(AddExpr a | a = add |
+  exists(AddOperation a | a = add |
     larg = a.getLhs() and
     rarg = a.getRhs()
   ) and
@@ -41,7 +41,7 @@ private predicate nonConstAddition(Expr add, Expr larg, Expr rarg) {
  * a `ConstantIntegerExpr`.
  */
 private predicate nonConstSubtraction(Expr sub, Expr larg, Expr rarg) {
-  exists(SubExpr s | s = sub |
+  exists(SubOperation s | s = sub |
     larg = s.getLhs() and
     rarg = s.getRhs()
   ) and
@@ -50,7 +50,7 @@ private predicate nonConstSubtraction(Expr sub, Expr larg, Expr rarg) {
 
 /** Gets an expression that is the remainder modulo `mod` of `arg`. */
 private Expr modExpr(Expr arg, int mod) {
-  exists(RemExpr rem |
+  exists(RemOperation rem |
     result = rem and
     arg = rem.getLeftOperand() and
     rem.getRightOperand().(ConstantIntegerExpr).getIntValue() = mod and
@@ -60,7 +60,7 @@ private Expr modExpr(Expr arg, int mod) {
   exists(ConstantIntegerExpr c |
     mod = 2.pow([1 .. 30]) and
     c.getIntValue() = mod - 1 and
-    result.(BitwiseAndExpr).hasOperands(arg, c)
+    result.(BitwiseAndOperation).hasOperands(arg, c)
   )
 }
 
@@ -105,11 +105,11 @@ private predicate andmaskFactor(int mask, int factor) {
 /** Holds if `e` is evenly divisible by `factor`. */
 private predicate evenlyDivisibleExpr(Expr e, int factor) {
   exists(ConstantIntegerExpr c, int k | k = c.getIntValue() |
-    e.(MulExpr).getAnOperand() = c and factor = k.abs() and factor >= 2
+    e.(MulOperation).getAnOperand() = c and factor = k.abs() and factor >= 2
     or
-    e.(LeftShiftExpr).getRhs() = c and factor = 2.pow(k) and k > 0
+    e.(LeftShiftOperation).getRhs() = c and factor = 2.pow(k) and k > 0
     or
-    e.(BitwiseAndExpr).getAnOperand() = c and factor = max(int f | andmaskFactor(k, f))
+    e.(BitwiseAndOperation).getAnOperand() = c and factor = max(int f | andmaskFactor(k, f))
   )
 }
 

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 AddOperation = RU::ExprNode::AddOperation;
 
-  class SubExpr = RU::ExprNode::SubExpr;
+  class SubOperation = RU::ExprNode::SubOperation;
 
-  class RemExpr = RU::ExprNode::RemExpr;
+  class RemOperation = RU::ExprNode::RemOperation;
 
-  class BitwiseAndExpr = RU::ExprNode::BitwiseAndExpr;
+  class BitwiseAndOperation = RU::ExprNode::BitwiseAndOperation;
 
-  class MulExpr = RU::ExprNode::MulExpr;
+  class MulOperation = RU::ExprNode::MulOperation;
 
-  class LeftShiftExpr = RU::ExprNode::LeftShiftExpr;
+  class LeftShiftOperation = RU::ExprNode::LeftShiftOperation;
 
   predicate guardControlsSsaRead = RU::guardControlsSsaRead/3;
 

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

@@ -64,15 +64,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
@@ -330,168 +330,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/SignAnalysisCommon.qll

@@ -316,7 +316,7 @@ Sign exprSign(Expr e) {
 private Sign specificSubExprSign(Expr e) {
   result = exprSign(getASubExprWithSameSign(e))
   or
-  exists(DivExpr div | div = e |
+  exists(DivOperation div | div = e |
     result = exprSign(div.getLeftOperand()) and
     result != TZero() and
     div.getRightOperand().(RealLiteral).getValue().toFloat() = 0

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 DivOperation = 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