Avoid javadoc linter warnings (#691)

Author: ktoso

BuildLogic/src/main/kotlin/build-logic.java-common-conventions.gradle.kts

@@ -101,3 +101,8 @@ tasks.withType<Test> {
         this.showStandardStreams = true
     }
 }
+
+// Validate javadoc for html/syntax/reference correctness but skip "missing" (no comment) warnings
+tasks.withType<Javadoc> {
+    (options as StandardJavadocDocletOptions).addStringOption("Xdoclint:all,-missing", "-quiet")
+}

Sources/JExtractSwiftLib/FFM/FFMSwift2JavaGenerator.swift

@@ -299,7 +299,7 @@ extension FFMSwift2JavaGenerator {
 
           /**
            * Assume that the passed {@code MemorySegment} represents a memory address of a {@link \(self.javaClassName(for: decl))}.
-           * <p/>
+           * <p>
            * Warnings:
            * <ul>
            *   <li>No checks are performed about the compatibility of the pointed at memory and the actual \(self.javaClassName(for: decl)) types.</li>

Sources/JExtractSwiftLib/JNI/JNISwift2JavaGenerator+JavaBindingsPrinting.swift

@@ -262,7 +262,7 @@ extension JNISwift2JavaGenerator {
         """
         /**
          * Assume that the passed {@code long} represents a memory address of a {@link \(javaName)}.
-         * <p/>
+         * <p>
          * Warnings:
          * <ul>
          *   <li>No checks are performed about the compatibility of the pointed at memory and the actual \(javaName) types.</li>

SwiftKitCore/src/main/java/org/swift/swiftkit/core/Preconditions.java

@@ -32,7 +32,7 @@
 
 /**
  * Collection of convenience functions to check argument preconditions.
- * <p/>
+ * <p>
  * Partially based on {@code com.google.common.base.Preconditions}.
  */
 public final class Preconditions {

SwiftKitCore/src/main/java/org/swift/swiftkit/core/SwiftInstance.java

@@ -20,30 +20,30 @@ public interface SwiftInstance {
     /**
      * Pointer to the {@code self} of the underlying Swift object or value.
      *
-     * @apiNote When using this pointer one must ensure that the underlying object
-     *          is kept alive using some means (e.g. a class remains retained), as
-     *          this function does not ensure safety of the address in any way.
+     * <b>API Note:</b> When using this pointer one must ensure that the underlying object
+     * is kept alive using some means (e.g. a class remains retained), as
+     * this function does not ensure safety of the address in any way.
      */
     long $memoryAddress();
 
     /**
      * Called when the arena has decided the value should be destroyed.
-     * <p/>
+     * <p>
      * <b>Warning:</b> The cleanup action must not capture {@code this}.
      */
     SwiftInstanceCleanup $createCleanup();
 
     /**
      * Exposes a boolean value which can be used to indicate if the object was destroyed.
-     * <p/>
+     * <p>
      * This is exposing the object, rather than performing the action because we don't want to accidentally
      * form a strong reference to the {@code SwiftInstance} which could prevent the cleanup from running,
      * if using an GC managed instance (e.g. using an {@code AutoSwiftMemorySession}.
      */
     AtomicBoolean $statusDestroyedFlag();
     /**
      * Ensures that this instance has not been destroyed.
-     * <p/>
+     * <p>
      * If this object has been destroyed, calling this method will cause an {@link IllegalStateException}
      * to be thrown. This check should be performed before accessing {@code $memorySegment} to prevent
      * use-after-free errors.

SwiftKitCore/src/main/java/org/swift/swiftkit/core/SwiftLibraries.java

@@ -32,7 +32,7 @@ public final class SwiftLibraries {
 
     /** 
      * Allows for configuration if jextracted types should automatically attempt to load swiftCore and the library type is from.
-     * <p/>
+     * <p>
      * If all libraries you need to load are available in paths passed to {@code -Djava.library.path} this should work correctly,
      * however if attempting to load libraries from e.g. the jar as a resource, you may want to disable this.
      */

SwiftKitCore/src/main/java/org/swift/swiftkit/core/annotations/Unsigned.java

@@ -26,13 +26,13 @@
 
 /**
  * Value is of an unsigned numeric type.
- * <p/>
+ * <p>
  * This annotation is used to annotate java integer primitives when their
  * corresponding Swift type was actually unsigned, e.g. an {@code @Unsigned long}
  * in a method signature corresponds to a Swift {@code UInt64} type, and therefore
  * negative values reported by the signed {@code long} should instead be interpreted positive values,
  * larger than {@code Long.MAX_VALUE} that are just not representable using a signed {@code long}.
- * <p/>
+ * <p>
  * If this annotation is used on a method, it refers to the return type using an unsigned integer.
  */
 @Documented

SwiftKitCore/src/main/java/org/swift/swiftkit/core/collections/SwiftDictionaryMap.java

@@ -22,9 +22,9 @@
 /**
  * A Java {@link java.util.Map} backed by a Swift Dictionary living in Swift's native heap memory.
  * This avoids un-necessary copying of the whole collection in case we're interested only in a few of its elements.
- * <p/>
+ * <p>
  * Methods on this type are implemented as JNI downcalls into the native Swift dictionary, unless specified otherwise.
- * <p/>
+ * <p>
  * You can use {@link #toJavaMap()} to obtain a copy of the data structure on the Java heap.
  *
  * @param <K> the key type, must be a value representable in Swift
@@ -106,7 +106,7 @@ public Set<Entry<K, V>> entrySet() {
      * Make a copy of the dictionary into a Java heap {@link java.util.Map}, 
      * which may be preferable if you are going to perform many operations on the map 
      * and don't expect the changes to be reflected in Swift.
-     * <p/>
+     * <p>
      * This operation DOES NOT perform a deep copy. I.e. if the dictionary contained reference types,
      * the new map will keep pointing at the same objects in the Swift heap.
      * 

SwiftKitCore/src/main/java/org/swift/swiftkit/core/collections/SwiftSet.java

@@ -22,9 +22,9 @@
 /**
  * A Java {@link java.util.Set} backed by a Swift Set living in Swift's native heap memory.
  * This avoids un-necessary copying of the whole collection in case we're interested only in a few of its elements.
- * <p/>
+ * <p>
  * Methods on this type are implemented as JNI downcalls into the native Swift set, unless specified otherwise.
- * <p/>
+ * <p>
  * You can use {@link #toJavaSet()} to obtain a copy of the data structure on the Java heap.
  *
  * @param <E> the element type, must be a value representable in Swift
@@ -108,7 +108,7 @@ public E next() {
      * Make a copy of the set into a Java heap {@link java.util.Set},
      * which may be preferable if you are going to perform many operations on the set
      * and don't expect the changes to be reflected in Swift.
-     * <p/>
+     * <p>
      * This operation DOES NOT perform a deep copy. I.e. if the set contained reference types,
      * the new set will keep pointing at the same objects in the Swift heap.
      *

SwiftKitCore/src/main/java/org/swift/swiftkit/core/tuple/Tuple1.java

@@ -17,6 +17,7 @@
 /**
  * Corresponds to Swift's built-in 1-element tuple type <code>(T0)</code>.
  * Elements are accessed via public final fields <code>$0</code>, <code>$1</code>, etc.
+ * @param <T0> the type of element 0
  */
 public class Tuple1<T0> {
     public final T0 $0;