Java: Rename UnaryExpr.getExpr to getOperand.

aschackmull · aschackmull · commit 5e6e64b2b762 · 2026-02-04T10:50:49.000+01:00
diff --git a/java/ql/consistency-queries/UnaryExpr.ql b/java/ql/consistency-queries/UnaryExpr.ql
@@ -2,7 +2,7 @@ import java
 
 from UnaryExpr ue
 where
-  not exists(ue.getExpr())
+  not exists(ue.getOperand())
   or
   exists(Expr e, int i | e.isNthChildOf(ue, i) and i != 0)
 select ue
diff --git a/java/ql/lib/semmle/code/java/Constants.qll b/java/ql/lib/semmle/code/java/Constants.qll
@@ -22,7 +22,7 @@ module CalculateConstants<getBoolValSig/1 getBoolVal, getIntValSig/1 getIntVal>
   boolean calculateBooleanValue(Expr e) {
     // No casts relevant to booleans.
     // `!` is the only unary operator that evaluates to a boolean.
-    result = getBoolVal(e.(LogNotExpr).getExpr()).booleanNot()
+    result = getBoolVal(e.(LogNotExpr).getOperand()).booleanNot()
     or
     // Handle binary expressions that have integer operands and a boolean result.
     exists(BinaryExpr b, int left, int right |
@@ -115,11 +115,11 @@ module CalculateConstants<getBoolValSig/1 getBoolVal, getIntValSig/1 getIntVal>
             else result = val
       )
       or
-      result = getIntVal(e.(PlusExpr).getExpr())
+      result = getIntVal(e.(PlusExpr).getOperand())
       or
-      result = -getIntVal(e.(MinusExpr).getExpr())
+      result = -getIntVal(e.(MinusExpr).getOperand())
       or
-      result = getIntVal(e.(BitNotExpr).getExpr()).bitNot()
+      result = getIntVal(e.(BitNotExpr).getOperand()).bitNot()
       or
       // No `int` value for `LogNotExpr`.
       exists(BinaryExpr b, int v1, int v2 |
diff --git a/java/ql/lib/semmle/code/java/ControlFlowGraph.qll b/java/ql/lib/semmle/code/java/ControlFlowGraph.qll
@@ -827,7 +827,7 @@ private module ControlFlowGraphImpl {
         index = 1 and result = e.getRightOperand()
       )
       or
-      index = 0 and result = this.(UnaryExpr).getExpr()
+      index = 0 and result = this.(UnaryExpr).getOperand()
       or
       index = 0 and result = this.(CastingExpr).getExpr()
       or
@@ -1044,7 +1044,7 @@ private module ControlFlowGraphImpl {
     or
     // The last node of a `LogNotExpr` is in its sub-expression with an inverted boolean completion
     // (or a `normalCompletion`).
-    exists(Completion subcompletion | last(n.(LogNotExpr).getExpr(), last, subcompletion) |
+    exists(Completion subcompletion | last(n.(LogNotExpr).getOperand(), last, subcompletion) |
       subcompletion = NormalCompletion() and
       completion = NormalCompletion() and
       not inBooleanContext(n)
@@ -1356,7 +1356,7 @@ private module ControlFlowGraphImpl {
     (
       result = first(n.asExpr().(AndLogicalExpr).getLeftOperand()) or
       result = first(n.asExpr().(OrLogicalExpr).getLeftOperand()) or
-      result = first(n.asExpr().(LogNotExpr).getExpr()) or
+      result = first(n.asExpr().(LogNotExpr).getOperand()) or
       result = first(n.asExpr().(ConditionalExpr).getCondition())
     )
     or
diff --git a/java/ql/lib/semmle/code/java/Expr.qll b/java/ql/lib/semmle/code/java/Expr.qll
@@ -113,7 +113,7 @@ class Expr extends ExprParent, @expr {
     if this instanceof CastingExpr or this instanceof NotNullExpr
     then
       result = this.(CastingExpr).getExpr().getUnderlyingExpr() or
-      result = this.(NotNullExpr).getExpr().getUnderlyingExpr()
+      result = this.(NotNullExpr).getOperand().getUnderlyingExpr()
     else result = this
   }
 }
@@ -144,13 +144,13 @@ class CompileTimeConstantExpr extends Expr {
       this.(CastingExpr).getExpr().isCompileTimeConstant()
       or
       // The unary operators `+`, `-`, `~`, and `!` (but not `++` or `--`).
-      this.(PlusExpr).getExpr().isCompileTimeConstant()
+      this.(PlusExpr).getOperand().isCompileTimeConstant()
       or
-      this.(MinusExpr).getExpr().isCompileTimeConstant()
+      this.(MinusExpr).getOperand().isCompileTimeConstant()
       or
-      this.(BitNotExpr).getExpr().isCompileTimeConstant()
+      this.(BitNotExpr).getOperand().isCompileTimeConstant()
       or
-      this.(LogNotExpr).getExpr().isCompileTimeConstant()
+      this.(LogNotExpr).getOperand().isCompileTimeConstant()
       or
       // The multiplicative operators `*`, `/`, and `%`,
       // the additive operators `+` and `-`,
@@ -943,7 +943,7 @@ class LogicExpr extends Expr {
   /** Gets an operand of this logical expression. */
   Expr getAnOperand() {
     this.(BinaryExpr).getAnOperand() = result or
-    this.(UnaryExpr).getExpr() = result
+    this.(UnaryExpr).getOperand() = result
   }
 }
 
@@ -1039,8 +1039,15 @@ class ReferenceEqualityTest extends EqualityTest {
 
 /** A common super-class that represents unary operator expressions. */
 class UnaryExpr extends Expr, @unaryexpr {
+  /**
+   * DEPRECATED: Use getOperand() instead.
+   *
+   * Gets the operand expression.
+   */
+  deprecated Expr getExpr() { result.getParent() = this }
+
   /** Gets the operand expression. */
-  Expr getExpr() { result.getParent() = this }
+  Expr getOperand() { result.getParent() = this }
 }
 
 /**
@@ -1773,14 +1780,14 @@ class VariableUpdate extends Expr {
   VariableUpdate() {
     this.(Assignment).getDest() instanceof VarAccess or
     this instanceof LocalVariableDeclExpr or
-    this.(UnaryAssignExpr).getExpr() instanceof VarAccess
+    this.(UnaryAssignExpr).getOperand() instanceof VarAccess
   }
 
   /** Gets the destination of this variable update. */
   Variable getDestVar() {
     result.getAnAccess() = this.(Assignment).getDest() or
     result = this.(LocalVariableDeclExpr).getVariable() or
-    result.getAnAccess() = this.(UnaryAssignExpr).getExpr()
+    result.getAnAccess() = this.(UnaryAssignExpr).getOperand()
   }
 }
 
@@ -1970,7 +1977,7 @@ class VarAccess extends Expr, @varaccess {
    */
   predicate isVarWrite() {
     exists(Assignment a | a.getDest() = this) or
-    exists(UnaryAssignExpr e | e.getExpr() = this)
+    exists(UnaryAssignExpr e | e.getOperand() = this)
   }
 
   /**
diff --git a/java/ql/lib/semmle/code/java/PrettyPrintAst.qll b/java/ql/lib/semmle/code/java/PrettyPrintAst.qll
@@ -257,7 +257,7 @@ private class PpUnaryExpr extends PpAst, UnaryExpr {
     i = 2 and result = "--" and this instanceof PostDecExpr
   }
 
-  override PpAst getChild(int i) { i = 1 and result = this.getExpr() }
+  override PpAst getChild(int i) { i = 1 and result = this.getOperand() }
 }
 
 private class PpCastExpr extends PpAst, CastExpr {
diff --git a/java/ql/lib/semmle/code/java/Statement.qll b/java/ql/lib/semmle/code/java/Statement.qll
@@ -184,7 +184,7 @@ class ForStmt extends ConditionalStmt, @forstmt {
   Variable getAnIterationVariable() {
     // Check that the variable is assigned to, incremented or decremented in the update expression, and...
     exists(Expr update | update = this.getAnUpdate().getAChildExpr*() |
-      update.(UnaryAssignExpr).getExpr() = result.getAnAccess() or
+      update.(UnaryAssignExpr).getOperand() = result.getAnAccess() or
       update = result.getAnAssignedValue()
     ) and
     // ...that it is checked or used in the condition.
diff --git a/java/ql/lib/semmle/code/java/arithmetic/Overflow.qll b/java/ql/lib/semmle/code/java/arithmetic/Overflow.qll
@@ -93,7 +93,7 @@ class ArithExpr extends Expr {
     ) and
     forall(Expr e |
       e = this.(BinaryExpr).getAnOperand() or
-      e = this.(UnaryAssignExpr).getExpr() or
+      e = this.(UnaryAssignExpr).getOperand() or
       e = this.(AssignOp).getSource()
     |
       e.getType() instanceof NumType
@@ -114,7 +114,7 @@ class ArithExpr extends Expr {
    */
   Expr getLeftOperand() {
     result = this.(BinaryExpr).getLeftOperand() or
-    result = this.(UnaryAssignExpr).getExpr() or
+    result = this.(UnaryAssignExpr).getOperand() or
     result = this.(AssignOp).getDest()
   }
 
@@ -128,7 +128,7 @@ class ArithExpr extends Expr {
   /** Gets an operand of this arithmetic expression. */
   Expr getAnOperand() {
     result = this.(BinaryExpr).getAnOperand() or
-    result = this.(UnaryAssignExpr).getExpr() or
+    result = this.(UnaryAssignExpr).getOperand() or
     result = this.(AssignOp).getSource()
   }
 }
diff --git a/java/ql/lib/semmle/code/java/comparison/Comparison.qll b/java/ql/lib/semmle/code/java/comparison/Comparison.qll
@@ -9,7 +9,7 @@ import java
  * Used as basis for the transitive closure in `exprImplies`.
  */
 private predicate exprImpliesStep(Expr e1, boolean b1, Expr e2, boolean b2) {
-  e1.(LogNotExpr).getExpr() = e2 and
+  e1.(LogNotExpr).getOperand() = e2 and
   b2 = b1.booleanNot() and
   (b1 = true or b1 = false)
   or
diff --git a/java/ql/lib/semmle/code/java/controlflow/Guards.qll b/java/ql/lib/semmle/code/java/controlflow/Guards.qll
@@ -279,9 +279,7 @@ private module GuardsInput implements SharedGuards::InputSig<Location, ControlFl
     }
   }
 
-  class NotExpr extends Expr instanceof J::LogNotExpr {
-    Expr getOperand() { result = this.(J::LogNotExpr).getExpr() }
-  }
+  class NotExpr = J::LogNotExpr;
 
   class IdExpr extends Expr {
     IdExpr() { this instanceof AssignExpr or this instanceof CastExpr }
diff --git a/java/ql/lib/semmle/code/java/dataflow/Nullness.qll b/java/ql/lib/semmle/code/java/dataflow/Nullness.qll
@@ -64,7 +64,7 @@ private predicate unboxed(Expr e) {
       bin.getType() instanceof PrimitiveType
     )
     or
-    exists(UnaryExpr un | un.getExpr() = e)
+    exists(UnaryExpr un | un.getOperand() = e)
     or
     exists(ChooseExpr cond | cond.getType() instanceof PrimitiveType | cond.getAResultExpr() = e)
     or
diff --git a/java/ql/lib/semmle/code/java/dataflow/RangeAnalysis.qll b/java/ql/lib/semmle/code/java/dataflow/RangeAnalysis.qll
@@ -173,23 +173,23 @@ module Sem implements Semantic<Location> {
   }
 
   class NegateExpr extends UnaryExpr instanceof MinusExpr {
-    override Expr getOperand() { result = super.getExpr() }
+    override Expr getOperand() { result = MinusExpr.super.getOperand() }
   }
 
   class PreIncExpr extends UnaryExpr instanceof J::PreIncExpr {
-    override Expr getOperand() { result = super.getExpr() }
+    override Expr getOperand() { result = J::PreIncExpr.super.getOperand() }
   }
 
   class PreDecExpr extends UnaryExpr instanceof J::PreDecExpr {
-    override Expr getOperand() { result = super.getExpr() }
+    override Expr getOperand() { result = J::PreDecExpr.super.getOperand() }
   }
 
   class PostIncExpr extends UnaryExpr instanceof J::PostIncExpr {
-    override Expr getOperand() { result = super.getExpr() }
+    override Expr getOperand() { result = J::PostIncExpr.super.getOperand() }
   }
 
   class PostDecExpr extends UnaryExpr instanceof J::PostDecExpr {
-    override Expr getOperand() { result = super.getExpr() }
+    override Expr getOperand() { result = J::PostDecExpr.super.getOperand() }
   }
 
   class CopyValueExpr extends UnaryExpr {
@@ -200,7 +200,7 @@ module Sem implements Semantic<Location> {
     }
 
     override Expr getOperand() {
-      result = this.(J::PlusExpr).getExpr() or
+      result = this.(J::PlusExpr).getOperand() or
       result = this.(J::AssignExpr).getSource() or
       result = this.(J::LocalVariableDeclExpr).getInit()
     }
diff --git a/java/ql/lib/semmle/code/java/dataflow/TypeFlow.qll b/java/ql/lib/semmle/code/java/dataflow/TypeFlow.qll
@@ -137,7 +137,7 @@ module FlowStepsInput implements UniversalFlow::UniversalFlowInput<Location> {
     or
     n2.asSsa().(Base::SsaCapturedDefinition).captures(n1.asSsa())
     or
-    n2.asExpr().(NotNullExpr).getExpr() = n1.asExpr()
+    n2.asExpr().(NotNullExpr).getOperand() = n1.asExpr()
   }
 
   /**
diff --git a/java/ql/lib/semmle/code/java/dataflow/internal/BaseSSA.qll b/java/ql/lib/semmle/code/java/dataflow/internal/BaseSSA.qll
@@ -87,7 +87,7 @@ private module BaseSsaImpl {
       result = TLocalVar(v.getCallable(), v)
     )
     or
-    result.getAnAccess() = upd.(UnaryAssignExpr).getExpr()
+    result.getAnAccess() = upd.(UnaryAssignExpr).getOperand()
   }
 
   /** Holds if `n` updates the local variable `v`. */
diff --git a/java/ql/lib/semmle/code/java/dataflow/internal/DataFlowUtil.qll b/java/ql/lib/semmle/code/java/dataflow/internal/DataFlowUtil.qll
@@ -201,7 +201,7 @@ predicate simpleAstFlowStep(Expr e1, Expr e2) {
   or
   e2 = any(StmtExpr stmtExpr | e1 = stmtExpr.getResultExpr())
   or
-  e2 = any(NotNullExpr nne | e1 = nne.getExpr())
+  e2 = any(NotNullExpr nne | e1 = nne.getOperand())
   or
   e2.(WhenExpr).getBranch(_).getAResult() = e1
   or
diff --git a/java/ql/lib/semmle/code/java/dataflow/internal/SsaImpl.qll b/java/ql/lib/semmle/code/java/dataflow/internal/SsaImpl.qll
@@ -302,7 +302,7 @@ private module Cached {
       result = TLocalVar(v.getCallable(), v)
     )
     or
-    result.getAnAccess() = upd.(UnaryAssignExpr).getExpr()
+    result.getAnAccess() = upd.(UnaryAssignExpr).getOperand()
   }
 
   /*
diff --git a/java/ql/lib/semmle/code/java/dataflow/internal/rangeanalysis/SignAnalysisSpecific.qll b/java/ql/lib/semmle/code/java/dataflow/internal/rangeanalysis/SignAnalysisSpecific.qll
@@ -69,10 +69,10 @@ module Private {
 
     /** Returns the operand of this expression. */
     Expr getOperand() {
-      result = this.(J::PreIncExpr).getExpr() or
-      result = this.(J::PreDecExpr).getExpr() or
-      result = this.(J::MinusExpr).getExpr() or
-      result = this.(J::BitNotExpr).getExpr()
+      result = this.(J::PreIncExpr).getOperand() or
+      result = this.(J::PreDecExpr).getOperand() or
+      result = this.(J::MinusExpr).getOperand() or
+      result = this.(J::BitNotExpr).getOperand()
     }
 
     /** Returns the operation representing this expression. */
@@ -258,12 +258,12 @@ private module Impl {
 
   /** Returns the operand of the operation if `e` is a decrement. */
   Expr getDecrementOperand(Element e) {
-    result = e.(PostDecExpr).getExpr() or result = e.(PreDecExpr).getExpr()
+    result = e.(PostDecExpr).getOperand() or result = e.(PreDecExpr).getOperand()
   }
 
   /** Returns the operand of the operation if `e` is an increment. */
   Expr getIncrementOperand(Element e) {
-    result = e.(PostIncExpr).getExpr() or result = e.(PreIncExpr).getExpr()
+    result = e.(PostIncExpr).getOperand() or result = e.(PreIncExpr).getOperand()
   }
 
   /** Gets the variable underlying the implicit SSA variable `v`. */
@@ -287,14 +287,14 @@ private module Impl {
 
   /** Holds if `f` is accessed in an increment operation. */
   predicate fieldIncrementOperationOperand(Field f) {
-    any(PostIncExpr inc).getExpr() = f.getAnAccess() or
-    any(PreIncExpr inc).getExpr() = f.getAnAccess()
+    any(PostIncExpr inc).getOperand() = f.getAnAccess() or
+    any(PreIncExpr inc).getOperand() = f.getAnAccess()
   }
 
   /** Holds if `f` is accessed in a decrement operation. */
   predicate fieldDecrementOperationOperand(Field f) {
-    any(PostDecExpr dec).getExpr() = f.getAnAccess() or
-    any(PreDecExpr dec).getExpr() = f.getAnAccess()
+    any(PostDecExpr dec).getOperand() = f.getAnAccess() or
+    any(PreDecExpr dec).getOperand() = f.getAnAccess()
   }
 
   /** Returns possible signs of `f` based on the declaration. */
@@ -316,9 +316,9 @@ private module Impl {
   /** Returns a sub expression of `e` for expression types where the sign depends on the child. */
   Expr getASubExprWithSameSign(Expr e) {
     result = e.(AssignExpr).getSource() or
-    result = e.(PlusExpr).getExpr() or
-    result = e.(PostIncExpr).getExpr() or
-    result = e.(PostDecExpr).getExpr() or
+    result = e.(PlusExpr).getOperand() or
+    result = e.(PostIncExpr).getOperand() or
+    result = e.(PostDecExpr).getOperand() or
     result = e.(ChooseExpr).getAResultExpr() or
     result = e.(CastingExpr).getExpr()
   }
diff --git a/java/ql/lib/semmle/code/java/frameworks/android/Intent.qll b/java/ql/lib/semmle/code/java/frameworks/android/Intent.qll
@@ -279,7 +279,7 @@ private predicate reaches(Expr src, Argument arg) {
   or
   exists(StmtExpr e | e.getResultExpr() = src | reaches(e, arg))
   or
-  exists(NotNullExpr e | e.getExpr() = src | reaches(e, arg))
+  exists(NotNullExpr e | e.getOperand() = src | reaches(e, arg))
   or
   exists(WhenExpr e | e.getBranch(_).getAResult() = src | reaches(e, arg))
 }
diff --git a/java/ql/lib/semmle/code/java/security/InsecureRandomnessQuery.qll b/java/ql/lib/semmle/code/java/security/InsecureRandomnessQuery.qll
@@ -75,7 +75,7 @@ module InsecureRandomnessConfig implements DataFlow::ConfigSig {
   predicate isAdditionalFlowStep(DataFlow::Node n1, DataFlow::Node n2) {
     n1.asExpr() = n2.asExpr().(BinaryExpr).getAnOperand()
     or
-    n1.asExpr() = n2.asExpr().(UnaryExpr).getExpr()
+    n1.asExpr() = n2.asExpr().(UnaryExpr).getOperand()
     or
     exists(MethodCall mc, string methodName |
       mc.getMethod().hasQualifiedName("org.owasp.esapi", "Encoder", methodName) and
diff --git a/java/ql/src/Advisory/Declarations/NonFinalImmutableField.ql b/java/ql/src/Advisory/Declarations/NonFinalImmutableField.ql
@@ -32,7 +32,7 @@ class AnyAssignment extends Expr {
   /** The expression modified by this assignment. */
   Expr getDest() {
     this.(Assignment).getDest() = result or
-    this.(UnaryAssignExpr).getExpr() = result
+    this.(UnaryAssignExpr).getOperand() = result
   }
 }
 
diff --git a/java/ql/src/Security/CWE/CWE-835/InfiniteLoop.ql b/java/ql/src/Security/CWE/CWE-835/InfiniteLoop.ql
@@ -49,7 +49,7 @@ predicate subCondition(Expr cond, Expr subcond, boolean negated) {
   or
   subCondition(cond.(OrLogicalExpr).getAnOperand(), subcond, negated)
   or
-  subCondition(cond.(LogNotExpr).getExpr(), subcond, negated.booleanNot())
+  subCondition(cond.(LogNotExpr).getOperand(), subcond, negated.booleanNot())
 }
 
 from
diff --git a/java/ql/src/Violations of Best Practice/Boolean Logic/SimplifyBoolExpr.ql b/java/ql/src/Violations of Best Practice/Boolean Logic/SimplifyBoolExpr.ql
@@ -98,9 +98,9 @@ where
     or
     conditionalWithBool(e, pattern, rewrite)
     or
-    e.(LogNotExpr).getExpr().(ComparisonOrEquality).negate(pattern, rewrite)
+    e.(LogNotExpr).getOperand().(ComparisonOrEquality).negate(pattern, rewrite)
     or
-    e.(LogNotExpr).getExpr() instanceof LogNotExpr and
+    e.(LogNotExpr).getOperand() instanceof LogNotExpr and
     pattern = "!!A" and
     rewrite = "A"
   )
diff --git a/java/ql/src/Violations of Best Practice/Dead Code/DeadStoreOfLocal.ql b/java/ql/src/Violations of Best Practice/Dead Code/DeadStoreOfLocal.ql
diff --git a/java/ql/src/Violations of Best Practice/Dead Code/NonAssignedFields.ql b/java/ql/src/Violations of Best Practice/Dead Code/NonAssignedFields.ql
diff --git a/java/ql/test-kotlin1/library-tests/exprs/unaryOp.ql b/java/ql/test-kotlin1/library-tests/exprs/unaryOp.ql
diff --git a/java/ql/test-kotlin2/library-tests/exprs/unaryOp.ql b/java/ql/test-kotlin2/library-tests/exprs/unaryOp.ql
diff --git a/java/ql/test/library-tests/locations/NegativeLiteralLocation.ql b/java/ql/test/library-tests/locations/NegativeLiteralLocation.ql

Original file line number	Diff line number	Diff line change
`@@ -257,7 +257,7 @@ private class PpUnaryExpr extends PpAst, UnaryExpr {`
`257`	`257`	`i = 2 and result = "--" and this instanceof PostDecExpr`
`258`	`258`	`}`
`259`	`259`
`260`		`- override PpAst getChild(int i) { i = 1 and result = this.getExpr() }`
	`260`	`+ override PpAst getChild(int i) { i = 1 and result = this.getOperand() }`
`261`	`261`	`}`
`262`	`262`
`263`	`263`	`private class PpCastExpr extends PpAst, CastExpr {`
Original file line number	Diff line number	Diff line change
`@@ -93,7 +93,7 @@ class ArithExpr extends Expr {`
`93`	`93`	`) and`
`94`	`94`	`forall(Expr e \|`
`95`	`95`	`e = this.(BinaryExpr).getAnOperand() or`
`96`		`- e = this.(UnaryAssignExpr).getExpr() or`
	`96`	`+ e = this.(UnaryAssignExpr).getOperand() or`
`97`	`97`	`e = this.(AssignOp).getSource()`
`98`	`98`	`\|`
`99`	`99`	`e.getType() instanceof NumType`
`@@ -114,7 +114,7 @@ class ArithExpr extends Expr {`
`114`	`114`	`*/`
`115`	`115`	`Expr getLeftOperand() {`
`116`	`116`	`result = this.(BinaryExpr).getLeftOperand() or`
`117`		`- result = this.(UnaryAssignExpr).getExpr() or`
	`117`	`+ result = this.(UnaryAssignExpr).getOperand() or`
`118`	`118`	`result = this.(AssignOp).getDest()`
`119`	`119`	`}`
`120`	`120`
`@@ -128,7 +128,7 @@ class ArithExpr extends Expr {`
`128`	`128`	`/** Gets an operand of this arithmetic expression. */`
`129`	`129`	`Expr getAnOperand() {`
`130`	`130`	`result = this.(BinaryExpr).getAnOperand() or`
`131`		`- result = this.(UnaryAssignExpr).getExpr() or`
	`131`	`+ result = this.(UnaryAssignExpr).getOperand() or`
`132`	`132`	`result = this.(AssignOp).getSource()`
`133`	`133`	`}`
`134`	`134`	`}`
Original file line number	Diff line number	Diff line change
`@@ -279,9 +279,7 @@ private module GuardsInput implements SharedGuards::InputSig<Location, ControlFl`
`279`	`279`	`}`
`280`	`280`	`}`
`281`	`281`
`282`		`- class NotExpr extends Expr instanceof J::LogNotExpr {`
`283`		`- Expr getOperand() { result = this.(J::LogNotExpr).getExpr() }`
`284`		`- }`
	`282`	`+ class NotExpr = J::LogNotExpr;`
`285`	`283`
`286`	`284`	`class IdExpr extends Expr {`
`287`	`285`	`IdExpr() { this instanceof AssignExpr or this instanceof CastExpr }`
Original file line number	Diff line number	Diff line change
`@@ -64,7 +64,7 @@ private predicate unboxed(Expr e) {`
`64`	`64`	`bin.getType() instanceof PrimitiveType`
`65`	`65`	`)`
`66`	`66`	`or`
`67`		`- exists(UnaryExpr un \| un.getExpr() = e)`
	`67`	`+ exists(UnaryExpr un \| un.getOperand() = e)`
`68`	`68`	`or`
`69`	`69`	`exists(ChooseExpr cond \| cond.getType() instanceof PrimitiveType \| cond.getAResultExpr() = e)`
`70`	`70`	`or`