fixup! Replace ByteBuddy proxying with direct soft assertion support

Author: filiphr

assertj-core/src/main/java/org/assertj/core/api/AbstractAssert.java

@@ -1191,9 +1191,7 @@ public SELF doesNotHaveSameHashCodeAs(Object other) {
    * @return a new {@link AbstractListAssert}.
    */
   protected <E> AbstractListAssert<?, List<? extends E>, E, ObjectAssert<E>> newListAssertInstance(List<? extends E> newActual) {
-    ListAssert<E> listAssert = new ListAssert<>(newActual);
-    listAssert.withAssertionState(myself);
-    return listAssert;
+    return new ListAssert<>(newActual);
   }
 
   SELF withAssertionState(@SuppressWarnings("rawtypes") AbstractAssert assertInstance) {
@@ -1205,16 +1203,8 @@ SELF withAssertionState(@SuppressWarnings("rawtypes") AbstractAssert assertInsta
 
   private void propagateAssertionInfoFrom(AbstractAssert<?, ?> assertInstance) {
     this.info.useRepresentation(assertInstance.info.representation());
-    if (assertInstance.info.overridingErrorMessage() != null) {
-      // When overridingErrorMessage is set, always propagate both it and the description
-      // (even if null) so the overridingErrorMessage is used as-is without any description prefix.
-      this.info.overridingErrorMessage(assertInstance.info.overridingErrorMessage());
-      this.info.description(assertInstance.info.description());
-    } else if (assertInstance.info.description() != null) {
-      // Only overwrite description if the source has one set.
-      // This preserves descriptions set by extracting/navigation methods (via .as()).
-      this.info.description(assertInstance.info.description());
-    }
+    this.info.overridingErrorMessage(assertInstance.info.overridingErrorMessage());
+    this.info.description(assertInstance.info.description());
   }
 
   // this method is meant to be overridden and made public in subclasses that want to expose it
@@ -1271,7 +1261,7 @@ protected RecursiveAssertionAssert usingRecursiveAssertion() {
     String extractedPropertyOrFieldDescription = extractedDescriptionOf(propertyOrField);
     String description = mostRelevantDescription(info.description(), extractedPropertyOrFieldDescription);
     @SuppressWarnings("unchecked")
-    ASSERT result = (ASSERT) assertFactory.createAssert(value).as(description).withAssertionState(myself);
+    ASSERT result = (ASSERT) assertFactory.createAssert(value).withAssertionState(myself).as(description);
     return result;
   }
 

assertj-core/src/main/java/org/assertj/core/api/AbstractCollectionAssert.java

@@ -169,10 +169,9 @@ private FactoryBasedAssert(ACTUAL actual, AssertFactory<ELEMENT, ELEMENT_ASSERT>
       this.assertFactory = assertFactory;
     }
 
-    @SuppressWarnings("unchecked")
     @Override
-    protected ELEMENT_ASSERT toAssert(ELEMENT value, String description) {
-      return assertFactory.createAssert(value).as(description);
+    protected ELEMENT_ASSERT toAssert(ELEMENT value) {
+      return assertFactory.createAssert(value);
     }
 
     @SuppressWarnings("unchecked")

assertj-core/src/main/java/org/assertj/core/api/AbstractIterableAssert.java

@@ -891,7 +891,7 @@ public AbstractListAssert<?, List<?>, Object, ObjectAssert<Object>> extracting(S
     List<Object> values = FieldsOrPropertiesExtractor.extract(actual, byName(propertyOrField));
     String extractedDescription = extractedDescriptionOf(propertyOrField);
     String description = mostRelevantDescription(info.description(), extractedDescription);
-    return propagateState(newListAssertInstanceForMethodsChangingElementType(values).as(description));
+    return newListAssertInstanceForMethodsChangingElementType(values).as(description);
   }
 
   /**
@@ -939,7 +939,7 @@ public AbstractListAssert<?, List<?>, Object, ObjectAssert<Object>> extractingRe
     List<Object> values = FieldsOrPropertiesExtractor.extract(actual, resultOf(method));
     String extractedDescription = extractedDescriptionOfMethod(method);
     String description = mostRelevantDescription(info.description(), extractedDescription);
-    return propagateState(newListAssertInstanceForMethodsChangingElementType(values).as(description));
+    return newListAssertInstanceForMethodsChangingElementType(values).as(description);
   }
 
   /**
@@ -989,7 +989,7 @@ public <P> AbstractListAssert<?, List<? extends P>, P, ObjectAssert<P>> extracti
     List<P> values = (List<P>) FieldsOrPropertiesExtractor.extract(actual, resultOf(method));
     String extractedDescription = extractedDescriptionOfMethod(method);
     String description = mostRelevantDescription(info.description(), extractedDescription);
-    return propagateState(newListAssertInstanceForMethodsChangingElementType(values).as(description));
+    return newListAssertInstanceForMethodsChangingElementType(values).as(description);
   }
 
   /**
@@ -1079,7 +1079,7 @@ public <P> AbstractListAssert<?, List<? extends P>, P, ObjectAssert<P>> extracti
     List<P> values = (List<P>) FieldsOrPropertiesExtractor.extract(actual, byName(propertyOrField));
     String extractedDescription = extractedDescriptionOf(propertyOrField);
     String description = mostRelevantDescription(info.description(), extractedDescription);
-    return propagateState(newListAssertInstanceForMethodsChangingElementType(values).as(description));
+    return newListAssertInstanceForMethodsChangingElementType(values).as(description);
   }
 
   /**
@@ -1171,7 +1171,7 @@ public AbstractListAssert<?, List<? extends Tuple>, Tuple, ObjectAssert<Tuple>>
     List<Tuple> values = FieldsOrPropertiesExtractor.extract(actual, byName(propertiesOrFields));
     String extractedDescription = extractedDescriptionOf(propertiesOrFields);
     String description = mostRelevantDescription(info.description(), extractedDescription);
-    return propagateState(newListAssertInstanceForMethodsChangingElementType(values).as(description));
+    return newListAssertInstanceForMethodsChangingElementType(values).as(description);
   }
 
   /**
@@ -1213,7 +1213,7 @@ public <V> AbstractListAssert<?, List<? extends V>, V, ObjectAssert<V>> extracti
   private <V> AbstractListAssert<?, List<? extends V>, V, ObjectAssert<V>> internalExtracting(Function<? super ELEMENT, V> extractor) {
     if (actual == null) throwAssertionError(shouldNotBeNull());
     List<V> values = FieldsOrPropertiesExtractor.extract(actual, extractor);
-    return propagateState(newListAssertInstanceForMethodsChangingElementType(values));
+    return newListAssertInstanceForMethodsChangingElementType(values);
   }
 
   /**
@@ -1348,21 +1348,7 @@ private <V> AbstractListAssert<?, List<? extends V>, V, ObjectAssert<V>> newList
       // extracting names we get a List<String> which is mot suitable for the age comparator
       usingDefaultElementComparator();
     }
-    return newListAssertInstance(values);
-  }
-
-  /**
-   * Called after an extracting/mapping/filtering method creates a new assert and sets its description.
-   * Propagates the soft assertion collector and assertion state from the parent, with the description
-   * being the most relevant between the parent's existing description and the new one.
-   * <p>
-   * This method must be called AFTER {@code .as(description)} so that {@code withAssertionState}
-   * overwrites the description with the parent's if the parent had one set.
-   */
-  @SuppressWarnings("rawtypes")
-  private <A extends AbstractAssert> A propagateState(A result) {
-    result.withAssertionState(myself);
-    return result;
+    return newListAssertInstance(values).withAssertionState(myself);
   }
 
   /**
@@ -1514,7 +1500,7 @@ private <V> AbstractListAssert<?, List<? extends V>, V, ObjectAssert<V>> doFlatE
     List<V> result = FieldsOrPropertiesExtractor.extract(actual, extractor).stream()
                                                 .flatMap(Collection::stream)
                                                 .collect(toList());
-    return propagateState(newListAssertInstanceForMethodsChangingElementType(result));
+    return newListAssertInstanceForMethodsChangingElementType(result);
   }
 
   /**
@@ -1588,7 +1574,7 @@ protected AbstractListAssert<?, List<?>, Object, ObjectAssert<Object>> flatExtra
     Stream<? extends ELEMENT> actualStream = stream(actual.spliterator(), false);
     List<Object> result = actualStream.flatMap(element -> Stream.of(extractors).map(extractor -> extractor.apply(element)))
                                       .collect(toList());
-    return propagateState(newListAssertInstanceForMethodsChangingElementType(result));
+    return newListAssertInstanceForMethodsChangingElementType(result);
   }
 
   /**
@@ -1723,7 +1709,7 @@ public AbstractListAssert<?, List<?>, Object, ObjectAssert<Object>> flatExtracti
         CommonErrors.wrongElementTypeForFlatExtracting(group);
       }
     }
-    return propagateState(newListAssertInstanceForMethodsChangingElementType(extractedValues));
+    return newListAssertInstanceForMethodsChangingElementType(extractedValues);
   }
 
   /**
@@ -1790,7 +1776,7 @@ protected AbstractListAssert<?, List<? extends Tuple>, Tuple, ObjectAssert<Tuple
                                                                                           .map(extractor -> extractor.apply(objectToExtractValueFrom))
                                                                                           .toArray());
     List<Tuple> tuples = stream(actual.spliterator(), false).map(tupleExtractor).collect(toList());
-    return propagateState(newListAssertInstanceForMethodsChangingElementType(tuples));
+    return newListAssertInstanceForMethodsChangingElementType(tuples);
   }
 
   /**
@@ -1875,7 +1861,7 @@ public AbstractListAssert<?, List<?>, Object, ObjectAssert<Object>> flatExtracti
     List<Object> extractedValues = FieldsOrPropertiesExtractor.extract(actual, byName(fieldOrPropertyNames)).stream()
                                                               .flatMap(tuple -> tuple.toList().stream())
                                                               .collect(toList());
-    return propagateState(newListAssertInstanceForMethodsChangingElementType(extractedValues));
+    return newListAssertInstanceForMethodsChangingElementType(extractedValues);
   }
 
   @Override
@@ -2834,9 +2820,7 @@ public ELEMENT_ASSERT first() {
 
   private ELEMENT_ASSERT internalFirst() {
     isNotEmpty();
-    ELEMENT_ASSERT result = toAssert(actual.iterator().next(), navigationDescription("check first element"));
-    result.withAssertionState(myself);
-    return result;
+    return toAssert(actual.iterator().next(), navigationDescription("check first element"));
   }
 
   /**
@@ -2900,9 +2884,7 @@ public ELEMENT_ASSERT last() {
 
   private ELEMENT_ASSERT internalLast() {
     isNotEmpty();
-    ELEMENT_ASSERT result = toAssert(lastElement(), navigationDescription("check last element"));
-    result.withAssertionState(myself);
-    return result;
+    return toAssert(lastElement(), navigationDescription("check last element"));
   }
 
   @SuppressWarnings("unchecked")
@@ -3055,9 +3037,7 @@ private ELEMENT_ASSERT internalElement(int index) {
       elementAtIndex = actualIterator.next();
     }
 
-    ELEMENT_ASSERT result = toAssert(elementAtIndex, navigationDescription("element at index " + index));
-    result.withAssertionState(myself);
-    return result;
+    return toAssert(elementAtIndex, navigationDescription("element at index " + index));
   }
 
   /**
@@ -3143,9 +3123,7 @@ public ELEMENT_ASSERT singleElement() {
 
   private ELEMENT_ASSERT internalSingleElement() {
     iterables.assertHasSize(info, actual, 1);
-    ELEMENT_ASSERT result = toAssert(actual.iterator().next(), navigationDescription("check single element"));
-    result.withAssertionState(myself);
-    return result;
+    return toAssert(actual.iterator().next(), navigationDescription("check single element"));
   }
 
   /**
@@ -3159,7 +3137,12 @@ private ELEMENT_ASSERT internalSingleElement() {
    * @param description describes the element, ex: "check first element" for {@link #first()}, used in assertion description.
    * @return the assertion for the given element
    */
-  protected abstract ELEMENT_ASSERT toAssert(ELEMENT value, String description);
+  @SuppressWarnings("unchecked")
+  protected ELEMENT_ASSERT toAssert(ELEMENT value, String description) {
+    return toAssert(value).withAssertionState(myself).as(description);
+  }
+
+  protected abstract ELEMENT_ASSERT toAssert(ELEMENT value);
 
   protected String navigationDescription(String propertyName) {
     String text = descriptionText();
@@ -3657,10 +3640,9 @@ private FactoryBasedAssert(ACTUAL actual, AssertFactory<ELEMENT, ELEMENT_ASSERT>
       this.assertFactory = assertFactory;
     }
 
-    @SuppressWarnings("unchecked")
     @Override
-    protected ELEMENT_ASSERT toAssert(ELEMENT value, String description) {
-      return assertFactory.createAssert(value).as(description);
+    protected ELEMENT_ASSERT toAssert(ELEMENT value) {
+      return assertFactory.createAssert(value);
     }
 
     @SuppressWarnings("unchecked")

assertj-core/src/main/java/org/assertj/core/api/AbstractListAssert.java

@@ -426,10 +426,9 @@ private FactoryBasedAssert(ACTUAL actual, AssertFactory<ELEMENT, ELEMENT_ASSERT>
       this.assertFactory = assertFactory;
     }
 
-    @SuppressWarnings("unchecked")
     @Override
-    protected ELEMENT_ASSERT toAssert(ELEMENT value, String description) {
-      return assertFactory.createAssert(value).as(description);
+    protected ELEMENT_ASSERT toAssert(ELEMENT value) {
+      return assertFactory.createAssert(value);
     }
 
     @SuppressWarnings("unchecked")

assertj-core/src/main/java/org/assertj/core/api/AbstractMapAssert.java

@@ -1935,7 +1935,7 @@ public AbstractListAssert<?, List<?>, Object, ObjectAssert<Object>> flatExtracti
     List<Object> valuesFlattened = flatten(values.toList());
     String extractedPropertiesOrFieldsDescription = extractedDescriptionOf(keys);
     String description = mostRelevantDescription(info.description(), extractedPropertiesOrFieldsDescription);
-    return newListAssertInstance(valuesFlattened).as(description);
+    return newListAssertInstance(valuesFlattened).withAssertionState(myself).as(description);
   }
 
   /**

assertj-core/src/main/java/org/assertj/core/api/AbstractObjectArrayAssert.java

@@ -3491,9 +3491,7 @@ public SELF noneMatch(Predicate<? super ELEMENT> predicate, String predicateDesc
    */
   @Override
   protected <E> AbstractListAssert<?, List<? extends E>, E, ObjectAssert<E>> newListAssertInstance(List<? extends E> newActual) {
-    ListAssert<E> result = new ListAssert<>(newActual);
-    result.withAssertionState(myself);
-    return result;
+    return new ListAssert<>(newActual);
   }
 
   /**
@@ -3770,9 +3768,7 @@ private static String removeAssert(String text) {
   }
 
   private ObjectAssert<ELEMENT> toAssert(ELEMENT value, String description) {
-    ObjectAssert<ELEMENT> result = new ObjectAssert<>(value);
-    result.withAssertionState(myself);
-    return result.as(description);
+    return new ObjectAssert<>(value).withAssertionState(myself).as(description);
   }
 
   // lazy init TypeComparators

assertj-core/src/main/java/org/assertj/core/api/AbstractObjectAssert.java

@@ -411,7 +411,7 @@ public AbstractListAssert<?, List<?>, Object, ObjectAssert<Object>> extracting(S
     Tuple values = byName(propertiesOrFields).apply(actual);
     String extractedPropertiesOrFieldsDescription = extractedDescriptionOf(propertiesOrFields);
     String description = mostRelevantDescription(info.description(), extractedPropertiesOrFieldsDescription);
-    return newListAssertInstance(values.toList()).as(description).withAssertionState(myself);
+    return newListAssertInstance(values.toList()).withAssertionState(myself).as(description);
   }
 
   /**
@@ -899,9 +899,7 @@ public RecursiveAssertionAssert usingRecursiveAssertion(RecursiveAssertionConfig
 
   // override for proxyable friendly AbstractObjectAssert
   protected <T> AbstractObjectAssert<?, T> newObjectAssert(T objectUnderTest) {
-    ObjectAssert<T> result = new ObjectAssert<>(objectUnderTest);
-    result.withAssertionState(myself);
-    return result;
+    return new ObjectAssert<>(objectUnderTest);
   }
 
   @SuppressWarnings({ "rawtypes" })

assertj-core/src/main/java/org/assertj/core/api/AbstractOptionalAssert.java

@@ -458,9 +458,7 @@ public SELF containsSame(VALUE expectedValue) {
   @CheckReturnValue
   public <U> AbstractOptionalAssert<?, U> flatMap(Function<? super VALUE, Optional<U>> mapper) {
     isNotNull();
-    OptionalAssert<U> result = assertThat(actual.flatMap(mapper));
-    result.withAssertionState(myself);
-    return result;
+    return assertThat(actual.flatMap(mapper)).withAssertionState(myself);
   }
 
   /**

assertj-core/src/main/java/org/assertj/core/api/AbstractThrowableAssert.java

@@ -859,9 +859,7 @@ private boolean isNotAnInstanceOfAny(Class<? extends Throwable>[] exceptionTypes
    */
   public AbstractStringAssert<?> message() {
     objects.assertNotNull(info, actual);
-    StringAssert result = new StringAssert(actual.getMessage());
-    result.withAssertionState(myself);
-    return result;
+    return new StringAssert(actual.getMessage()).withAssertionState(myself);
   }
 
 }

assertj-core/src/main/java/org/assertj/core/api/CollectionAssert.java

@@ -41,8 +41,8 @@ public CollectionAssert(Collection<? extends ELEMENT> actual) {
   }
 
   @Override
-  protected ObjectAssert<ELEMENT> toAssert(ELEMENT value, String description) {
-    return new ObjectAssert<>(value).as(description);
+  protected ObjectAssert<ELEMENT> toAssert(ELEMENT value) {
+    return new ObjectAssert<>(value);
   }
 
   @Override