Add Swift module support to ZipBuilder (#5040)

Author: paulb777

ZipBuilder/Sources/ZipBuilder/FrameworkBuilder.swift

@@ -221,7 +221,12 @@ struct FrameworkBuilder {
                 "ARCHS=\(cleanArch)",
                 "VALID_ARCHS=\(cleanArch)",
                 "ONLY_ACTIVE_ARCH=NO",
-                "BUILD_LIBRARIES_FOR_DISTRIBUTION=YES",
+                // BUILD_LIBRARY_FOR_DISTRIBUTION=YES is necessary for Swift libraries.
+                // See https://forums.developer.apple.com/thread/125646.
+                // Unlike the comment there, the option here is sufficient to cause .swiftinterface
+                // files to be generated in the .swiftmodule directory. The .swiftinterface files
+                // are required for xcodebuild to successfully generate an xcframework.
+                "BUILD_LIBRARY_FOR_DISTRIBUTION=YES",
                 "SUPPORTS_MACCATALYST=\(isMacCatalystString)",
                 "BUILD_DIR=\(buildDir.path)",
                 "-sdk", platform.rawValue,
@@ -267,7 +272,7 @@ struct FrameworkBuilder {
       var actualFramework: String
       do {
         let files = try FileManager.default.contentsOfDirectory(at: frameworkPath,
-                                                                includingPropertiesForKeys: nil).compactMap { $0.absoluteString }
+                                                                includingPropertiesForKeys: nil).compactMap { $0.path }
         let frameworkDir = files.filter { $0.contains(".framework") }
         actualFramework = URL(fileURLWithPath: frameworkDir[0]).lastPathComponent
       } catch {
@@ -427,21 +432,21 @@ struct FrameworkBuilder {
 
     // Find CocoaPods generated umbrella header.
     var umbrellaHeader = ""
-    if framework == "gRPC-Core" {
+    if framework == "gRPC-Core" || framework == "TensorFlowLiteObjC" {
       // TODO: Proper handling of podspec-specified module.modulemap files with customized umbrella
       // headers. This is good enough for Firebase since it doesn't need these modules.
       umbrellaHeader = "\(framework)-umbrella.h"
     } else {
       var umbrellaHeaderURL: URL
       do {
         let files = try fileManager.contentsOfDirectory(at: headersDir,
-                                                        includingPropertiesForKeys: nil).compactMap { $0.absoluteString }
-        let umbrellas = files.filter { $0.contains("umbrella.h") }
+                                                        includingPropertiesForKeys: nil).compactMap { $0.path }
+        let umbrellas = files.filter { $0.hasSuffix("umbrella.h") }
         if umbrellas.count != 1 {
           fatalError("Did not find exactly one umbrella header in \(headersDir).")
         }
         guard let firstUmbrella = umbrellas.first,
-          let foundHeader = URL(string: firstUmbrella) else { /* error */
+          let foundHeader = URL(string: firstUmbrella) else {
           fatalError("Failed to get umbrella header in \(headersDir).")
         }
         umbrellaHeaderURL = foundHeader
@@ -527,10 +532,6 @@ struct FrameworkBuilder {
                                 thinArchives: [Architecture: URL],
                                 destination: URL,
                                 moduleMapContents: String) {
-    // Build the fat archive using the `lipo` command. We need the full archive path and the list of
-    // thin paths (as Strings, not URLs).
-    let thinPaths = thinArchives.map { $0.value.path }
-
     // Store all fat archives in a temporary directory that includes all architectures included as
     // the parent folder.
     let fatArchivesDir: URL = {
@@ -552,8 +553,10 @@ struct FrameworkBuilder {
       fatalError("Could not create directories needed to build \(framework): \(error)")
     }
 
+    // Build the fat archive using the `lipo` command. We need the full archive path.
     let fatArchive = fatArchivesDir.appendingPathComponent(framework)
-    let result = syncExec(command: "/usr/bin/lipo", args: ["-create", "-output", fatArchive.path] + thinPaths)
+    let result = syncExec(command: "/usr/bin/lipo", args: ["-create", "-output", fatArchive.path] +
+      thinArchives.map { $0.value.path })
     switch result {
     case let .error(code, output):
       fatalError("""
@@ -571,19 +574,84 @@ struct FrameworkBuilder {
     } catch {
       fatalError("Could not copy \(framework) to destination: \(error)")
     }
-    // Copy the module map to the destination.
-    let moduleDir = destination.appendingPathComponent("Modules")
-    do {
-      try FileManager.default.createDirectory(at: moduleDir, withIntermediateDirectories: true)
-    } catch {
-      fatalError("Could not create Modules directory for framework: \(framework). \(error)")
+
+    // CocoaPods does not put dependent frameworks and libraries into the module maps it generates.
+    // Instead it use build options to specify them. For the zip build, we need the module maps to
+    // include the dependent frameworks and libraries. Therefore we reconstruct them by parsing
+    // the CocoaPods config files and add them here.
+    // Currently we only to the construction for Objective C since Swift Module directories require
+    // several other files. See https://github.com/firebase/firebase-ios-sdk/pull/5040.
+    // Therefore, for Swift we do a simple copy of the Modules files from an Xcode build.
+    // This is sufficient for the testing done so far, but more testing is required to determine
+    // if dependent libraries and frameworks also may need to be added to the Swift module maps in
+    // some cases.
+    let builtSwiftModules = makeSwiftModuleMap(thinArchives: thinArchives, destination: destination)
+    if !builtSwiftModules {
+      // Copy the module map to the destination.
+      let moduleDir = destination.appendingPathComponent("Modules")
+      do {
+        try FileManager.default.createDirectory(at: moduleDir, withIntermediateDirectories: true)
+      } catch {
+        fatalError("Could not create Modules directory for framework: \(framework). \(error)")
+      }
+      let modulemap = moduleDir.appendingPathComponent("module.modulemap")
+      do {
+        try moduleMapContents.write(to: modulemap, atomically: true, encoding: .utf8)
+      } catch {
+        fatalError("Could not write modulemap to disk for \(framework): \(error)")
+      }
     }
-    let modulemap = moduleDir.appendingPathComponent("module.modulemap")
-    do {
-      try moduleMapContents.write(to: modulemap, atomically: true, encoding: .utf8)
-    } catch {
-      fatalError("Could not write modulemap to disk for \(framework): \(error)")
+  }
+
+  private func makeSwiftModuleMap(thinArchives: [Architecture: URL], destination: URL) -> Bool {
+    let fileManager = FileManager.default
+    for archive in thinArchives {
+      let frameworkDir = archive.value.deletingLastPathComponent()
+      // Get the Modules directory. The Catalyst one is a symbolic link.
+      let moduleDir = frameworkDir.appendingPathComponent("Modules").resolvingSymlinksInPath()
+      do {
+        let files = try fileManager.contentsOfDirectory(at: moduleDir,
+                                                        includingPropertiesForKeys: nil).compactMap { $0.path }
+        let swiftModules = files.filter { $0.hasSuffix(".swiftmodule") }
+        if swiftModules.isEmpty {
+          return false
+        }
+        guard let first = swiftModules.first,
+          let swiftModule = URL(string: first) else {
+          fatalError("Failed to get swiftmodule in \(moduleDir).")
+        }
+        let destModuleDir = destination.appendingPathComponent("Modules")
+        if !fileManager.directoryExists(at: destModuleDir) {
+          do {
+            try fileManager.copyItem(at: moduleDir, to: destModuleDir)
+          } catch {
+            fatalError("Could not copy Modules from \(moduleDir) to " + "\(destModuleDir): \(error)")
+          }
+        } else {
+          // If the Modules directory is already there, only copy in the architecture specific files
+          // from the *.swiftmodule subdirectory.
+          do {
+            let files = try fileManager.contentsOfDirectory(at: swiftModule,
+                                                            includingPropertiesForKeys: nil).compactMap { $0.path }
+            let destSwiftModuleDir = destModuleDir.appendingPathComponent(swiftModule.lastPathComponent)
+            for file in files {
+              let fileURL = URL(fileURLWithPath: file)
+              do {
+                try fileManager.copyItem(at: fileURL, to:
+                  destSwiftModuleDir.appendingPathComponent(fileURL.lastPathComponent))
+              } catch {
+                fatalError("Could not copy Swift module file from \(fileURL) to " + "\(destSwiftModuleDir): \(error)")
+              }
+            }
+          } catch {
+            fatalError("Failed to get Modules directory contents - \(moduleDir): \(error.localizedDescription)")
+          }
+        }
+      } catch {
+        fatalError("Error while enumerating files \(moduleDir): \(error.localizedDescription)")
+      }
     }
+    return true
   }
 
   /// Packages an XCFramework based on an almost complete framework folder (missing the binary but includes everything else needed)
@@ -619,7 +687,7 @@ struct FrameworkBuilder {
     for platform in Architecture.TargetPlatform.allCases {
       // Get all the slices that belong to the specific platform in order to lipo them together.
       let slices = thinArchives.filter { $0.key.platform == platform }
-      if slices.count == 0 {
+      if slices.isEmpty {
         continue
       }
       let platformDir = platformFrameworksDir.appendingPathComponent(platform.rawValue)