Fix equals and hashCode for Expressions

dd-java-agent/agent-debugger/debugger-el/src/main/java/com/datadog/debugger/el/BooleanValueExpressionAdapter.java

@@ -3,6 +3,7 @@
 import com.datadog.debugger.el.expressions.BooleanExpression;
 import com.datadog.debugger.el.expressions.ValueExpression;
 import com.datadog.debugger.el.values.BooleanValue;
+import java.util.Objects;
 
 public class BooleanValueExpressionAdapter implements ValueExpression<BooleanValue> {
 
@@ -26,4 +27,18 @@ public BooleanValue evaluate(EvalContext evalContext) {
   public <R> R accept(Visitor<R> visitor) {
     return visitor.visit(booleanExpression);
   }
+
+  @Generated
+  @Override
+  public boolean equals(Object o) {
+    if (o == null || getClass() != o.getClass()) return false;
+    BooleanValueExpressionAdapter that = (BooleanValueExpressionAdapter) o;
+    return Objects.equals(booleanExpression, that.booleanExpression);
+  }
+
+  @Generated
+  @Override
+  public int hashCode() {
+    return Objects.hashCode(booleanExpression);
+  }
 }

dd-java-agent/agent-debugger/debugger-el/src/main/java/com/datadog/debugger/el/expressions/BinaryExpression.java

@@ -1,7 +1,9 @@
 package com.datadog.debugger.el.expressions;
 
 import com.datadog.debugger.el.EvalContext;
+import com.datadog.debugger.el.Generated;
 import com.datadog.debugger.el.Visitor;
+import java.util.Objects;
 
 /**
  * Takes two {@linkplain BooleanExpression} instances and combines them with the given {@link
@@ -52,4 +54,20 @@ public BooleanExpression getRight() {
   public BinaryOperator getOperator() {
     return operator;
   }
+
+  @Generated
+  @Override
+  public boolean equals(Object o) {
+    if (o == null || getClass() != o.getClass()) return false;
+    BinaryExpression that = (BinaryExpression) o;
+    return Objects.equals(left, that.left)
+        && Objects.equals(right, that.right)
+        && operator == that.operator;
+  }
+
+  @Generated
+  @Override
+  public int hashCode() {
+    return Objects.hash(left, right, operator);
+  }
 }

dd-java-agent/agent-debugger/debugger-el/src/main/java/com/datadog/debugger/el/expressions/ComparisonExpression.java

@@ -5,9 +5,11 @@
 import com.datadog.debugger.el.EvalContext;
 import com.datadog.debugger.el.EvaluationException;
 import com.datadog.debugger.el.EvaluationTimeOutException;
+import com.datadog.debugger.el.Generated;
 import com.datadog.debugger.el.PrettyPrintVisitor;
 import com.datadog.debugger.el.Value;
 import com.datadog.debugger.el.Visitor;
+import java.util.Objects;
 
 /**
  * Takes two {@linkplain ValueExpression} instances and compares them using the given {@link
@@ -62,4 +64,20 @@ public ValueExpression<?> getRight() {
   public ComparisonOperator getOperator() {
     return operator;
   }
+
+  @Generated
+  @Override
+  public boolean equals(Object o) {
+    if (o == null || getClass() != o.getClass()) return false;
+    ComparisonExpression that = (ComparisonExpression) o;
+    return Objects.equals(left, that.left)
+        && Objects.equals(right, that.right)
+        && operator == that.operator;
+  }
+
+  @Generated
+  @Override
+  public int hashCode() {
+    return Objects.hash(left, right, operator);
+  }
 }

dd-java-agent/agent-debugger/debugger-el/src/main/java/com/datadog/debugger/el/expressions/ContainsExpression.java

@@ -5,10 +5,12 @@
 
 import com.datadog.debugger.el.EvalContext;
 import com.datadog.debugger.el.EvaluationException;
+import com.datadog.debugger.el.Generated;
 import com.datadog.debugger.el.PrettyPrintVisitor;
 import com.datadog.debugger.el.Value;
 import com.datadog.debugger.el.Visitor;
 import com.datadog.debugger.el.values.CollectionValue;
+import java.util.Objects;
 
 public class ContainsExpression implements BooleanExpression {
   private final ValueExpression<?> target;
@@ -71,4 +73,18 @@ public ValueExpression<?> getTarget() {
   public ValueExpression<?> getValue() {
     return value;
   }
+
+  @Generated
+  @Override
+  public boolean equals(Object o) {
+    if (o == null || getClass() != o.getClass()) return false;
+    ContainsExpression that = (ContainsExpression) o;
+    return Objects.equals(target, that.target) && Objects.equals(value, that.value);
+  }
+
+  @Generated
+  @Override
+  public int hashCode() {
+    return Objects.hash(target, value);
+  }
 }

dd-java-agent/agent-debugger/debugger-el/src/main/java/com/datadog/debugger/el/expressions/FilterCollectionExpression.java

@@ -9,6 +9,7 @@
 
 import com.datadog.debugger.el.EvalContext;
 import com.datadog.debugger.el.EvaluationException;
+import com.datadog.debugger.el.Generated;
 import com.datadog.debugger.el.Value;
 import com.datadog.debugger.el.Visitor;
 import com.datadog.debugger.el.values.CollectionValue;
@@ -23,6 +24,7 @@
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Map;
+import java.util.Objects;
 import java.util.Set;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -124,4 +126,19 @@ public ValueExpression<?> getSource() {
   public BooleanExpression getFilterExpression() {
     return filterExpression;
   }
+
+  @Generated
+  @Override
+  public boolean equals(Object o) {
+    if (o == null || getClass() != o.getClass()) return false;
+    FilterCollectionExpression that = (FilterCollectionExpression) o;
+    return Objects.equals(source, that.source)
+        && Objects.equals(filterExpression, that.filterExpression);
+  }
+
+  @Generated
+  @Override
+  public int hashCode() {
+    return Objects.hash(source, filterExpression);
+  }
 }

dd-java-agent/agent-debugger/debugger-el/src/main/java/com/datadog/debugger/el/expressions/IndexExpression.java

@@ -6,12 +6,14 @@
 
 import com.datadog.debugger.el.EvalContext;
 import com.datadog.debugger.el.EvaluationException;
+import com.datadog.debugger.el.Generated;
 import com.datadog.debugger.el.PrettyPrintVisitor;
 import com.datadog.debugger.el.Value;
 import com.datadog.debugger.el.Visitor;
 import com.datadog.debugger.el.values.ListValue;
 import com.datadog.debugger.el.values.MapValue;
 import datadog.trace.bootstrap.debugger.util.Redaction;
+import java.util.Objects;
 
 public class IndexExpression implements ValueExpression<Value<?>> {
 
@@ -81,4 +83,18 @@ public ValueExpression<?> getTarget() {
   public ValueExpression<?> getKey() {
     return key;
   }
+
+  @Generated
+  @Override
+  public boolean equals(Object o) {
+    if (o == null || getClass() != o.getClass()) return false;
+    IndexExpression that = (IndexExpression) o;
+    return Objects.equals(target, that.target) && Objects.equals(key, that.key);
+  }
+
+  @Generated
+  @Override
+  public int hashCode() {
+    return Objects.hash(target, key);
+  }
 }

dd-java-agent/agent-debugger/debugger-el/src/main/java/com/datadog/debugger/el/expressions/IsDefinedExpression.java

@@ -5,8 +5,10 @@
 import com.datadog.debugger.el.EvalContext;
 import com.datadog.debugger.el.EvaluationException;
 import com.datadog.debugger.el.EvaluationTimeOutException;
+import com.datadog.debugger.el.Generated;
 import com.datadog.debugger.el.Value;
 import com.datadog.debugger.el.Visitor;
+import java.util.Objects;
 
 /** Check whether a {@linkplain Value} was resolved correctly or symbol exists.<br> */
 public class IsDefinedExpression implements BooleanExpression {
@@ -41,4 +43,18 @@ public <R> R accept(Visitor<R> visitor) {
   public ValueExpression<?> getValueExpression() {
     return valueExpression;
   }
+
+  @Generated
+  @Override
+  public boolean equals(Object o) {
+    if (o == null || getClass() != o.getClass()) return false;
+    IsDefinedExpression that = (IsDefinedExpression) o;
+    return Objects.equals(valueExpression, that.valueExpression);
+  }
+
+  @Generated
+  @Override
+  public int hashCode() {
+    return Objects.hashCode(valueExpression);
+  }
 }

dd-java-agent/agent-debugger/debugger-el/src/main/java/com/datadog/debugger/el/expressions/IsEmptyExpression.java

@@ -4,11 +4,13 @@
 
 import com.datadog.debugger.el.EvalContext;
 import com.datadog.debugger.el.EvaluationException;
+import com.datadog.debugger.el.Generated;
 import com.datadog.debugger.el.PrettyPrintVisitor;
 import com.datadog.debugger.el.Value;
 import com.datadog.debugger.el.Visitor;
 import com.datadog.debugger.el.values.CollectionValue;
 import com.datadog.debugger.el.values.StringValue;
+import java.util.Objects;
 
 /**
  * Checks whether a {@linkplain Value} is empty.<br>
@@ -50,4 +52,18 @@ public <R> R accept(Visitor<R> visitor) {
   public ValueExpression<?> getValueExpression() {
     return valueExpression;
   }
+
+  @Generated
+  @Override
+  public boolean equals(Object o) {
+    if (o == null || getClass() != o.getClass()) return false;
+    IsEmptyExpression that = (IsEmptyExpression) o;
+    return Objects.equals(valueExpression, that.valueExpression);
+  }
+
+  @Generated
+  @Override
+  public int hashCode() {
+    return Objects.hashCode(valueExpression);
+  }
 }

dd-java-agent/agent-debugger/debugger-el/src/main/java/com/datadog/debugger/el/expressions/LenExpression.java

@@ -4,13 +4,15 @@
 
 import com.datadog.debugger.el.EvalContext;
 import com.datadog.debugger.el.EvaluationException;
+import com.datadog.debugger.el.Generated;
 import com.datadog.debugger.el.PrettyPrintVisitor;
 import com.datadog.debugger.el.Value;
 import com.datadog.debugger.el.ValueType;
 import com.datadog.debugger.el.Visitor;
 import com.datadog.debugger.el.values.CollectionValue;
 import com.datadog.debugger.el.values.NumericValue;
 import com.datadog.debugger.el.values.StringValue;
+import java.util.Objects;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -61,4 +63,18 @@ public ValueExpression<?> getSource() {
   public <R> R accept(Visitor<R> visitor) {
     return visitor.visit(this);
   }
+
+  @Generated
+  @Override
+  public boolean equals(Object o) {
+    if (o == null || getClass() != o.getClass()) return false;
+    LenExpression that = (LenExpression) o;
+    return Objects.equals(source, that.source);
+  }
+
+  @Generated
+  @Override
+  public int hashCode() {
+    return Objects.hashCode(source);
+  }
 }

dd-java-agent/agent-debugger/debugger-el/src/main/java/com/datadog/debugger/el/expressions/MatchingExpression.java

@@ -1,5 +1,8 @@
 package com.datadog.debugger.el.expressions;
 
+import com.datadog.debugger.el.Generated;
+import java.util.Objects;
+
 /** Abstract super class for expressions performing matching of a value against a predicate. */
 abstract class MatchingExpression implements BooleanExpression {
   protected final ValueExpression<?> valueExpression;
@@ -19,4 +22,19 @@ public ValueExpression<?> getValueExpression() {
   public BooleanExpression getFilterPredicateExpression() {
     return filterPredicateExpression;
   }
+
+  @Generated
+  @Override
+  public boolean equals(Object o) {
+    if (o == null || getClass() != o.getClass()) return false;
+    MatchingExpression that = (MatchingExpression) o;
+    return Objects.equals(valueExpression, that.valueExpression)
+        && Objects.equals(filterPredicateExpression, that.filterPredicateExpression);
+  }
+
+  @Generated
+  @Override
+  public int hashCode() {
+    return Objects.hash(valueExpression, filterPredicateExpression);
+  }
 }

dd-java-agent/agent-debugger/debugger-el/src/main/java/com/datadog/debugger/el/expressions/NotExpression.java

@@ -3,7 +3,9 @@
 import static com.datadog.debugger.el.expressions.ExpressionHelper.checkTimeout;
 
 import com.datadog.debugger.el.EvalContext;
+import com.datadog.debugger.el.Generated;
 import com.datadog.debugger.el.Visitor;
+import java.util.Objects;
 
 /** Will negate the resolved {@linkplain BooleanExpression} */
 public final class NotExpression implements BooleanExpression {
@@ -28,4 +30,18 @@ public <R> R accept(Visitor<R> visitor) {
   public BooleanExpression getPredicate() {
     return predicate;
   }
+
+  @Generated
+  @Override
+  public boolean equals(Object o) {
+    if (o == null || getClass() != o.getClass()) return false;
+    NotExpression that = (NotExpression) o;
+    return Objects.equals(predicate, that.predicate);
+  }
+
+  @Generated
+  @Override
+  public int hashCode() {
+    return Objects.hashCode(predicate);
+  }
 }

dd-java-agent/agent-debugger/debugger-el/src/main/java/com/datadog/debugger/el/expressions/StringPredicateExpression.java

@@ -2,9 +2,11 @@
 
 import com.datadog.debugger.el.EvalContext;
 import com.datadog.debugger.el.EvaluationException;
+import com.datadog.debugger.el.Generated;
 import com.datadog.debugger.el.PrettyPrintVisitor;
 import com.datadog.debugger.el.Value;
 import com.datadog.debugger.el.values.StringValue;
+import java.util.Objects;
 import java.util.function.BiPredicate;
 
 public class StringPredicateExpression implements BooleanExpression {
@@ -60,4 +62,21 @@ public BiPredicate<String, String> getPredicate() {
   public String getName() {
     return name;
   }
+
+  @Generated
+  @Override
+  public boolean equals(Object o) {
+    if (o == null || getClass() != o.getClass()) return false;
+    StringPredicateExpression that = (StringPredicateExpression) o;
+    // predicate is excluded: lambda equality is identity-based, the class and name identify it
+    return Objects.equals(sourceString, that.sourceString)
+        && Objects.equals(str, that.str)
+        && Objects.equals(name, that.name);
+  }
+
+  @Generated
+  @Override
+  public int hashCode() {
+    return Objects.hash(sourceString, str, name);
+  }
 }