Separate products from modules for the executable docs

Author: cmcgee1024

Sources/Commands/PackageCommands/GenerateDocumentation.swift

@@ -253,35 +253,33 @@ struct GenerateDocumentation: AsyncSwiftCommand {
         let doccExecutable = try swiftCommandState.toolsBuildParameters.toolchain.toolchainDir.appending(components: ["usr", "bin", "docc"])
 
         var modules: [ResolvedModule] = []
+        var products: [ResolvedProduct] = []
 
         // Copy the symbol graphs from the target-specific locations to the single output directory
         for rootPackage in try await buildSystem.getPackageGraph().rootPackages {
             if !internalDocs {
                 for product in rootPackage.products {
-                    modules.append(contentsOf: product.modules)
+                    for module in product.modules {
+                      modules.append(module)
+                    }
+
+                    products.append(product)
                 }
             } else {
                 modules.append(contentsOf: rootPackage.modules)
             }
         }
 
-        for module: ResolvedModule in modules {
-            // TODO handle executable modules differently using a command-line reference generator
-            guard module.type != .test && module.type != .plugin else {
-                continue
-            }
+        for product in products {
+          if product.type == .executable {
+              let exec = builtArtifacts.filter({ $0.1.kind == .executable && $0.0 == "\(product.name)-product" }).first?.1.path
 
-            if module.type == .executable {
-                // TODO check on the tuple filtering based on the module name here
-                // FIXME executables are at the product level, not the module level, this needs to be redone to fit that model
-                let exec = builtArtifacts.filter({ $0.0 == "\(module.name.lowercased())-product" }).map( { $0.1.path } ).first
+              guard let exec else {
+                  print("Couldn't find \(product.name)")
+                  continue
+              }
 
-                guard let exec else {
-                    print("Couldn't find \(module.name)")
-                    continue
-                }
-
-                do {
+               do {
                     // FIXME run the executable within a very restricted sandbox
                     let dumpHelpProcess = AsyncProcess(args: [exec, "--experimental-dump-help"], outputRedirection: .collect)
                     try dumpHelpProcess.launch()
@@ -293,23 +291,23 @@ struct GenerateDocumentation: AsyncSwiftCommand {
 
                     // Creating a simple DocC catalog
                     // TODO copy over an existing DocC catalog for this module if one exists already
-                    let catalogDir = buildPath.appending(components: ["tool-docc-catalog", module.name, "Documentation.docc"])
+                    let catalogDir = buildPath.appending(components: ["tool-docc-catalog", product.name, "Documentation.docc"])
                     try? swiftCommandState.fileSystem.removeFileTree(catalogDir)
                     try swiftCommandState.fileSystem.createDirectory(catalogDir, recursive: true)
-                    let summaryMd = catalogDir.appending(components: ["\(module.name.lowercased()).md"])
+                    let summaryMd = catalogDir.appending(components: ["\(product.name.lowercased()).md"])
                     try swiftCommandState.fileSystem.writeFileContents(summaryMd, string: page)
 
-                    let archiveDir = buildPath.appending(components: ["tool-docc-archive", "\(module.name).doccarchive"])
+                    let archiveDir = buildPath.appending(components: ["tool-docc-archive", "\(product.name).doccarchive"])
                     try? swiftCommandState.fileSystem.removeFileTree(archiveDir)
                     try swiftCommandState.fileSystem.createDirectory(archiveDir.parentDirectory, recursive: true)
 
-                    print("CONVERT TOOL: \(module.name)")
+                    print("CONVERT TOOL: \(product.name)")
 
                     let process = try Process.run(URL(fileURLWithPath: doccExecutable.pathString), arguments: [
                         "convert",
                         catalogDir.pathString,
-                        "--fallback-display-name=\(module.name)",
-                        "--fallback-bundle-identifier=\(module.name)",
+                        "--fallback-display-name=\(product.name)",
+                        "--fallback-bundle-identifier=\(product.name)",
                         "--output-path=\(archiveDir)",
                     ])
                     process.waitUntilExit()
@@ -318,15 +316,25 @@ struct GenerateDocumentation: AsyncSwiftCommand {
                         doccArchives.append(archiveDir.pathString)
                     }
                 } catch {
-                    print("warning: could not generate tool info documentation for \(module.name)")
+                    print("warning: could not generate tool info documentation for \(product.name)")
                 }
 
                 continue
             }
-            
+        }
+
+        for module: ResolvedModule in modules {
+            guard module.type != .test && module.type != .plugin && module.type != .executable else {
+                continue
+            }
 
             let inputPathDir = symbolGraph.outputLocationForTarget(module.name, try swiftCommandState.productsBuildParameters)
             let inputPath = buildPath.appending(components: inputPathDir)
+
+            guard swiftCommandState.fileSystem.exists(inputPath) else {
+              continue
+            }
+
             let outputPathDir = [String](inputPathDir.dropLast()) + [inputPathDir.last!.replacing(".symbolgraphs", with: ".doccarchive")]
             let outputPath = buildPath.appending(components: outputPathDir)
 
@@ -338,6 +346,8 @@ struct GenerateDocumentation: AsyncSwiftCommand {
             let catalogArgs = if let doccCatalog  {[doccCatalog.pathString]} else {[String]()}
 
             print("CONVERT: \(module.name)")
+
+            print("docc convert \(catalogArgs.joined(separator: " ")) \(["--fallback-display-name=\(module.name)", "--fallback-bundle-identifier=\(module.name)", "--additional-symbol-graph-dir=\(inputPath)", "--output-path=\(outputPath)"].joined(separator: " "))")
 
             let process = try Process.run(URL(fileURLWithPath: doccExecutable.pathString), arguments: [
                 "convert",