testkit: improve output assertion tools for jextract testing

Author: ktoso

Samples/JExtractPluginSampleApp/Sources/JExtractPluginSampleLib/MyCoolSwiftClass.swift

@@ -13,6 +13,14 @@
 //===----------------------------------------------------------------------===//
 
 public class MyCoolSwiftClass {
-  public init(number: Int) {}
-  public func exposedToJava() { }
+  var number: Int
+  public init(number: Int) {
+    print("[swift] init(number: \(number))")
+    self.number = number
+  }
+
+  public func exposedToJava() {
+    print("[swift] exposedToJava()")
+    print("[swift]   number = \(number)")
+  }
 }

Samples/JExtractPluginSampleApp/build.gradle

@@ -58,11 +58,11 @@ def buildSwift = tasks.register("swiftBuildProject", Exec) {
     inputs.file(new File(rootDir, "Package.swift"))
     inputs.dir(new File(rootDir, "Sources"))
 
-    // TODO: we can use package describe --type json to figure out which targets depend on JExtractSwiftPlugin and will produce outputs
     inputs.file(layout.projectDirectory.file("Package.swift"))
     inputs.dir(layout.projectDirectory.dir("Sources"))
 
-//    outputs.dir(layout.buildDirectory.dir("../.build/plugins/outputs/${layout.projectDirectory.asFile.getName().toLowerCase()}/JExtractPluginSampleLib/destination/JExtractSwiftPlugin/src/generated/java"))
+    // TODO: we can use package describe --type json to figure out which targets depend on JExtractSwiftPlugin and will produce outputs
+    //       Avoid adding this directory, but create the expected one specifically for all targets which WILL produce sources because they have the plugin
     outputs.dir(layout.buildDirectory.dir("../.build/plugins/outputs/${layout.projectDirectory.asFile.getName().toLowerCase()}"))
 
     File baseSwiftPluginOutputsDir = layout.buildDirectory.dir("../.build/plugins/outputs/").get().asFile
@@ -72,7 +72,6 @@ def buildSwift = tasks.register("swiftBuildProject", Exec) {
     Files.walk(layout.buildDirectory.dir("../.build/plugins/outputs/").get().asFile.toPath()).each {
         if (it.endsWith("JExtractSwiftPlugin/src/generated/java")) {
             outputs.dir(it)
-            println("OUTPUT = ${it}")
         }
     }
 

Samples/JExtractPluginSampleApp/gradlew

@@ -0,0 +1 @@
+../../gradlew

Samples/JExtractPluginSampleApp/gradlew.bat

@@ -0,0 +1 @@
+../../gradlew.bat

Samples/JavaSieve/Sources/JavaSieve/main.swift

@@ -13,13 +13,16 @@
 //===----------------------------------------------------------------------===//
 
 import JavaKit
+import JavaMath
 
 let jvm = try JavaVirtualMachine.shared(classPath: ["QuadraticSieve-1.0.jar"])
 do {
   let sieveClass = try JavaClass<SieveOfEratosthenes>(environment: jvm.environment())
   for prime in sieveClass.findPrimes(100)! {
     print("Found prime: \(prime.intValue())")
   }
+
+  try JavaClass<RoundingMode>().HALF_UP
 } catch {
   print("Failure: \(error)")
 }

Sources/JExtractSwift/CodePrinter.swift

@@ -34,14 +34,19 @@ public struct CodePrinter {
   }
   public var indentationText: String = ""
 
-  public static func toString(_ block: (inout CodePrinter) -> ()) -> String {
+  public static func toString(_ block: (inout CodePrinter) throws -> ()) rethrows -> String {
     var printer = CodePrinter()
-    block(&printer)
+    try block(&printer)
     return printer.finalize()
   }
 
-  public init() {
-
+  var ioMode: PrintMode
+  public enum PrintMode {
+    case accumulateAll
+    case flushToFileOnWrite
+  }
+  public init(io: PrintMode = .flushToFileOnWrite) {
+    self.ioMode = .accumulateAll
   }
 
   internal mutating func append(_ text: String) {
@@ -91,6 +96,16 @@ public struct CodePrinter {
     }
   }
 
+  /// Print a plain newline, e.g. to separate declarations.
+  public mutating func println(
+    _ terminator: PrinterTerminator = .newLine,
+    function: String = #function,
+    file: String = #fileID,
+    line: UInt = #line
+  ) {
+    print("")
+  }
+
   public mutating func print(
     _ text: Any,
     _ terminator: PrinterTerminator = .newLine,
@@ -159,6 +174,12 @@ public struct CodePrinter {
   public var isEmpty: Bool {
     self.contents.isEmpty
   }
+
+  public mutating func dump(file: String = #fileID, line: UInt = #line) {
+    Swift.print("// CodePrinter.dump @ \(file):\(line)")
+    Swift.print(contents)
+  }
+
 }
 
 public enum PrinterTerminator: String {
@@ -185,3 +206,49 @@ public enum PrinterTerminator: String {
     }
   }
 }
+
+extension CodePrinter {
+  package mutating func writeContents(
+    outputDirectory: String,
+    javaPackagePath: String?,
+    filename: String
+  ) throws {
+    guard self.ioMode != .accumulateAll else {
+      // if we're accumulating everything, we don't want to finalize/flush any contents
+      // let's mark that this is where a write would have happened though:
+      print("// ^^^^ Contents of: \(outputDirectory)/\(filename)")
+      return
+    }
+
+    let contents = finalize()
+    if outputDirectory == "-" {
+      print(
+        "// ==== ---------------------------------------------------------------------------------------------------"
+      )
+      if let javaPackagePath {
+        print("// \(javaPackagePath)/\(filename)")
+      } else {
+        print("// \(filename)")
+      }
+      print(contents)
+      return
+    }
+
+    let targetDirectory = [outputDirectory, javaPackagePath].compactMap { $0 }.joined(
+        separator: PATH_SEPARATOR)
+    log.trace("Prepare target directory: \(targetDirectory)")
+    try FileManager.default.createDirectory(
+      atPath: targetDirectory, withIntermediateDirectories: true)
+
+    let targetFilePath = [javaPackagePath, filename].compactMap { $0 }.joined(
+        separator: PATH_SEPARATOR)
+  Swift.print("Writing '\(targetFilePath)'...", terminator: "")
+    try contents.write(
+      to: Foundation.URL(fileURLWithPath: targetDirectory).appendingPathComponent(filename),
+      atomically: true,
+      encoding: .utf8
+    )
+    Swift.print(" done.".green)
+  }
+
+}

Sources/JExtractSwift/ImportedDecls.swift

@@ -115,13 +115,20 @@ extension ImportedParam {
 }
 
 // TODO: this is used in different contexts and needs a cleanup
+//       Perhaps this is "which parameter passing style"?
 public enum SelfParameterVariant {
+  // ==== Java forwarding patterns
+
   /// Make a method that accepts the raw memory pointer as a MemorySegment
   case memorySegment
   /// Make a method that accepts the the Java wrapper class of the type
   case wrapper
   /// Raw SWIFT_POINTER
   case pointer
+
+  // ==== Swift forwarding patterns
+
+  case swiftThunkSelf
 }
 
 public struct ImportedFunc: ImportedDecl, CustomStringConvertible {
@@ -161,14 +168,14 @@ public struct ImportedFunc: ImportedDecl, CustomStringConvertible {
   public var returnType: TranslatedType
   public var parameters: [ImportedParam]
 
-  public func effectiveParameters(selfVariant: SelfParameterVariant?) -> [ImportedParam] {
+  public func effectiveParameters(paramPassingStyle: SelfParameterVariant?) -> [ImportedParam] {
     if let parent {
       var params = parameters
 
       // Add `self: Self` for method calls on a member
       //
       // allocating initializer takes a Self.Type instead, but it's also a pointer
-      switch selfVariant {
+      switch paramPassingStyle {
       case nil, .wrapper:
         break
 
@@ -185,6 +192,9 @@ public struct ImportedFunc: ImportedDecl, CustomStringConvertible {
         params.append(
           ImportedParam(param: selfParam, type: parentForSelf)
         )
+
+      case .swiftThunkSelf:
+        break
       }
 
       // TODO: add any metadata for generics and other things we may need to add here
@@ -303,24 +313,22 @@ public struct ImportedVariable: ImportedDecl, CustomStringConvertible {
         identifier: self.identifier,
         returnType: TranslatedType.void,
         parameters: [.init(param: newValueParam, type: self.returnType)])
-      // FIXME: funcDecl.swiftMangledName = self.swiftMangledName + "s" // form mangled name of the getter by adding the suffix
       return funcDecl
 
     case .get:
-      var funcDecl = ImportedFunc(
+      let funcDecl = ImportedFunc(
         module: self.module,
         decl: self.syntax!,
         parent: self.parentName,
         identifier: self.identifier,
         returnType: self.returnType,
         parameters: [])
-      // FIXME: funcDecl.swiftMangledName = self.swiftMangledName + "g" // form mangled name of the getter by adding the suffix
       return funcDecl
     }
   }
 
   public func effectiveAccessorParameters(
-    _ kind: VariableAccessorKind, selfVariant: SelfParameterVariant?
+    _ kind: VariableAccessorKind, paramPassingStyle: SelfParameterVariant?
   ) -> [ImportedParam] {
     var params: [ImportedParam] = []
 
@@ -338,10 +346,7 @@ public struct ImportedVariable: ImportedDecl, CustomStringConvertible {
       // Add `self: Self` for method calls on a member
       //
       // allocating initializer takes a Self.Type instead, but it's also a pointer
-      switch selfVariant {
-      case nil, .wrapper:
-        break
-
+      switch paramPassingStyle {
       case .pointer:
         let selfParam: FunctionParameterSyntax = "self$: $swift_pointer"
         params.append(
@@ -361,6 +366,11 @@ public struct ImportedVariable: ImportedDecl, CustomStringConvertible {
             type: parentForSelf
           )
         )
+
+      case nil,
+           .wrapper,
+           .swiftThunkSelf:
+        break
       }
     }
 

Sources/JExtractSwift/Logger.swift

@@ -88,7 +88,7 @@ public struct Logger {
     }
 
     let metadataString: String =
-      metadata.isEmpty ? "\(metadata)" : ""
+      metadata.isEmpty ? "" : "\(metadata)"
 
     print("[trace][\(file):\(line)](\(function)) \(message()) \(metadataString)")
   }

Sources/JExtractSwift/Swift2JavaTranslator+MemoryLayouts.swift

@@ -20,16 +20,16 @@ import SwiftSyntax
 extension Swift2JavaTranslator {
   public func javaMemoryLayoutDescriptors(
     forParametersOf decl: ImportedFunc,
-    selfVariant: SelfParameterVariant?
+    paramPassingStyle: SelfParameterVariant?
   ) -> [ForeignValueLayout] {
     var layouts: [ForeignValueLayout] = []
     layouts.reserveCapacity(decl.parameters.count + 1)
 
     //     // When the method is `init()` it does not accept a self (well, unless allocating init but we don't import those)
-    //    let selfVariant: SelfParameterVariant? =
+    //    let paramPassingStyle: SelfParameterVariant? =
     //      decl.isInit ? nil : .wrapper
 
-    for param in decl.effectiveParameters(selfVariant: selfVariant) {
+    for param in decl.effectiveParameters(paramPassingStyle: paramPassingStyle) {
       layouts.append(param.type.foreignValueLayout)
     }