remove vendored guava entirely, and instead allow sourcegen to use Guava

types

Author: ktoso

NOTICE.txt

@@ -549,30 +549,32 @@ extension FFMSwift2JavaGenerator {
 
   func unsignedResultConversion(_ from: SwiftType, to javaType: JavaType,
                                 mode: JExtractUnsignedIntegerMode) -> JavaConversionStep {
-    guard mode == .wrap else {
-      return .placeholder
-    }
+    switch mode {
+    case .annotate:
+      return .placeholder // no conversions
 
-    guard let className = javaType.className else {
-      fatalError("Missing target class name for result conversion step from \(from) to \(javaType)")
-    }
+    case .wrapGuava:
+      guard let typeName = javaType.fullyQualifiedClassName else {
+        fatalError("Missing target class name for result conversion step from \(from) to \(javaType)")
+      }
 
-    switch from {
-    case .nominal(let nominal):
-     switch nominal.nominalTypeDecl.knownTypeKind {
-     case .uint8:
-       return .call(.placeholder, function: "\(className).fromIntBits", withArena: false)
-     case .uint16:
-       return .placeholder // no conversion, UInt16 can be returned as-is and will be seen as char by Java
-     case .uint32:
-       return .call(.placeholder, function: "\(className).fromIntBits", withArena: false)
-     case .uint64:
-       return .call(.placeholder, function: "\(className).fromLongBits", withArena: false)
-     default:
-       fatalError("unsignedResultConversion: Unsupported conversion from \(from) to \(javaType)")
-     }
-     default:
-       fatalError("unsignedResultConversion: Unsupported conversion from \(from) to \(javaType)")
+      switch from {
+      case .nominal(let nominal):
+       switch nominal.nominalTypeDecl.knownTypeKind {
+       case .uint8:
+         return .call(.placeholder, function: "\(typeName).fromIntBits", withArena: false)
+       case .uint16:
+         return .placeholder // no conversion, UInt16 can be returned as-is and will be seen as char by Java
+       case .uint32:
+         return .call(.placeholder, function: "\(typeName).fromIntBits", withArena: false)
+       case .uint64:
+         return .call(.placeholder, function: "\(typeName).fromLongBits", withArena: false)
+       default:
+         fatalError("unsignedResultConversion: Unsupported conversion from \(from) to \(javaType)")
+       }
+       default:
+         fatalError("unsignedResultConversion: Unsupported conversion from \(from) to \(javaType)")
+      }
     }
   }
 

Sources/JExtractSwiftLib/FFM/FFMSwift2JavaGenerator+JavaTranslation.swift

@@ -104,8 +104,6 @@ extension FFMSwift2JavaGenerator {
 
     // NonNull, Unsigned and friends
     "org.swift.swiftkit.core.annotations.*",
-    // Unsigned numerics support
-    "org.swift.swiftkit.core.primitives.*",
 
     // Necessary for native calls and type mapping
     "java.lang.foreign.*",
@@ -187,7 +185,7 @@ extension FFMSwift2JavaGenerator {
   func printImportedNominal(_ printer: inout CodePrinter, _ decl: ImportedNominalType) {
     printHeader(&printer)
     printPackage(&printer)
-    printImports(&printer)
+    printImports(&printer) // TODO: we could have some imports be driven from types used in the generated decl
 
     printNominal(&printer, decl) { printer in
       // We use a static field to abuse the initialization order such that by the time we get type metadata,

Sources/JExtractSwiftLib/FFM/FFMSwift2JavaGenerator.swift

@@ -78,6 +78,15 @@ public final class ImportedFunc: ImportedDecl, CustomStringConvertible {
     }
   }
 
+  /// If this function type uses types that require any additional `import` statements,
+  /// these would be exported here.
+  var additionalJavaImports: Set<String> {
+    var imports: Set<String> = []
+//    imports += self.functionSignature.parameters.flatMap { $0.additionalJavaImports }
+//    imports += self.functionSignature.result.additionalJavaImports
+    return imports
+  }
+
   var isStatic: Bool {
     if case .staticMethod = functionSignature.selfParameter {
       return true

Sources/JExtractSwiftLib/ImportedDecls.swift

@@ -26,7 +26,7 @@ extension JavaType {
     case "UInt8":
       self = switch unsigned {
         case .ignoreSign: .char
-        case .wrapAsUnsignedNumbers: JavaType.swiftkit.primitives.UnsignedByte
+        case .wrapUnsignedGuava: JavaType.guava.primitives.UnsignedInteger
       }
 
     case "Int16": self = .short
@@ -36,14 +36,14 @@ extension JavaType {
     case "UInt32":
       self = switch unsigned {
       case .ignoreSign: .int
-      case .wrapAsUnsignedNumbers: JavaType.swiftkit.primitives.UnsignedInteger
+      case .wrapUnsignedGuava: JavaType.guava.primitives.UnsignedInteger
       }
 
     case "Int64": self = .long
     case "UInt64":
       self = switch unsigned {
       case .ignoreSign: .long
-      case .wrapAsUnsignedNumbers: JavaType.swiftkit.primitives.UnsignedLong
+      case .wrapUnsignedGuava: JavaType.guava.primitives.UnsignedLong
       }
 
     case "Float": self = .float
@@ -60,25 +60,20 @@ extension JavaType {
     switch swiftType {
     case .nominal(let nominal):
       switch nominal.nominalTypeDecl.knownTypeKind {
-      case .uint8: return swiftkit.primitives.UnsignedByte
+      case .uint8: return guava.primitives.UnsignedInteger
       case .uint16: return .char // no wrapper necessary, we can express it as 'char' natively in Java
-      case .uint32: return swiftkit.primitives.UnsignedInteger
-      case .uint64: return swiftkit.primitives.UnsignedLong
+      case .uint32: return guava.primitives.UnsignedInteger
+      case .uint64: return guava.primitives.UnsignedLong
       default: return nil
       }
     default: return nil
     }
   }
 
-  enum swiftkit {
+  /// Known types from the Google Guava library
+  enum guava {
     enum primitives {
-      static let package = "org.swift.swiftkit.core.primitives"
-
-      static var UnsignedByte: JavaType {
-        .class(package: primitives.package, name: "UnsignedByte")
-      }
-
-      // UnsignedShort is not necessary because UInt16 is directly expressible as Java's unsigned 'char'.
+      static let package = "com.google.common.primitives"
 
       static var UnsignedInteger: JavaType {
         .class(package: primitives.package, name: "UnsignedInteger")

Sources/JExtractSwiftLib/JavaTypes/JavaType+SwiftKit.swift

@@ -38,7 +38,7 @@ public enum JExtractUnsignedIntegerMode: String, Codable {
   /// This mode trades off performance, due to needing to allocate the type-safe wrapper objects around
   /// primitive values, however allows to retain static type information about the unsignedness of
   /// unsigned number types in the Java side of generated bindings.
-  case wrap
+  case wrapGuava
 
 //  /// If possible, use a wider Java signed integer type to represent an Unsigned Swift integer type.
 //  /// For example, represent a Swift `UInt32` (width equivalent to Java `int`) as a Java signed `long`,
@@ -56,7 +56,7 @@ extension JExtractUnsignedIntegerMode {
   public var needsConversion: Bool {
     switch self {
     case .annotate: false
-    case .wrap: true
+    case .wrapGuava: true
     }
   }
 

Sources/JavaKitConfigurationShared/GenerationMode.swift

@@ -60,7 +60,7 @@ extension JavaType: CustomStringConvertible {
     }
   }
 
-  /// Returns the a class name if this java type was a class,
+  /// Returns the class name if this java type was a class,
   /// and nil otherwise.
   public var className: String? {
     switch self {
@@ -70,4 +70,17 @@ extension JavaType: CustomStringConvertible {
       return nil
     }
   }
+
+  /// Returns the fully qualified class name if this java type was a class,
+  /// and nil otherwise.
+  public var fullyQualifiedClassName: String? {
+    switch self {
+    case .class(.some(let package), let name):
+      return "\(package).\(name)"
+    case .class(nil, let name):
+      return name
+    default:
+      return nil
+    }
+  }
 }

Sources/JavaTypes/JavaType+JavaSource.swift

@@ -96,18 +96,21 @@ extension JavaType {
 /// - `UInt32` is imported as `int`
 /// - `UInt64` is imported as `long`
 ///
-/// When `wrapAsUnsignedNumbers` is used, unsigned Swift types are imported as safe "wrapper" types on the Java side.
+/// When `wrapUnsignedGuava` is used, unsigned Swift types are imported as safe "wrapper" types from the popular Guava
+/// library on the Java side. SwiftJava does not include these types, so you would have to make sure your project depends
+/// on Guava for such generated code to be able to compile.
+///
 /// These make the Unsigned nature of the types explicit in Java, however they come at a cost of allocating the wrapper
 /// object, and indirection when accessing the underlying numeric value. These are often useful as a signal to watch out
 /// when dealing with a specific API, however in high performance use-cases, one may want to choose using the primitive
 ///  values directly, and interact with them using {@code UnsignedIntegers} SwiftKit helper classes on the Java side.
 ///
 /// The type mappings in this mode are as follows:
-/// - `UInt8` is imported as `org.swift.swiftkit.core.primitives.UnsignedByte`
+/// - `UInt8` is imported as `com.google.common.primitives.UnsignedInteger`
 /// - `UInt16` is imported as `char` (this is always correct, since `char` is unsigned in Java)
-/// - `UInt32` is imported as `org.swift.swiftkit.core.primitives.UnsignedInteger`
-/// - `UInt64` is imported as `org.swift.swiftkit.core.primitives.UnsignedLong`
+/// - `UInt32` is imported as `com.google.common.primitives.UnsignedInteger`
+/// - `UInt64` is imported as `com.google.common.primitives.UnsignedLong`
 public enum UnsignedNumericsMode {
   case ignoreSign
-  case wrapAsUnsignedNumbers
-}
+  case wrapUnsignedGuava
+}