swiftlang/swift-java

This system is a toolchain for bidirectional interoperability between Swift and Java, enabling Swift code to call Java APIs and Java code to invoke Swift functions. It provides build plugins and command-line tools to automatically generate type-safe bindings, supporting both the Java Native Interface (JNI) and the Foreign Function & Memory (FFM) API. The framework includes runtime libraries for memory management, exception handling, and dependency resolution, along with comprehensive samples and tests to validate cross-language integration.

77 changes.

The project was initialized with core infrastructure, including Gradle build logic, Docker environments, and comprehensive documentation. Significant effort focused on establishing bidirectional Swift-Java interoperability through the introduction of JExtractSwift and SwiftJava plugins, alongside the development of JNI and FFM code generation backends. This period also saw the creation of extensive sample applications and test suites to validate the new bridging capabilities.

15 changes.

This period focused on building a reusable, language-neutral Swift analysis module (SwiftExtract) to decouple source parsing from code generation. It introduced native support for Swift collections in JNI bridging, implemented a generic CodePrinter with Java 23 Javadoc support, and established automation scripts for documentation and release workflows.

The tool library now includes support for Android API versioning and deeper Java class introspection. It introduces an \AndroidAPILevel\ enum mirroring Android SDK version codes and an \AndroidAPIVersions\ parser that reads \api-versions.xml\ to track when classes, methods, and fields were introduced, removed, or deprecated. Additionally, a new \JavaClassFileReader\ parses JVM \.class\ files to extract RuntimeInvisibleAnnotations (such as \@RequiresApi\), enabling the tool to respect class-retained annotations that are not visible via standard reflection.

Sources/SwiftJavaToolLib · high confidence

The JavaDependencySampleApp now includes a ci-validate.sh script that automates the build and dependency resolution process, specifically handling the disabling of experimental prebuilts on non-Darwin platforms to work around known issues. Additionally, symbolic links for the Gradle wrapper (gradlew, gradlew.bat, and the gradle directory) have been added to ensure the sample app can correctly invoke the shared Gradle tooling for dependency management.

Samples/JavaDependencySampleApp · high confidence

Introduces the ExampleSwiftLibrary source file, providing a plain Swift implementation of various global functions and a class (MySwiftClass) designed to be exported to Java via the jextract-swift tool. The library demonstrates support for exporting Swift functions that accept and return primitive types (Int, Long, Double), functional interfaces (Runnable, Suppliers, Consumers, Predicates, Unary/Binary Operators), and raw buffer pointers, along with a Swift class featuring properties, initializers, and methods to validate cross-language binding.

Sources/ExampleSwiftLibrary · high confidence

The tool now includes a binding for the Java \java.lang.ClassLoader\ class, exposing the \loadClass\ instance method and the \getSystemClassLoader\ static method to Swift code, enabling direct interaction with Java's class loading mechanisms.

Sources/SwiftJavaTool/Java · high confidence

The JavaDependencySampleApp now includes a sample demonstrating the use of the Apache Commons CSV library. This addition introduces a configuration file that declares the \org.apache.commons:commons-csv:1.12.0\ dependency and specifies the Java classes to be wrapped (such as \CSVFormat\, \CSVParser\, and \CSVRecord\), along with a dummy source file to satisfy build requirements.

Samples/JavaDependencySampleApp/Sources/JavaCommonsCSV · high confidence

The sample application now includes a new Java entry point, HelloJava2Swift.java, which demonstrates calling Swift code from Java using both Foreign Function & Memory (FFM) and JNI. The example showcases key interoperability features such as passing strings, integers, and data objects, managing Swift object lifecycles with arenas, handling callbacks, and resolving overloaded function signatures.

Samples/SwiftJavaExtractFFMSampleApp/src/main · high confidence

The JExtract tool now includes built-in support for mapping Swift types to specific Java counterparts. This change adds definitions for native-backed Swift collections (SwiftDictionaryMap, SwiftSet), standard JDK functional interfaces (such as IntSupplier, LongConsumer, and various Unary/Binary operators), and Swift tuple types (including labeled tuples with arity up to 24). It also introduces handling for Swift errors via SwiftJavaErrorException and integer overflow checks via SwiftIntegerOverflowException, enabling more accurate and idiatic Java bindings for these Swift constructs.

Sources/JExtractSwiftLib/JavaTypes · high confidence

The JavaDependencySample app now includes a demonstration of integrating Java libraries, specifically Apache Commons IO and Commons CSV. The sample code initializes a JVM, retrieves the file extension for a path using FilenameUtils, and parses a CSV string using CSVFormat, illustrating how Swift code can interact with these Java dependencies.

Samples/JavaDependencySampleApp/Sources/JavaDependencySample · high confidence

A new sample application, JavaProbablyPrime, has been added to demonstrate using SwiftJava to call Java APIs from a Swift command-line tool. The sample includes a Swift source file that uses ArgumentParser to accept a number and a certainty level, then utilizes the java.math.BigInteger class (mapped via swift-java.config) to check if the input number is probably prime.

Samples/JavaProbablyPrime/Sources · high confidence

A new sample project, JavaProbablyPrime, has been added to demonstrate how to use Java APIs from Swift. It shows how to wrap the java.math.BigInteger type using the SwiftJavaPlugin build tool plugin and call its isProbablePrime method. The sample includes a README explaining the usage and a CI validation script to verify the functionality.

Samples/JavaProbablyPrime · high confidence

A new sample project, JavaSieve, has been added to demonstrate how to import and use a Java library distributed as a JAR file within Swift. The sample includes configuration files (swift-java.config) to map Java classes like SieveOfEratosthenes to Swift types, and source code showing how to initialize the JVM and call Java methods, such as finding prime numbers, directly from Swift.

Samples/JavaSieve · high confidence

The SwiftJava Exceptions module now provides seamless interoperability between Java exceptions and Swift's error handling. Users can now check if a Java exception is checked or unchecked via the new \isCheckedException\ property on \Exception\ and \Throwable\ classes. Additionally, \Throwable\ instances automatically conform to Swift's \Error\ protocol, allowing them to be thrown and caught using standard Swift \do-catch\ blocks. The \JNIEnvironment\ extension adds helper methods to translate JNI exceptions into Swift errors (\translatingJNIExceptions\), throw Swift errors as Java exceptions (\throwAsException\), and throw specific Java exceptions (\throwJavaException\), simplifying error propagation across the Swift-Java boundary.

Sources/SwiftJava/Exceptions · high confidence

A new Swift source file, SwiftTypeInSubDirectory.swift, has been added to the LibrarySubDirectory of the MySwiftLibrary sample. This file defines a public final class containing a hello method that returns an integer, serving as a sample implementation for the SwiftJavaExtractFFMSampleApp.

Samples/SwiftJavaExtractFFMSampleApp/Sources/MySwiftLibrary/LibrarySubDirectory · high confidence

The sample application now includes a new JNI implementation file that exposes the \com.example.swift.HelloJava2Swift\ Java class to Swift. This file defines the \HelloJava2SwiftNativeMethods\ protocol and implements two native methods: \jniWriteString\, which returns the character count of a provided message, and \jniGetInt\, which returns a fixed integer value of 12.

Samples/SwiftJavaExtractFFMSampleApp/Sources/MySwiftLibrary/jni · high confidence

A new sample application (HelloJava2SwiftJNI.java) has been added to demonstrate interoperability between Java and Swift via JNI. The sample illustrates how to use the SwiftKit library to call Swift functions from Java, manage memory using SwiftArena, and interact with Swift classes and structs.

Samples/SwiftJavaExtractJNISampleApp/src/main · high confidence

Introduces the SwiftJavaError class to wrap Swift errors for safe passage across the FFI boundary, along with generated thunks that expose error descriptions and type information to Java. This change is accompanied by the addition of core runtime helper functions in SwiftRuntimeFunctions.swift, including memory management wrappers (retain, release, retainCount, isUniquelyReferenced), type lookup by string, and string-to-C-string conversion, enabling robust error propagation and object lifecycle management in FFM/JNI modes.

Sources/SwiftRuntimeFunctions · high confidence

This change introduces a new \JavaLangReflect\ module that provides convenience extensions for Java reflection types. It adds modifier-checking properties (such as \isPublic\, \isStatic\, \isNative\, and \isFinal\) to \Constructor\, \Method\, and \Field\ via a shared \HasJavaModifiers\ protocol, and adds \throwsCheckedException\ to \Executable\. It also includes \CustomStringConvertible\ implementations for \Type\, \ParameterizedType\, and \TypeVariable\, along with a configuration file mapping Java reflection classes to their Swift counterparts.

Sources/JavaStdlib/JavaLangReflect · high confidence

A new shell script (ci-validate.sh) has been added to the JavaKitSampleApp sample to automate validation of the Java integration. The script builds the project with tests, runs the generated Java application entry points (including one with Swift-based argument parsing), and executes the Swift test suite, while applying a workaround to disable experimental prebuilts on non-Darwin platforms.

Samples/JavaKitSampleApp · high confidence

A new benchmark file has been added to the Benchmarks module to measure the performance of simple calls to the Java library, specifically testing the retrieval of default user interaction settings from the URLConnection class via the SwiftJava bridge.

Benchmarks · high confidence

A new configuration file (swift-java.config) has been added to the JavaIO module, defining mappings for key Java IO classes including BufferedInputStream, InputStreamReader, Reader, FileReader, StringReader, FileDescriptor, and WatchService. This establishes the binding configuration required for these specific standard library components within the SwiftJava framework.

Sources/JavaStdlib/JavaIO · high confidence

Users can now easily convert between Swift's Foundation URL and Java's java.net.URL via new extension methods (fromJava/fromSwift) in JavaURL+URIConversions.swift. The JavaNet module configuration has been updated to explicitly extend java.net.URL, java.io.File, and java.nio.file.Path, and to map java.net.URI, URLClassLoader, URLConnection, and HttpURLConnection to their Swift counterparts.

Sources/JavaStdlib/JavaNet · high confidence

The \MySwiftLibrary\ sample source has been significantly expanded to demonstrate a broader range of \jextract\ JNI capabilities. The library now includes dedicated modules for testing asynchronous methods (\Async.swift\), Swift actors and isolated parameters (\Isolated.swift\), and distributed actors (\Distributed.swift\). Support for complex data structures is demonstrated through new files handling arrays (\Arrays.swift\), dictionaries (\Dictionary.swift\), sets (\CollectionBoxable.swift\), and Foundation types like \Data\, \Date\, \UUID\, and \URL\. The sample also exercises advanced Swift features such as generic types (\GenericType.swift\), protocol inheritance and existential boxes (\ProtocolA\, \ProtocolB\, \ProtocolC\, \ConcreteProtocolAB.swift\), escaping closures (\Closures.swift\, \EscapingClosures.swift\), and custom operators (\Operators.swift\). Additionally, a new \MySwiftDependencyLibrary\ module with a \swift-java.config\ file illustrates cross-module type resolution.

Samples/SwiftJavaExtractJNISampleApp/Sources · high confidence

The \Sources/JavaStdlib/JavaLangReflect/generated\ directory now contains auto-generated Swift wrappers for the \java.lang.reflect\ package, including \AccessibleObject\, \AnnotatedType\, \Annotation\, \Array\, \Constructor\, \Executable\, \Field\, \GenericArrayType\, \GenericDeclaration\, \JavaClass\ extensions, \Method\, \Parameter\, and \ParameterizedType\. These files expose Java reflection capabilities—such as accessing fields, invoking methods, inspecting annotations, and handling generic types—directly in Swift via the \SwiftJava\ and \SwiftJavaJNICore\ modules.

Sources/JavaStdlib/JavaLangReflect/generated · high confidence

The \Sources/JavaStdlib/JavaNet/generated\ directory now contains auto-generated Swift wrappers for core Java networking classes, including \URI\, \URL\, \File\, \Path\, \URLConnection\, \HttpURLConnection\, and \URLClassLoader\. These files expose Java constructors, static fields (such as HTTP status codes in \HttpURLConnection\), and instance methods (like \connect\, \getContentType\, and \toURI\) to Swift, enabling direct interaction with the Java standard library's networking and file-path APIs from Swift code.

Sources/JavaStdlib/JavaNet/generated · high confidence

This update adds auto-generated Swift bindings for the Java \java.util.function\ package, including functional interfaces like \Consumer\, \Function\, \Predicate\, \Supplier\, and their primitive specializations (e.g., \IntConsumer\, \DoubleFunction\). It also introduces extension methods on Swift wrappers for Java collections (\ArrayList\, \HashMap\, \Collection\, \Map\, \Set\, \Optional\, etc.) to expose Java 8+ functional methods such as \forEach\, \removeIf\, \compute\, \map\, and \filter\, enabling idiomatic functional programming patterns when interacting with Java libraries from Swift.

Sources/JavaStdlib/JavaUtilFunction/generated · high confidence

The Swift-Java documentation site is now available, providing comprehensive guides for both directions of interoperability. It covers the \jextract\ tool for exposing Swift code to Java (including JNI and FFM modes, feature support, and binary size optimization) and the \wrap-java\ tool plus JavaKit macros for calling Java from Swift. The documentation also includes specific guides for Android integration (R8/ProGuard rules, Core Library Desugaring, and API availability), the \swift-java\ command-line interface, the SwiftPM build plugins, and the \swift-java.config\ file schema.

Sources/SwiftJavaDocumentation · high confidence

The repository has been initialized with the core project structure, including the Apache 2.0 license, a comprehensive README detailing Swift and Java interoperability tools, and a CONTRIBUTING guide for local CI execution. Build infrastructure is established via Gradle wrapper scripts and configuration, while developer tooling is standardized through \.editorconfig\, \.swift-format\, and \.gitignore\ files to enforce consistent code style and ignore build artifacts.

(repo-wide) · high confidence

The JExtractSwiftLib module now includes a set of new source files (CEnum, CFunction, CParameter, CStruct, CTag, CType, CUnion) that model C types for the purpose of lowering Swift declarations to C. These types provide a structured representation of C enums, structs, unions, functions, and parameters, including support for printing C-compatible type declarations and handling qualifiers like const and volatile.

Sources/JExtractSwiftLib/CTypes · high confidence

The JExtract tool now includes a new CDeclLowering module that translates Swift function signatures into C-compatible \@\_cdecl\ representations. This enables the extraction of Swift APIs by lowering complex types—such as pointers, optionals, and functions—into standard C types, while explicitly rejecting unsupported features like async, isolated, or throwing functions in this specific lowering path. This change provides the foundational type mapping logic required for generating C entrypoints for Swift code.

Sources/JExtractSwiftLib/FFM/CDeclLowering · high confidence

Adds a new Docker setup including a Dockerfile, docker-compose configurations, and a JDK installation script to standardize the build environment. The environment is configured to use Swift nightly builds on Ubuntu Jammy and installs JDK 25 (Amazon Corretto) to support the latest Foreign Function Interface (FFI) while remaining compatible with Gradle, ensuring consistent local and CI execution for Swift and Java tests.

docker · high confidence

The \JExtractSwiftLib/FFM\ module now provides a new code generation path using Java's Foreign Function & Memory API (FFM) alongside the existing JNI approach. This adds support for generating Java bindings for Swift APIs, including specific handling for \Foundation.Data\ (with helpers like \fromByteArray\, \toMemorySegment\, and \toByteBuffer\), Swift tuples, closures, and variadic functions. It also introduces 32-bit integer overflow checking for FFM downcalls and allows configuring the native library name via \swift-java.config\.

Sources/JExtractSwiftLib/FFM · high confidence

SwiftKitFFM now provides two memory arena strategies for managing native Swift resources from Java: a confined arena via \AllocatingSwiftArena.ofConfined()\ for explicit, deterministic cleanup, and an auto arena via \AllocatingSwiftArena.ofAuto()\ that relies on the Java Garbage Collector to trigger native cleanup. This change introduces the \FFMSwiftInstance\ and \FFMSwiftErrorInstance\ base classes to handle memory segments and type metadata, along with \FFMSwiftInstanceCleanup\ to safely destroy native values and detect double-destruction. It also adds runtime utilities for loading Swift libraries, handling C strings, and accessing Swift value witness tables for type layout and destruction.

SwiftKitFFM · high confidence

The \Sources/JExtractSwiftLib/JNI\ location now contains the core implementation for the \jextract\ tool's JNI mode, enabling the automatic generation of Java bindings for Swift code. This change adds the \JNISwift2JavaGenerator\ and its supporting modules to translate Swift types, functions, and protocols into Java classes and JNI thunks. Key capabilities include mapping Swift primitive and standard library types (such as \String\, \Data\, \Date\, and \UUID\) to their Java equivalents, handling complex types like tuples, optionals, and arrays, and supporting escaping closures via \@JavaInterface\ wrappers. The generator also produces the necessary Swift-side thunk code and linker export lists to facilitate efficient interop between Swift and Java applications.

Sources/JExtractSwiftLib/JNI · high confidence

Adds the \JExtractSwiftPlugin\, a Swift Package Manager build tool plugin that integrates with the \swift-java\ CLI to automatically generate Java wrappers and Swift bindings for Swift types. The plugin scans for a \swift-java.config\ file in the target directory, processes Swift source files, and outputs generated Java code and Swift thunk files (e.g., \+SwiftJava.swift\) to the standard SPM output directories. It supports cross-module dependency resolution via \--depends-on\, handles JNI-specific requirements like linker export lists for dead code elimination, and optionally generates Java callback wrappers if enabled in the configuration.

Plugins/JExtractSwiftPlugin · high confidence

The \Sources/SwiftExtract\ directory now contains a standalone, language-neutral Swift analysis module that parses Swift source code and produces an \AnalysisResult\ containing extracted types, functions, variables, and cross-module extensions. This module decouples the analysis logic from any specific target language (such as Java/JNI) by introducing an \ExtractDecider\ protocol that allows downstream generators to define their own extraction policies (e.g., access level filtering, attribute handling) while the core analyzer remains reusable. The analysis result includes support for cross-module extensions, generic type specializations, and Foundation overlay types, providing a structured intermediate representation for downstream code generators to consume.

Sources/SwiftExtract · high confidence

The SwiftExtract module now provides a reusable Swift analysis layer that models extracted Swift types, including support for async/throws effect specifiers, typed throws, isolated parameters, and generic requirements. It introduces a symbol table system with built-in overlays for the Swift and Foundation standard libraries (including FoundationEssentials alternatives and types like URL, Date, and TimeInterval) and adds a dependency scanner that resolves module imports, including those inside \#if canImport blocks, to correctly track alternative modules and main symbol sources.

Sources/SwiftExtract/SwiftTypes · high confidence

The new SwiftJavaMacros module provides the macro infrastructure for interoperating between Swift and Java. It introduces several macros: @JavaClass, @JavaInterface, and @JavaRecord to import Java types into Swift; @ExportToJavaClass to expose Swift types to Java; @JavaImplementation to define Swift extensions that implement native Java methods (including JNI escaping and environment handling); @JavaMethod and @JavaStaticMethod to mark imported Java methods; @JavaField and @JavaStaticField for property access; and @JavaExport as a marker for jextract. The module also includes a GenerationMode enum to distinguish between import, export, and implementation contexts, and a compiler plugin (SwiftJavaMacrosPlugin) that registers these macros.

Sources/SwiftJavaMacros · high confidence

A new Swift Package Plugin named SwiftJavaPlugin has been added to the repository. This plugin enables Swift targets to wrap Java classes by reading a \swift-java.config\ file, resolving Java dependencies, and invoking the \swift-java\ tool to generate Swift wrappers. It supports cross-module type resolution via \--depends-on\ for dependent targets and allows Java classes to be implemented natively in Swift.

Plugins/SwiftJavaPlugin · high confidence

The new SwiftJavaRuntimeSupport module provides the runtime infrastructure for bridging Swift and Java types via JNI. It includes CollectionBridge for converting Swift collections (Dictionary, Set, Optional, Array) to and from Java objects, JextractedTypeBridge to reduce boilerplate for jextract-generated wrappers, and \_JNIBoxedConversions for handling primitive boxing. The module also introduces \_JNIMethodIDCache for efficient JNI method/field lookups with Android core library desugaring support, and defines configuration mappings for core SwiftKit classes like SwiftInstance and SwiftArena.

Sources/SwiftJavaRuntimeSupport · high confidence

The SwiftKitCore module now provides a new memory management model for bridged Swift objects, offering two distinct lifecycle strategies: confined arenas that require explicit closing to release native resources immediately, and auto arenas that rely on the Java garbage collector for eventual cleanup. This change introduces the \SwiftArena\ interface along with \ConfinedSwiftMemorySession\ and \AutoSwiftMemorySession\ implementations, alongside core infrastructure such as \JNISwiftInstance\ for native instance handling, \SwiftInstanceCleanup\ for safe destruction tracking, and \SwiftLibraries\ for automatic dynamic library loading. Users must now manage the lifetime of Swift objects through these arenas to prevent memory leaks or premature deallocation.

SwiftKitCore · high confidence

A new Swift Package Manager build tool plugin has been added to the JavaCompilerPlugin location, enabling the compilation of Java source files (.java) within a target into class files. The plugin scans the target's sources for Java files, reads configuration from a \swift-java.config\ file (supporting JSON5 format), and invokes the \javac\ compiler. It passes the \-parameters\ flag to preserve parameter names for subsequent Swift wrapper generation and respects any compiler version arguments defined in the configuration. The compiled class files are output to the plugin's work directory.

Plugins/JavaCompilerPlugin · high confidence

The code generation system now uses a generic CodePrinter typed by language (Swift or Java) to provide language-appropriate syntax helpers. For Java output, the printer now supports Java 23+ Javadoc comments using Markdown-style line comments (///) with automatic conversion of inline code tags, falling back to traditional block comments for earlier versions. For Swift output, it adds a guard block helper. The printer also includes configurable inline comment styles and an option to disable source-location debug trailers in generated code.

Sources/CodePrinting · high confidence

Adds a new Swift Package Manager plugin (\_StaticBuildConfigPlugin) and its supporting executable (StaticBuildConfigPluginExecutable) that generate a static-build-config.json file during the build process. The executable detects the compiler version at compile time: for Swift 6.3+ it invokes the Swift frontend to print the static build configuration, while for earlier versions (6.1/6.2) it generates a default configuration with language version 5.10 and the corresponding compiler version, ensuring consistent build metadata across supported Swift releases.

_Plugins/\StaticBuildConfigPlugin, Sources/StaticBuildConfigPluginExecutable · high confidence

The \Sources/SwiftJava/BridgedValues\ module now supports passing native Swift \Set\ and \Dictionary\ types across the JNI boundary. This is achieved by introducing the \JobjectBridge\ protocol and \JavaBoxable\ conformance for standard types (String, Int64, Int32, Double, Float, Bool, Int8, UInt8), allowing them to be boxed into Java objects. New extensions on \Dictionary\ and \Set\ provide \dictionaryGetJNIValue\ and \setGetJNIValue\ methods to box these collections into retained pointers, while corresponding \init(fromJNI:)\ initializers reconstruct them on the Swift side. Additionally, \SwiftDictionaryMap\ and \SwiftSet\ Java classes are implemented to expose collection operations (size, get/contains, keys/values, toArray) to Java code via JNI method implementations.

Sources/SwiftJava/BridgedValues · high confidence

This change introduces a new sample project, Samples/SwiftAndJavaJarFFMSampleLib, that demonstrates exporting plain Swift code to Java using the jextract-swift tool and the Foreign Function & Memory (FFM) API. The sample includes Swift sources (MySwiftClass, MySwiftLibrary) exposing methods and global functions, including support for Java functional interfaces such as Supplier, Consumer, Predicate, and various Unary/Binary Operators. It provides a Java entry point (HelloJava2Swift) and an example usage (Example.java) to call the generated bindings, along with a CI validation script, Gradle build files, JMH benchmarks, and comprehensive JUnit tests verifying the interoperability of these Swift-to-Java calls.

Samples/SwiftAndJavaJarFFMSampleLib · high confidence

The repository now includes a set of shell scripts to streamline development and release workflows. \generate-docs.sh\ and \generate-cli-help-snippets.sh\ automate the creation of static DocC HTML documentation and CLI help snippets, ensuring docs stay in sync with the tool. \release.sh\ automates the release process, including pinning dependencies, verifying builds, and creating release branches. \wrap-java-generate.sh\ and \swiftkit-ffm-generate-bindings.sh\ regenerate Swift and Java bindings from configuration files. Additionally, \run-linkage-test.sh\ verifies that the linkage test suite covers all runtime library products and does not accidentally link against Foundation.

scripts · high confidence

This change introduces the \SwiftJavaConfigurationShared\ module, providing the foundational configuration structures and utilities for the SwiftJava tooling. It adds a comprehensive \Configuration\ struct that allows users to define generation parameters such as Java package names, native library loading behavior, variadic overload limits, access levels, and support for specific Java features like async functions and protocol implementation. Additionally, it includes \GradleDependencyParsing.swift\ to handle the parsing of Gradle-style dependency descriptors, enabling the configuration of Java dependencies within the Swift build system.

Sources/SwiftJavaConfigurationShared · high confidence

This change introduces a new \DependencyResolver\ component that allows users to resolve project dependencies to a classpath and check if dependencies are loaded, with configuration managed via \swift-java.config\. Additionally, it adds \TerminalColors\ support, enabling colored output in terminal tools while respecting the \NO\_COLOR\ environment variable and terminal capabilities.

Sources/JavaKitDependencyResolver · high confidence

The \SwiftExtractConfigurationShared\ module now includes \AccessLevelMode\ and \LogLevel\ enums, allowing both the analysis layer and language-specific configuration layers to share common settings without depending on SwiftSyntax. \AccessLevelMode\ defines the minimum access level (public, package, internal) for extraction, while \LogLevel\ provides verbosity levels (trace through critical) for the analysis logger.

Sources/SwiftExtractConfigurationShared · high confidence

The Plugins/PluginsShared directory now provides a centralized set of utilities and protocols for Swift Java plugins, accessible via symlinks to avoid code duplication. This includes robust JAVA\_HOME detection that falls back to SDKMAN and the system PATH, helper functions for locating swift-java.config files, and standardized output directory paths for generated Java and Swift code. It also introduces a common plugin protocol for logging and a dedicated error type for missing configuration, streamlining how individual plugins handle environment setup and shared logic.

Plugins/PluginsShared · high confidence

The Swift-to-Java extraction tool now supports resolving types that live in external Swift modules. By using the new \--depends-on\ flag (or configuring \inputSwiftDirectory\ and \swiftModuleName\ in \swift-java.config\), jextract can load source files from dependent modules and inject synthetic stubs for Java wrapper types, ensuring that cross-module references are correctly resolved during analysis and code generation.

Sources/JExtractSwiftLib · high confidence

SwiftJava now supports Android Core Library Desugaring, automatically mapping desugared classes (such as \java.util.Optional\ variants) to their \j$.\*\ locations on older Android SDKs. Additionally, class lookups now include a fallback to the application class loader when using SwiftJava as a dynamic library, improving reliability in environments where the default loader cannot find wrapped classes.

Sources/SwiftJava · high confidence

The \Snippets\ directory has been restructured to use symlinks pointing to actual sample and test files (e.g., from \SwiftJavaExtractJNISampleApp\ and \JavaKitSampleApp\), ensuring that code snippets in documentation are always compiled and validated. Additionally, a new \Sources/GenerateConfigDocs\ tool has been introduced to automatically regenerate the \SwiftJavaConfigFile.md\ documentation from the \Configuration.swift\ source, keeping the supported configuration options in sync with the code.

Snippets, Sources/GenerateConfigDocs · high confidence

The BuildLogic module has been rewritten in Kotlin DSL, introducing new convention plugins (java-common, java-application, java-library) and utility functions to streamline the build configuration. A key behavioral change is the more reliable detection of Swift runtime library paths using \swiftc -print-target-info\, which ensures that tests and applications can correctly locate native dependencies on both Linux and macOS. Additionally, the build now automatically registers the directories containing generated Java sources from the JExtractSwiftPlugin, allowing IDEs to index these files without requiring a prior build execution.

BuildLogic · high confidence

The SwiftJavaExtractJNISampleApp now includes a ci-validate.sh script and Gradle wrapper symlinks to standardize its build and test execution. The script implements platform-specific workarounds for Swift 6.2.1, disabling experimental prebuilts on non-macOS systems and handling Gradle wrapper download timeouts on GitHub Actions macOS runners by pre-loading the wrapper distribution.

Samples/SwiftJavaExtractJNISampleApp · high confidence

The JavaUtil module now uses a new \swift-java.config\ file to explicitly map Java standard library classes (such as \java.util.ArrayList\, \java.util.HashMap\, and \java.util.Queue\) to their corresponding Swift implementations. This change centralizes the configuration for how these common utility classes are bridged, replacing previous manual or implicit wiring mechanisms with a declarative mapping structure.

Sources/JavaStdlib/JavaUtil · high confidence

The JavaKit sample application has been reorganized into a dedicated sub-package and now includes several new Java source files to demonstrate broader interoperability features. These additions include HelloJavaKitArrays for array handling, HelloSubclass and HelloSwift for class inheritance and native method callbacks, Point to test Java record support, SwiftArgumentParserMain to show Swift-based argument parsing, and ThreadSafe/ThreadSafeHelperClass to demonstrate thread-safety annotations and Java Optional types.

Samples/JavaKitSampleApp/Sources/JavaKitExample/com · high confidence

The MySwiftLibrary sample source files have been replaced with a comprehensive set of Swift declarations designed to exercise the FFM (Foreign Function Manager) extraction mode. The new library includes functions and types for handling Java functional interfaces (such as IntSupplier, LongConsumer, and DoublePredicate), Swift tuples, optionals, and throwing functions. It also adds support for Foundation.Data, UnsafeRawBufferPointer, and typealiases, providing a broader demonstration of how Swift code is translated to Java under the FFM backend.

Samples/SwiftJavaExtractFFMSampleApp/Sources/MySwiftLibrary · high confidence

The JExtractSwiftLib module now includes a set of convenience extensions to support Java type mapping and JNI symbol generation. JavaType gains helpers for computing JNI type signatures, determining optional wrapper types (such as OptionalInt), and handling boxing for primitive types. String extensions provide utilities for escaping JNI identifiers, parsing Java class names from SwiftJava lookups, and generating JNI C symbol names and Java binary names for nested synthetic types. Additionally, a new JavaTypeAnnotations helper detects when Swift unsigned integer types require specific Java annotations.

Sources/JExtractSwiftLib/Convenience · high confidence

The swift-java tool now exposes distinct subcommands to separate concerns: \configure\ generates or amends the \swift-java.config\ file from JARs or classpaths with support for include/exclude filters; \resolve\ fetches Maven-style dependencies and writes the resulting classpath to a module-specific \.swift-java.classpath\ file; \jextract\ handles extracting Java bindings from Swift sources with options for dependency resolution (\--depends-on\), filtering, and single-type generation; \wrap-java\ wraps Java classes into Swift bindings with dependency and filtering support; and \java-callbacks-build\ consolidates the Gradle, javac, configure, and wrap-java steps into a single command to avoid linking Foundation in build plugins. This restructuring disentangles the previous monolithic command flow, giving users explicit control over configuration, dependency resolution, and code generation stages.

Sources/SwiftJavaTool/Commands · high confidence

JavaKit now includes an internal cache for JNI method and class references to optimize the performance of JNI lookups in generated wrappers. This change introduces a new helper class that pre-resolves method IDs and maintains global references to Java classes, reducing the overhead of repeated native calls during runtime.

Sources/JavaKit · high confidence

A new configuration file for the \java.util.function\ module has been introduced, defining Swift type mappings for standard Java functional interfaces (such as \Consumer\, \Function\, \Predicate\, and \Supplier\) and specifying classes to extend, including \java.util.Optional\ variants and common collection types.

Sources/JavaStdlib/JavaUtilFunction · high confidence

The JavaKitExample sample has been reorganized into its own sub-package and updated to demonstrate new language features. The sample now includes a SwiftArgumentParserMain component that shows how Java native entry points can delegate to Swift ArgumentParser commands. The core JavaKitExample.swift implementation has been expanded to showcase optional mapping support, allowing Swift code to handle nullable Java types, and demonstrates the new @ThreadSafe annotation by exposing Sendable conformance for thread-safe Java classes.

Samples/JavaKitSampleApp/Sources/JavaKitExample · high confidence

The JExtract tooling now exposes explicit configuration enums that let users control code generation behavior. Users can choose how Swift \async\ functions are mapped to Java via \JExtractAsyncFuncMode\ (returning \CompletableFuture\ or the legacy \Future\ for older Android platforms). The generation backend is configurable via \JExtractGenerationMode\, allowing a switch between the default Foreign Function and Memory (FFM) API and the Java Native Interface (JNI). Memory management strategies are defined in \JExtractMemoryManagementMode\, offering either explicit \SwiftArena\ usage or an automatic global arena. Additionally, \JavaSourceLevel\ allows targeting specific JDK versions (17–25) to control available language features, such as JDK 18+ JavaDoc snippets, with \JavaSourceFeature\ providing a mechanism to conditionally enable source-level-dependent constructs.

Sources/SwiftJavaConfigurationShared/JExtract · high confidence

The SwiftExtract module introduces a set of convenience extensions to simplify SwiftSyntax analysis and data manipulation. For access control checks, WithModifiersSyntax and DeclModifierSyntax now provide methods like isAtLeast, isPublic, and isAtLeastPackage, replacing the previous passesAccessLevel naming to better reflect their purpose in determining declaration visibility. Collection utilities include mapKeys for transforming dictionary keys, withIsLast to identify the final element in a sequence, and sum for integer collections. String helpers add firstCharacterUppercased, firstCharacterLowercased, dropSwiftFileSuffix, and unescapedSwiftName to handle common formatting and parsing tasks.

Sources/SwiftExtract/Convenience · high confidence

The swift-java command-line tool has been restructured to replace its previous ad-hoc argument parsing with a formal subcommand model (configure, resolve, wrap-java, jextract, and JavaCallbacksBuild). This change introduces shared CommonOptions for consistent handling of output directories, log levels, and configuration paths across all modes, and adds a CommonJVMOptions extension to unify classpath resolution from environment variables, config files, and command-line flags. Additionally, the tool now prevents crashes when no subcommand is specified by printing usage instructions, and introduces a hardcoded exclusion list for specific JDK types (java.lang.Enum) to prevent import errors.

Sources/SwiftJavaTool · high confidence

The generated Swift wrappers for \java.io\ and \java.nio.file\ classes have been regenerated to align with the updated \wrap-java\ tooling. This update refreshes the bindings for \BufferedInputStream\, \FileDescriptor\, \FileReader\, \InputStreamReader\, \Reader\, \StringReader\, and \WatchService\, ensuring that method signatures, inheritance structures, and static fields (such as \FileDescriptor.in\, \out\, and \err\) accurately reflect the current Java standard library definitions.

Sources/JavaStdlib/JavaIO/generated · high confidence

The auto-generated Swift wrappers for \java.util\ classes (including \ArrayDeque\, \ArrayList\, \HashMap\, \HashSet\, \LinkedList\, \PriorityQueue\, \Queue\, \TreeMap\, \TreeSet\, and others) have been regenerated using the \wrap-java\ tool. This update refreshes the generated code to align with the current state of the Java-to-Swift wrapper generator, ensuring the bindings remain consistent with the underlying Java API signatures.

Sources/JavaStdlib/JavaUtil/generated · high confidence

The generated Swift wrappers for the Java-to-Swift runtime support layer have been regenerated, introducing new bindings for core memory management and instance handling. Specifically, the update adds \JavaJNISwiftInstance\ to expose JNI-specific instance methods like \$memoryAddress\ and \$typeMetadataAddress\, defines \JavaSwiftArena\ with an \ofAuto\ factory method and a \register\ capability, and provides \JavaSwiftMemoryManagement\ which exposes the \DEFAULT\_SWIFT\_JAVA\_AUTO\_ARENA\ static field. These changes ensure the Swift side correctly mirrors the updated Java \SwiftInstance\, \SwiftArena\, and \SwiftMemoryManagement\ interfaces.

Sources/SwiftJavaRuntimeSupport/generated · high confidence

The generated Swift bindings in Sources/JavaStdlib/JavaUtilJar have been regenerated using the updated wrap-java tool, introducing stable output ordering. This update refreshes the Swift wrappers for java.util.jar classes (Attributes, JarEntry, JarFile, JarInputStream, JarOutputStream, Manifest) and java.util.zip.ZipEntry, ensuring they align with the current Java signatures and the centralized SwiftJava naming conventions.

Sources/JavaStdlib/JavaUtilJar · high confidence

The auto-generated Swift wrappers for Java classes have been regenerated to include new Swift standard library extensions. \Enumeration\ and \JavaIterator\ now conform to \IteratorProtocol\, and \List\ conforms to \Sequence\, allowing these Java collections to be used directly in Swift \for-in\ loops and other sequence-based APIs. The generated code also reflects updates to the underlying \SwiftJavaJNICore\ module and includes fixes for generic parameter handling and method generation.

Sources/SwiftJava/generated · high confidence

Added JMH benchmarks for Swift-JNI interoperability features; Added JMH benchmarks for Swift-Java interop performance; Added Java test coverage for the FFM sample app; Added Java unit tests for the Swift-JNI sample application; Added LinkageTest to verify SwiftJava module dependencies; Added macro expansion tests for SwiftJava; Added runtime tests for JavaKit sample app; Added test assertion helpers for lowering and output verification; Added test configuration for Java dependencies; Added test coverage for JExtractSwift; Added test coverage for SwiftJavaToolLib WrapJava functionality; Added test suite for SwiftJavaToolLib; Added test support utilities for SwiftExtract analysis; Added tests for Android desugaring and basic Java runtime interactions; Added tests for FFM code generation capabilities; Added tests for Gradle dependency parsing and JSON configuration with comments; Added tests for JExtract JNI code generation; Added tests for SwiftExtract analysis capabilities; Added tests for SwiftKit FFM sample app; Added tests for inline comment styles and Java documentation comment formatting.

The Gradle wrapper configuration has been updated to use Gradle 9.4.0. This change ensures that the build tool is automatically downloaded and used, standardizing the build environment for all developers and CI systems without requiring manual installation of a specific Gradle version.

gradle · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 65 → 64 (-1.4)
• Rubric changed (rubric-2026.09.11 → rubric-2026.09.18) — scores are not directly comparable.

• Code Health 84 → 85 (+1.2)
• Architecture 93 → 90 (-2.4)
• Maturity 60 → 60 (+0.7)
• Readiness 59 → 54 (-4.6)
• Security 71 → 78 (+7.4)
• Performance 85 (new)

• Change coupling: Swift2Java.swift ↔ SwiftAnalyzer.swift (Sources/JExtractSwiftLib/Swift2Java.swift)
• Documentation: no installation or build instructions (README.md)
• Documentation: no usage examples (README.md)
• Duplicated block (12 lines × 2) (Plugins/JExtractSwiftPlugin/JExtractSwiftPlugin.swift)
• FixmeComment (Sources/SwiftExtract/SwiftTypes/SwiftParsedModuleSymbolTableBuilder.swift)
• Hotspot: Sources/JExtractSwiftLib/FFM/ConversionStep.swift (Sources/JExtractSwiftLib/FFM/ConversionStep.swift)
• Hotspot: Sources/JExtractSwiftLib/FFM/FFMSwift2JavaGenerator+JavaBindingsPrinting.swift (Sources/JExtractSwiftLib/FFM/FFMSwift2JavaGenerator+JavaBindingsPrinting.swift)
• Hotspot: Sources/JExtractSwiftLib/FFM/FFMSwift2JavaGenerator.swift (Sources/JExtractSwiftLib/FFM/FFMSwift2JavaGenerator.swift)
• Hotspot: Sources/JExtractSwiftLib/JNI/JNIJavaTypeTranslator.swift (Sources/JExtractSwiftLib/JNI/JNIJavaTypeTranslator.swift)
• Hotspot: Sources/JExtractSwiftLib/Swift2Java.swift (Sources/JExtractSwiftLib/Swift2Java.swift)
• Hotspot: Sources/SwiftExtract/SwiftAnalysisVisitor.swift (Sources/SwiftExtract/SwiftAnalysisVisitor.swift)
• Hotspot: Sources/SwiftExtract/SwiftAnalyzer.swift (Sources/SwiftExtract/SwiftAnalyzer.swift)
• Hotspot: Sources/SwiftExtract/SwiftTypes/SwiftKnownTypeDecls.swift (Sources/SwiftExtract/SwiftTypes/SwiftKnownTypeDecls.swift)
• Hotspot: Sources/SwiftExtract/SwiftTypes/SwiftType.swift (Sources/SwiftExtract/SwiftTypes/SwiftType.swift)
• Hotspot: Sources/SwiftJavaTool/Commands/WrapJavaCommand.swift (Sources/SwiftJavaTool/Commands/WrapJavaCommand.swift)
• Hotspot: Sources/SwiftJavaToolLib/JavaClassTranslator.swift (Sources/SwiftJavaToolLib/JavaClassTranslator.swift)
• Hotspot: Sources/SwiftJavaToolLib/JavaTranslator.swift (Sources/SwiftJavaToolLib/JavaTranslator.swift)
• JExtractSwiftBuildToolPlugin.createBuildCommands (cognitive 20) (Plugins/JExtractSwiftPlugin/JExtractSwiftPlugin.swift)
• JExtractSwiftBuildToolPlugin.createBuildCommands (cyclomatic 16) (Plugins/JExtractSwiftPlugin/JExtractSwiftPlugin.swift)
• MethodTooLong: JExtractSwiftBuildToolPlugin.createBuildCommands (Plugins/JExtractSwiftPlugin/JExtractSwiftPlugin.swift)
• …and 7 more

• Ambiguous output generation: finalize() appears to return the accumulated string content, which is semantically identical to toString(). Having two methods that both return the final string representation creates confusion about when to call which.
• ConfigParser.swift.docLines (cognitive 39) (Sources/GenerateConfigDocs/ConfigParser.swift)
• ConfigParser.swift.docLines (cyclomatic 19) (Sources/GenerateConfigDocs/ConfigParser.swift)
• ConfigParser.swift.nilCoalescingFallback (cognitive 16) (Sources/GenerateConfigDocs/ConfigParser.swift)
• Coverage not measured — Swift suite
• Duplicated block (10 lines × 15) (SwiftKitCore/src/main/java/org/swift/swiftkit/core/tuple/Tuple10.java)
• Duplicated block (10 lines × 5) (SwiftKitCore/src/main/java/org/swift/swiftkit/core/tuple/Tuple20.java)
• Duplicated block (11–12 lines × 2) (Sources/JExtractSwiftLib/FFM/FFMSwift2JavaGenerator+JavaBindingsPrinting.swift)
• Duplicated block (11–12 lines × 2) (Sources/SwiftExtract/SwiftFileFilter.swift)
• Duplicated block (12 lines × 2) (Samples/SwiftJavaExtractFFMSampleApp/Sources/MySwiftLibrary/UnsafeRawBufferPointer.swift)
• Duplicated block (13 lines × 2) (Sources/JavaStdlib/JavaLangReflect/HasJavaModifiers.swift)
• Duplicated block (13 lines × 2) (SwiftKitCore/src/main/java/org/swift/swiftkit/core/SwiftLibraries.java)
• Duplicated block (21 lines × 2) (Samples/SwiftJavaExtractFFMSampleApp/Sources/MySwiftLibrary/Typealias.swift)
• Duplicated block (6 lines × 2) (SwiftKitCore/src/main/java/org/swift/swiftkit/core/CallTraces.java)
• Duplicated block (8 lines × 2) (Samples/SwiftAndJavaJarFFMSampleLib/src/main/java/com/example/swift/HelloJava2Swift.java)
• Inconsistent printing API: print takes an Any object, println takes no content (just terminator), and printParts takes a String. This forces the caller to choose methods based on the type of content being printed rather than a unified interface. append(String) also exists for raw text.
• Members sharing a duplicated core (15 members, 50+ identical tokens) (SwiftKitCore/src/main/java/org/swift/swiftkit/core/tuple/Tuple10.java)
• MethodTooLong: ExtractedNominalType.effectiveJavaName (Sources/SwiftExtract/ExtractedDecls.swift)
• MethodTooLong: ExtractedNominalType.effectiveJavaSimpleName (Sources/SwiftExtract/ExtractedDecls.swift)
• Off the main sequence: SwiftJavaConfigurationShared
• …and 7 more

• 4 commits — 4 feature/other, 0 fixes

• Sources/JExtractSwiftLib — 2 commits
• .github/workflows — 1 commit
• Samples/SwiftJavaExtractFFMSampleApp — 1 commit

• change: CI: use Xcode Swift for macOS tests while retaining Swiftly build (#923)
• change: [SwiftExtract] Preserve source file path for deferred (out-of-order) extensions (#924)
• change: jextract: fail on missing or empty javaPackage (#919) (#921)
• change: test: re-enable FFM sample coverage (#918)

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

swiftlang/swift-java was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.