Fix java formatting (#7703)

PJF is generally what you want for java. I'm biased though since I had
heavy input on the code it produces

---------

Signed-off-by: Robert Kruszewski <github@robertk.io>

Author: robert3005

java/build.gradle.kts

@@ -6,6 +6,7 @@ import net.ltgt.gradle.errorprone.errorprone
 plugins {
     id("com.diffplug.spotless") version "8.4.0"
     id("com.palantir.git-version") version "5.0.0"
+    id("com.palantir.java-format") version "2.90.0"
     id("net.ltgt.errorprone") version "5.1.0" apply false
     id("com.google.protobuf") version "0.10.0" apply false
     id("com.vanniktech.maven.publish") version "0.36.0" apply false
@@ -39,8 +40,13 @@ allprojects {
 
         spotless {
             java {
-                palantirJavaFormat()
+                palantirJavaFormat().formatJavadoc(true)
                 licenseHeaderFile("${rootProject.projectDir}/.spotless/java-license-header.txt")
+                removeUnusedImports()
+                forbidWildcardImports()
+                importOrder("")
+                trimTrailingWhitespace()
+                leadingTabsToSpaces(4)
                 targetExclude("**/generated/**")
                 targetExcludeIfContentContains("// spotless:disabled")
             }

java/vortex-jni/src/main/java/dev/vortex/DateTimeUtil.java

@@ -12,23 +12,20 @@
 /**
  * Utility class for date and time conversions in Vortex.
  *
- * <p>This class provides helper functions for converting Java date/time objects
- * to nanoseconds since the Unix epoch, which is the internal representation
- * used by Vortex for temporal data.</p>
+ * <p>This class provides helper functions for converting Java date/time objects to nanoseconds since the Unix epoch,
+ * which is the internal representation used by Vortex for temporal data.
  *
- * <p>Helpful functions borrowed from Iceberg class with same name.</p>
+ * <p>Helpful functions borrowed from Iceberg class with same name.
  */
 public final class DateTimeUtil {
-    /**
-     * The Unix epoch as an OffsetDateTime (1970-01-01T00:00:00Z).
-     */
+    /** The Unix epoch as an OffsetDateTime (1970-01-01T00:00:00Z). */
     public static final OffsetDateTime EPOCH = Instant.ofEpochSecond(0).atOffset(ZoneOffset.UTC);
 
     /**
      * Converts a LocalDateTime to nanoseconds since the Unix epoch.
      *
-     * <p>The LocalDateTime is assumed to be in UTC timezone for conversion purposes.
-     * When decoded back to LocalDateTime, the timezone information will not be preserved.</p>
+     * <p>The LocalDateTime is assumed to be in UTC timezone for conversion purposes. When decoded back to
+     * LocalDateTime, the timezone information will not be preserved.
      *
      * @param dateTime the LocalDateTime to convert
      * @return nanoseconds since the Unix epoch
@@ -40,7 +37,7 @@ public static long nanosFromTimestamp(LocalDateTime dateTime) {
     /**
      * Converts an OffsetDateTime to nanoseconds since the Unix epoch.
      *
-     * <p>The timezone information in the OffsetDateTime is preserved during conversion.</p>
+     * <p>The timezone information in the OffsetDateTime is preserved during conversion.
      *
      * @param dateTime the OffsetDateTime to convert
      * @return nanoseconds since the Unix epoch

java/vortex-jni/src/main/java/dev/vortex/api/DataSource.java

@@ -18,12 +18,10 @@
 import org.apache.arrow.vector.types.pojo.Schema;
 
 /**
- * A set of Vortex files opened through a {@link Session}. Data sources are cheap to open
- * (only the first file is read eagerly, to determine the schema) and can be scanned
- * multiple times.
+ * A set of Vortex files opened through a {@link Session}. Data sources are cheap to open (only the first file is read
+ * eagerly, to determine the schema) and can be scanned multiple times.
  *
- * <p>Native resources are released automatically via {@link VortexCleaner} when the
- * data source becomes unreachable.
+ * <p>Native resources are released automatically via {@link VortexCleaner} when the data source becomes unreachable.
  */
 public final class DataSource {
     private final Session session;
@@ -42,8 +40,8 @@ public static DataSource open(Session session, String uri) {
     }
 
     /**
-     * Open one or more URIs or globs. When a glob is used, the first match is opened eagerly;
-     * subsequent matches are opened lazily on scan.
+     * Open one or more URIs or globs. When a glob is used, the first match is opened eagerly; subsequent matches are
+     * opened lazily on scan.
      *
      * @param session open session
      * @param uri single URI or glob
@@ -54,8 +52,8 @@ public static DataSource open(Session session, String uri, Map<String, String> p
     }
 
     /**
-     * Open one or more URIs or globs. When a glob is used, the first match is opened eagerly;
-     * subsequent matches are opened lazily on scan.
+     * Open one or more URIs or globs. When a glob is used, the first match is opened eagerly; subsequent matches are
+     * opened lazily on scan.
      *
      * @param session open session
      * @param uris URIs or globs to scan
@@ -82,9 +80,8 @@ public Schema arrowSchema(BufferAllocator allocator) {
     }
 
     /**
-     * Row count along with the precision of that estimate. Mirrors the Rust
-     * {@code Option<Precision<u64>>} returned by {@code DataSource::row_count}:
-     * {@link RowCount.Unknown} when no estimate is available, {@link RowCount.Estimate}
+     * Row count along with the precision of that estimate. Mirrors the Rust {@code Option<Precision<u64>>} returned by
+     * {@code DataSource::row_count}: {@link RowCount.Unknown} when no estimate is available, {@link RowCount.Estimate}
      * for an inexact hint, {@link RowCount.Exact} when the count is authoritative.
      */
     public RowCount rowCount() {

java/vortex-jni/src/main/java/dev/vortex/api/Expression.java

@@ -11,10 +11,9 @@
 /**
  * A Vortex expression node backed by a native pointer.
  *
- * <p>Expressions are composed via the static factories ({@link #root()}, {@link
- * #getItem(String, Expression)}, etc.). Each returned {@code Expression} owns its native
- * pointer; the pointer is released automatically when the {@code Expression} is no longer
- * reachable. Passing an expression as an input to a builder does <em>not</em> transfer
+ * <p>Expressions are composed via the static factories ({@link #root()}, {@link #getItem(String, Expression)}, etc.).
+ * Each returned {@code Expression} owns its native pointer; the pointer is released automatically when the
+ * {@code Expression} is no longer reachable. Passing an expression as an input to a builder does <em>not</em> transfer
  * ownership — the resulting expression is an independent copy on the native side.
  */
 public final class Expression {

java/vortex-jni/src/main/java/dev/vortex/api/Partition.java

@@ -14,10 +14,10 @@
 import org.apache.arrow.vector.ipc.ArrowReader;
 
 /**
- * A unit of scan work that materializes into an Arrow stream. Partitions are single-pass:
- * calling {@link #scanArrow(BufferAllocator)} consumes the partition and transfers
- * ownership of its native memory to the returned {@link ArrowReader}. If the partition
- * is never consumed, its native memory is released automatically via {@link VortexCleaner}.
+ * A unit of scan work that materializes into an Arrow stream. Partitions are single-pass: calling
+ * {@link #scanArrow(BufferAllocator)} consumes the partition and transfers ownership of its native memory to the
+ * returned {@link ArrowReader}. If the partition is never consumed, its native memory is released automatically via
+ * {@link VortexCleaner}.
  */
 public final class Partition {
     private final Session session;
@@ -52,9 +52,8 @@ public OptionalLong rowCount() {
     }
 
     /**
-     * Consume the partition and return an {@link ArrowReader} that yields record batches.
-     * The caller must close the reader when finished; doing so releases the native partition
-     * resources as well.
+     * Consume the partition and return an {@link ArrowReader} that yields record batches. The caller must close the
+     * reader when finished; doing so releases the native partition resources as well.
      */
     public ArrowReader scanArrow(BufferAllocator allocator) {
         if (!consumed.compareAndSet(false, true)) {

java/vortex-jni/src/main/java/dev/vortex/api/Scan.java

@@ -16,9 +16,8 @@
 /**
  * A lazy handle to a set of {@link Partition partitions}.
  *
- * <p>Once a scan has produced its last partition it is effectively exhausted; native
- * resources are released automatically via {@link VortexCleaner} when the scan becomes
- * unreachable.
+ * <p>Once a scan has produced its last partition it is effectively exhausted; native resources are released
+ * automatically via {@link VortexCleaner} when the scan becomes unreachable.
  */
 public final class Scan implements Iterator<Partition> {
     private final Session session;
@@ -39,8 +38,7 @@ static Scan fromPointer(Session session, long pointer) {
     }
 
     /**
-     * Arrow schema produced by this scan. Must be called before the first call to
-     * {@link #hasNext()}/{@link #next()}.
+     * Arrow schema produced by this scan. Must be called before the first call to {@link #hasNext()}/{@link #next()}.
      */
     public Schema arrowSchema(BufferAllocator allocator) {
         try (ArrowSchema schema = ArrowSchema.allocateNew(allocator)) {

java/vortex-jni/src/main/java/dev/vortex/api/ScanOptions.java

@@ -10,8 +10,7 @@
 /**
  * Scan configuration passed to {@link DataSource#scan(ScanOptions)}.
  *
- * <p>All fields are optional. A call to {@link #of()} returns a default that reads every
- * row and column.
+ * <p>All fields are optional. A call to {@link #of()} returns a default that reads every row and column.
  */
 @Value.Immutable
 public interface ScanOptions {
@@ -29,8 +28,8 @@ public interface ScanOptions {
     OptionalLong rowRangeEnd();
 
     /**
-     * Sorted ascending row indices that should be included in (or excluded from) the scan,
-     * depending on {@link #selectionMode()}.
+     * Sorted ascending row indices that should be included in (or excluded from) the scan, depending on
+     * {@link #selectionMode()}.
      */
     Optional<long[]> selectionIndices();
 

java/vortex-jni/src/main/java/dev/vortex/api/Session.java

@@ -8,15 +8,13 @@
 import dev.vortex.jni.NativeSession;
 
 /**
- * Handle to a native Vortex session. The session owns a current-thread async runtime and
- * is the entry point for opening {@link DataSource data sources} and {@link VortexWriter
- * writers}.
+ * Handle to a native Vortex session. The session owns a current-thread async runtime and is the entry point for opening
+ * {@link DataSource data sources} and {@link VortexWriter writers}.
  *
- * <p>Sessions are safe to share across threads within a process, though concrete
- * operations (scans, writes) remain single-threaded on the session's runtime thread.
+ * <p>Sessions are safe to share across threads within a process, though concrete operations (scans, writes) remain
+ * single-threaded on the session's runtime thread.
  *
- * <p>Native resources are released automatically when the session becomes unreachable,
- * via {@link VortexCleaner}.
+ * <p>Native resources are released automatically when the session becomes unreachable, via {@link VortexCleaner}.
  */
 public final class Session {
     private final long pointer;

java/vortex-jni/src/main/java/dev/vortex/api/VortexWriter.java

@@ -18,15 +18,13 @@
 /**
  * Writer for Vortex files.
  *
- * <p>Batches are accepted via the Arrow C Data Interface: callers export an Arrow record
- * batch to an {@code ArrowArray} / {@code ArrowSchema} pair and pass the addresses to
- * {@link #writeBatch(long, long)}. The writer accepts up to four in-flight batches
- * on the session's runtime thread before back-pressuring the caller.
+ * <p>Batches are accepted via the Arrow C Data Interface: callers export an Arrow record batch to an {@code ArrowArray}
+ * / {@code ArrowSchema} pair and pass the addresses to {@link #writeBatch(long, long)}. The writer accepts up to four
+ * in-flight batches on the session's runtime thread before back-pressuring the caller.
  *
- * <p>Call {@link #close()} to flush remaining batches and finalize the file. If the writer
- * becomes unreachable without an explicit {@code close()}, {@link VortexCleaner} will flush
- * and release native resources as a backstop — but callers should always finalize
- * explicitly so that I/O errors surface through the normal call path.
+ * <p>Call {@link #close()} to flush remaining batches and finalize the file. If the writer becomes unreachable without
+ * an explicit {@code close()}, {@link VortexCleaner} will flush and release native resources as a backstop — but
+ * callers should always finalize explicitly so that I/O errors surface through the normal call path.
  */
 public final class VortexWriter implements AutoCloseable {
     private final long pointer;
@@ -44,8 +42,8 @@ private VortexWriter(long pointer) {
     }
 
     /**
-     * Create a writer that streams records into the file at {@code uri}. The Arrow schema
-     * describes the exact layout of every batch written.
+     * Create a writer that streams records into the file at {@code uri}. The Arrow schema describes the exact layout of
+     * every batch written.
      */
     public static VortexWriter create(
             Session session, String uri, Schema arrowSchema, Map<String, String> options, BufferAllocator allocator)

java/vortex-jni/src/main/java/dev/vortex/arrow/ArrowAllocation.java

@@ -8,11 +8,9 @@
 
 /**
  * Utility class for managing Apache Arrow memory allocation.
- * <p>
- * This class provides a global shared root allocator for Arrow memory operations
- * used throughout the Vortex JNI layer. The allocator is configured with the maximum
- * available heap size to allow for efficient memory management.
- * </p>
+ *
+ * <p>This class provides a global shared root allocator for Arrow memory operations used throughout the Vortex JNI
+ * layer. The allocator is configured with the maximum available heap size to allow for efficient memory management.
  */
 public final class ArrowAllocation {
     private static final RootAllocator ROOT_ALLOCATOR = new RootAllocator(Long.MAX_VALUE);
@@ -21,11 +19,9 @@ private ArrowAllocation() {}
 
     /**
      * Returns the shared root allocator instance for Apache Arrow operations.
-     * <p>
-     * This allocator is shared across all Arrow operations in the JVM and is configured
-     * to use the maximum available memory. It should be used as the parent allocator
-     * for all Arrow memory operations within the Vortex system.
-     * </p>
+     *
+     * <p>This allocator is shared across all Arrow operations in the JVM and is configured to use the maximum available
+     * memory. It should be used as the parent allocator for all Arrow memory operations within the Vortex system.
      *
      * @return the shared {@link BufferAllocator} instance
      */