Work around/suppress around 95 warnings produced on JDK-17 with -Xlint:all (assertj#2648)

Work around/suppress around 95 warnings produced on JDK-17 with -Xlint flag enabled.

Fix a couple of warnings dotted around in tests to do with unchecked operations

Fix incorrect javadoc reference in Floats_AssertLessThanOrEqualTo_test

Author: ascopes

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

@@ -685,6 +685,7 @@ public SELF containsExactlyInAnyOrderEntriesOf(Map<? extends K, ? extends V> map
     return containsOnly(toEntries(map));
   }
 
+  @SuppressWarnings("unchecked")
   private Map.Entry<? extends K, ? extends V>[] toEntries(Map<? extends K, ? extends V> map) {
     return map.entrySet().toArray(new Map.Entry[0]);
   }

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

@@ -90,7 +90,8 @@
  * @author Lovro Pandzic
  */
 // suppression of deprecation works in Eclipse to hide warning for the deprecated classes in the imports
-@SuppressWarnings("deprecation")
+// IntelliJ thinks this is redundant when it is not.
+@SuppressWarnings({"deprecation", "RedundantSuppression"})
 public abstract class AbstractObjectArrayAssert<SELF extends AbstractObjectArrayAssert<SELF, ELEMENT>, ELEMENT> extends
     AbstractAssert<SELF, ELEMENT[]>
     implements IndexedObjectEnumerableAssert<AbstractObjectArrayAssert<SELF, ELEMENT>, ELEMENT>,

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

@@ -44,7 +44,8 @@
  * @author Nicolai Parlog
  * @author Grzegorz Piwowarek
  */
-@SuppressWarnings("deprecation")
+// Deprecation is raised by JDK-17. IntelliJ thinks this is redundant when it is not.
+@SuppressWarnings({"deprecation", "RedundantSuppression"})
 public abstract class AbstractOptionalAssert<SELF extends AbstractOptionalAssert<SELF, VALUE>, VALUE> extends
     AbstractAssert<SELF, Optional<VALUE>> {
 
@@ -278,6 +279,7 @@ public SELF containsInstanceOf(Class<?> clazz) {
    */
   @Deprecated
   @CheckReturnValue
+  @SuppressWarnings({"DeprecatedIsStillUsed", "deprecation"})
   public SELF usingFieldByFieldValueComparator() {
     return usingValueComparator(new FieldByFieldComparator());
   }

src/main/java/org/assertj/core/api/AtomicReferenceArrayAssert.java

@@ -70,20 +70,21 @@
 import org.assertj.core.util.introspection.IntrospectionError;
 
 // suppression of deprecation works in Eclipse to hide warning for the deprecated classes in the imports
-@SuppressWarnings("deprecation")
+// Deprecation is raised by JDK-17. IntelliJ thinks this is redundant when it is not.
+@SuppressWarnings({"deprecation", "RedundantSuppression"})
 public class AtomicReferenceArrayAssert<T>
     extends AbstractAssert<AtomicReferenceArrayAssert<T>, AtomicReferenceArray<T>>
     implements IndexedObjectEnumerableAssert<AtomicReferenceArrayAssert<T>, T>,
     ArraySortedAssert<AtomicReferenceArrayAssert<T>, T> {
 
-  private T[] array;
+  private final T[] array;
   @VisibleForTesting
   ObjectArrays arrays = ObjectArrays.instance();
   @VisibleForTesting
   Iterables iterables = Iterables.instance();
 
   private TypeComparators comparatorsByType;
-  private Map<String, Comparator<?>> comparatorsForElementPropertyOrFieldNames = new TreeMap<>();
+  private final Map<String, Comparator<?>> comparatorsForElementPropertyOrFieldNames = new TreeMap<>();
   private TypeComparators comparatorsForElementPropertyOrFieldTypes;
 
   public AtomicReferenceArrayAssert(AtomicReferenceArray<T> actual) {

src/main/java/org/assertj/core/api/InstanceOfAssertFactories.java

@@ -89,7 +89,9 @@ public interface InstanceOfAssertFactories {
    *
    * @see #PREDICATE
    */
-  @SuppressWarnings({ "rawtypes", "unused" }) // rawtypes: using Class instance, unused: parameter needed for type inference
+  @SuppressWarnings({"rawtypes", "unused", "unchecked", "RedundantSuppression"})
+  // rawtypes+unchecked: using Class instance, unused: parameter needed for type inference.
+  // IntelliJ can warn that this is redundant when it is not.
   static <T> InstanceOfAssertFactory<Predicate, PredicateAssert<T>> predicate(Class<T> type) {
     return new InstanceOfAssertFactory<>(Predicate.class, Assertions::<T> assertThat);
   }
@@ -129,7 +131,9 @@ static <T> InstanceOfAssertFactory<Predicate, PredicateAssert<T>> predicate(Clas
    *
    * @see #COMPLETABLE_FUTURE
    */
-  @SuppressWarnings({ "rawtypes", "unused" }) // rawtypes: using Class instance, unused: parameter needed for type inference
+  @SuppressWarnings({"rawtypes", "unused", "unchecked", "RedundantSuppression"})
+  // rawtypes+unchecked: using Class instance, unused: parameter needed for type inference.
+  // IntelliJ can warn that this is redundant when it is not.
   static <RESULT> InstanceOfAssertFactory<CompletableFuture, CompletableFutureAssert<RESULT>> completableFuture(Class<RESULT> resultType) {
     return new InstanceOfAssertFactory<>(CompletableFuture.class, Assertions::<RESULT> assertThat);
   }
@@ -151,7 +155,9 @@ static <RESULT> InstanceOfAssertFactory<CompletableFuture, CompletableFutureAsse
    *
    * @see #COMPLETION_STAGE
    */
-  @SuppressWarnings({ "rawtypes", "unused" }) // rawtypes: using Class instance, unused: parameter needed for type inference
+  @SuppressWarnings({"rawtypes", "unused", "unchecked", "RedundantSuppression"})
+  // rawtypes+unchecked: using Class instance, unused: parameter needed for type inference.
+  // IntelliJ can warn that this is redundant when it is not.
   static <RESULT> InstanceOfAssertFactory<CompletionStage, CompletableFutureAssert<RESULT>> completionStage(Class<RESULT> resultType) {
     return new InstanceOfAssertFactory<>(CompletionStage.class, Assertions::<RESULT> assertThat);
   }
@@ -173,7 +179,9 @@ static <RESULT> InstanceOfAssertFactory<CompletionStage, CompletableFutureAssert
    *
    * @see #OPTIONAL
    */
-  @SuppressWarnings({ "rawtypes", "unused" }) // rawtypes: using Class instance, unused: parameter needed for type inference
+  @SuppressWarnings({"rawtypes", "unused", "unchecked", "RedundantSuppression"})
+  // rawtypes+unchecked: using Class instance, unused: parameter needed for type inference.
+  // IntelliJ can warn that this is redundant when it is not.
   static <VALUE> InstanceOfAssertFactory<Optional, OptionalAssert<VALUE>> optional(Class<VALUE> resultType) {
     return new InstanceOfAssertFactory<>(Optional.class, Assertions::<VALUE> assertThat);
   }
@@ -338,7 +346,9 @@ static <VALUE> InstanceOfAssertFactory<Optional, OptionalAssert<VALUE>> optional
    *
    * @see #FUTURE
    */
-  @SuppressWarnings({ "rawtypes", "unused" }) // rawtypes: using Class instance, unused: parameter needed for type inference
+  @SuppressWarnings({"rawtypes", "unused", "unchecked", "RedundantSuppression"})
+  // rawtypes+unchecked: using Class instance, unused: parameter needed for type inference.
+  // IntelliJ can warn that this is redundant when it is not.
   static <RESULT> InstanceOfAssertFactory<Future, FutureAssert<RESULT>> future(Class<RESULT> resultType) {
     return new InstanceOfAssertFactory<>(Future.class, Assertions::<RESULT> assertThat);
   }
@@ -574,7 +584,9 @@ static <ELEMENT> InstanceOfAssertFactory<ELEMENT[][], Object2DArrayAssert<ELEMEN
    *
    * @see #ATOMIC_INTEGER_FIELD_UPDATER
    */
-  @SuppressWarnings({ "rawtypes", "unused" }) // rawtypes: using Class instance, unused: parameter needed for type inference
+  @SuppressWarnings({"rawtypes", "unused", "unchecked", "RedundantSuppression"})
+  // rawtypes+unchecked: using Class instance, unused: parameter needed for type inference.
+  // IntelliJ can warn that this is redundant when it is not.
   static <OBJECT> InstanceOfAssertFactory<AtomicIntegerFieldUpdater, AtomicIntegerFieldUpdaterAssert<OBJECT>> atomicIntegerFieldUpdater(Class<OBJECT> objectType) {
     return new InstanceOfAssertFactory<>(AtomicIntegerFieldUpdater.class, Assertions::<OBJECT> assertThat);
   }
@@ -614,7 +626,9 @@ static <OBJECT> InstanceOfAssertFactory<AtomicIntegerFieldUpdater, AtomicInteger
    *
    * @see #ATOMIC_LONG_FIELD_UPDATER
    */
-  @SuppressWarnings({ "rawtypes", "unused" }) // rawtypes: using Class instance, unused: parameter needed for type inference
+  @SuppressWarnings({"rawtypes", "unused", "unchecked", "RedundantSuppression"})
+  // rawtypes+unchecked: using Class instance, unused: parameter needed for type inference.
+  // IntelliJ can warn that this is redundant when it is not.
   static <OBJECT> InstanceOfAssertFactory<AtomicLongFieldUpdater, AtomicLongFieldUpdaterAssert<OBJECT>> atomicLongFieldUpdater(Class<OBJECT> objectType) {
     return new InstanceOfAssertFactory<>(AtomicLongFieldUpdater.class, Assertions::<OBJECT> assertThat);
   }
@@ -636,7 +650,9 @@ static <OBJECT> InstanceOfAssertFactory<AtomicLongFieldUpdater, AtomicLongFieldU
    *
    * @see #ATOMIC_REFERENCE
    */
-  @SuppressWarnings({ "rawtypes", "unused" }) // rawtypes: using Class instance, unused: parameter needed for type inference
+  @SuppressWarnings({"rawtypes", "unused", "unchecked", "RedundantSuppression"})
+  // rawtypes+unchecked: using Class instance, unused: parameter needed for type inference.
+  // IntelliJ can warn that this is redundant when it is not.
   static <VALUE> InstanceOfAssertFactory<AtomicReference, AtomicReferenceAssert<VALUE>> atomicReference(Class<VALUE> valueType) {
     return new InstanceOfAssertFactory<>(AtomicReference.class, Assertions::<VALUE> assertThat);
   }
@@ -658,7 +674,9 @@ static <VALUE> InstanceOfAssertFactory<AtomicReference, AtomicReferenceAssert<VA
    *
    * @see #ATOMIC_REFERENCE_ARRAY
    */
-  @SuppressWarnings({ "rawtypes", "unused" }) // rawtypes: using Class instance, unused: parameter needed for type inference
+  @SuppressWarnings({"rawtypes", "unused", "unchecked", "RedundantSuppression"})
+  // rawtypes+unchecked: using Class instance, unused: parameter needed for type inference.
+  // IntelliJ can warn that this is redundant when it is not.
   static <ELEMENT> InstanceOfAssertFactory<AtomicReferenceArray, AtomicReferenceArrayAssert<ELEMENT>> atomicReferenceArray(Class<ELEMENT> elementType) {
     return new InstanceOfAssertFactory<>(AtomicReferenceArray.class, Assertions::<ELEMENT> assertThat);
   }
@@ -683,7 +701,9 @@ static <ELEMENT> InstanceOfAssertFactory<AtomicReferenceArray, AtomicReferenceAr
    *
    * @see #ATOMIC_REFERENCE_FIELD_UPDATER
    */
-  @SuppressWarnings({ "rawtypes", "unused" }) // rawtypes: using Class instance, unused: parameter needed for type inference
+  @SuppressWarnings({"rawtypes", "unused", "unchecked", "RedundantSuppression"})
+  // rawtypes+unchecked: using Class instance, unused: parameter needed for type inference.
+  // IntelliJ can warn that this is redundant when it is not.
   static <FIELD, OBJECT> InstanceOfAssertFactory<AtomicReferenceFieldUpdater, AtomicReferenceFieldUpdaterAssert<FIELD, OBJECT>> atomicReferenceFieldUpdater(Class<FIELD> fieldType,
                                                                                                                                                             Class<OBJECT> objectType) {
     return new InstanceOfAssertFactory<>(AtomicReferenceFieldUpdater.class, Assertions::<FIELD, OBJECT> assertThat);
@@ -706,7 +726,9 @@ static <FIELD, OBJECT> InstanceOfAssertFactory<AtomicReferenceFieldUpdater, Atom
    *
    * @see #ATOMIC_MARKABLE_REFERENCE
    */
-  @SuppressWarnings({ "rawtypes", "unused" }) // rawtypes: using Class instance, unused: parameter needed for type inference
+  @SuppressWarnings({"rawtypes", "unused", "unchecked", "RedundantSuppression"})
+  // rawtypes+unchecked: using Class instance, unused: parameter needed for type inference.
+  // IntelliJ can warn that this is redundant when it is not.
   static <VALUE> InstanceOfAssertFactory<AtomicMarkableReference, AtomicMarkableReferenceAssert<VALUE>> atomicMarkableReference(Class<VALUE> valueType) {
     return new InstanceOfAssertFactory<>(AtomicMarkableReference.class, Assertions::<VALUE> assertThat);
   }
@@ -728,7 +750,9 @@ static <VALUE> InstanceOfAssertFactory<AtomicMarkableReference, AtomicMarkableRe
    *
    * @see #ATOMIC_STAMPED_REFERENCE
    */
-  @SuppressWarnings({ "rawtypes", "unused" }) // rawtypes: using Class instance, unused: parameter needed for type inference
+  @SuppressWarnings({"rawtypes", "unused", "unchecked", "RedundantSuppression"})
+  // rawtypes+unchecked: using Class instance, unused: parameter needed for type inference.
+  // IntelliJ can warn that this is redundant when it is not.
   static <VALUE> InstanceOfAssertFactory<AtomicStampedReference, AtomicStampedReferenceAssert<VALUE>> atomicStampedReference(Class<VALUE> valueType) {
     return new InstanceOfAssertFactory<>(AtomicStampedReference.class, Assertions::<VALUE> assertThat);
   }
@@ -794,7 +818,9 @@ static <T extends Throwable> InstanceOfAssertFactory<T, AbstractThrowableAssert<
    *
    * @see #ITERABLE
    */
-  @SuppressWarnings({ "rawtypes", "unused" }) // rawtypes: using Class instance, unused: parameter needed for type inference
+  @SuppressWarnings({"rawtypes", "unused", "unchecked", "RedundantSuppression"})
+  // rawtypes+unchecked: using Class instance, unused: parameter needed for type inference.
+  // IntelliJ can warn that this is redundant when it is not.
   static <ELEMENT> InstanceOfAssertFactory<Iterable, IterableAssert<ELEMENT>> iterable(Class<ELEMENT> elementType) {
     return new InstanceOfAssertFactory<>(Iterable.class, Assertions::<ELEMENT> assertThat);
   }
@@ -816,7 +842,9 @@ static <ELEMENT> InstanceOfAssertFactory<Iterable, IterableAssert<ELEMENT>> iter
    *
    * @see #ITERATOR
    */
-  @SuppressWarnings({ "rawtypes", "unused" }) // rawtypes: using Class instance, unused: parameter needed for type inference
+  @SuppressWarnings({"rawtypes", "unused", "unchecked", "RedundantSuppression"})
+  // rawtypes+unchecked: using Class instance, unused: parameter needed for type inference.
+  // IntelliJ can warn that this is redundant when it is not.
   static <ELEMENT> InstanceOfAssertFactory<Iterator, IteratorAssert<ELEMENT>> iterator(Class<ELEMENT> elementType) {
     return new InstanceOfAssertFactory<>(Iterator.class, Assertions::<ELEMENT> assertThat);
   }
@@ -840,7 +868,9 @@ static <ELEMENT> InstanceOfAssertFactory<Iterator, IteratorAssert<ELEMENT>> iter
    * @see #COLLECTION
    * @since 3.21.0
    */
-  @SuppressWarnings({ "rawtypes", "unused" }) // rawtypes: using Class instance, unused: parameter needed for type inference
+  @SuppressWarnings({"rawtypes", "unused", "unchecked", "RedundantSuppression"})
+  // rawtypes+unchecked: using Class instance, unused: parameter needed for type inference.
+  // IntelliJ can warn that this is redundant when it is not.
   static <E> InstanceOfAssertFactory<Collection, AbstractCollectionAssert<?, Collection<? extends E>, E, ObjectAssert<E>>> collection(Class<E> elementType) {
     return new InstanceOfAssertFactory<>(Collection.class, Assertions::<E> assertThat);
   }
@@ -862,7 +892,9 @@ static <E> InstanceOfAssertFactory<Collection, AbstractCollectionAssert<?, Colle
    *
    * @see #LIST
    */
-  @SuppressWarnings({ "rawtypes", "unused" }) // rawtypes: using Class instance, unused: parameter needed for type inference
+  @SuppressWarnings({"rawtypes", "unused", "unchecked", "RedundantSuppression"})
+  // rawtypes+unchecked: using Class instance, unused: parameter needed for type inference.
+  // IntelliJ can warn that this is redundant when it is not.
   static <ELEMENT> InstanceOfAssertFactory<List, ListAssert<ELEMENT>> list(Class<ELEMENT> elementType) {
     return new InstanceOfAssertFactory<>(List.class, Assertions::<ELEMENT> assertThat);
   }
@@ -884,7 +916,9 @@ static <ELEMENT> InstanceOfAssertFactory<List, ListAssert<ELEMENT>> list(Class<E
    *
    * @see #STREAM
    */
-  @SuppressWarnings({ "rawtypes", "unused" }) // rawtypes: using Class instance, unused: parameter needed for type inference
+  @SuppressWarnings({"rawtypes", "unused", "unchecked", "RedundantSuppression"})
+  // rawtypes+unchecked: using Class instance, unused: parameter needed for type inference.
+  // IntelliJ can warn that this is redundant when it is not.
   static <ELEMENT> InstanceOfAssertFactory<Stream, ListAssert<ELEMENT>> stream(Class<ELEMENT> elementType) {
     return new InstanceOfAssertFactory<>(Stream.class, Assertions::<ELEMENT> assertThat);
   }
@@ -930,7 +964,9 @@ static <ELEMENT> InstanceOfAssertFactory<Stream, ListAssert<ELEMENT>> stream(Cla
    *
    * @see #SPLITERATOR
    */
-  @SuppressWarnings({ "rawtypes", "unused" }) // rawtypes: using Class instance, unused: parameter needed for type inference
+  @SuppressWarnings({"rawtypes", "unused", "unchecked", "RedundantSuppression"})
+  // rawtypes+unchecked: using Class instance, unused: parameter needed for type inference.
+  // IntelliJ can warn that this is redundant when it is not.
   static <ELEMENT> InstanceOfAssertFactory<Spliterator, SpliteratorAssert<ELEMENT>> spliterator(Class<ELEMENT> elementType) {
     return new InstanceOfAssertFactory<>(Spliterator.class, Assertions::<ELEMENT> assertThat);
   }
@@ -954,7 +990,9 @@ static <ELEMENT> InstanceOfAssertFactory<Spliterator, SpliteratorAssert<ELEMENT>
    *
    * @see #MAP
    */
-  @SuppressWarnings({ "rawtypes", "unused" }) // rawtypes: using Class instance, unused: parameter needed for type inference
+  @SuppressWarnings({"rawtypes", "unused", "unchecked", "RedundantSuppression"})
+  // rawtypes+unchecked: using Class instance, unused: parameter needed for type inference.
+  // IntelliJ can warn that this is redundant when it is not.
   static <K, V> InstanceOfAssertFactory<Map, MapAssert<K, V>> map(Class<K> keyType, Class<V> valueType) {
     return new InstanceOfAssertFactory<>(Map.class, Assertions::<K, V> assertThat);
   }

src/main/java/org/assertj/core/api/Java6BDDAssertions.java

@@ -55,6 +55,8 @@
  */
 @Deprecated
 @CheckReturnValue
+// Deprecation is raised by JDK-17. IntelliJ thinks this is redundant when it is not.
+@SuppressWarnings({"DeprecatedIsStillUsed", "deprecation", "RedundantSuppression"})
 public class Java6BDDAssertions {
 
   /**

src/main/java/org/assertj/core/api/ListAssert.java

@@ -220,9 +220,9 @@ private AssertionError actualDoesNotStartWithSequence(AssertionInfo info, Object
                    .failure(info, shouldStartWith("Stream under test", sequence, iterables.getComparisonStrategy()));
   }
 
-  @SuppressWarnings("rawtypes")
-  private ListFromStream asListFromStream() {
-    return (ListFromStream) actual;
+  @SuppressWarnings("unchecked")
+  private ListFromStream<ELEMENT, Stream<ELEMENT>> asListFromStream() {
+    return (ListFromStream<ELEMENT, Stream<ELEMENT>>) actual;
   }
 
   @VisibleForTesting