[SR-13235] libSwiftPM should vend a ClangTarget's module map generation info

This is separate from the module map generation for now, but will be reconciled so that the generation will use the same module map information as what's vended to the client.

Vending the target's module map layout information provides more semantic information to the client than just vending the raw contents of the generated module map.  This semantic information can then (for example) be shown in the user interface of an IDE, etc.

rdar://65678318

Author: abertelrud

Sources/PackageLoading/ModuleMapGenerator.swift

@@ -71,6 +71,49 @@ public struct ModuleMapGenerator {
         self.diagnostics = diagnostics
     }
 
+    /// Determine the type of module map that applies to the specifed public-headers directory.
+    public static func determineModuleMapType(includeDir: AbsolutePath, moduleName: String, fileSystem: FileSystem) -> ModuleMapType {
+        
+        // First check for a custom module map.
+        let customModuleMap = includeDir.appending(component: moduleMapFilename)
+        if fileSystem.isFile(customModuleMap) {
+            return .custom(customModuleMap)
+        }
+        
+        // Next try to get the entries in the public-headers directory; if we cannot, we have no module map.
+        guard let entries = try? fileSystem.getDirectoryContents(includeDir).map({ includeDir.appending(component: $0) }) else {
+            return .none
+        }
+        let headers = entries.filter({ fileSystem.isFile($0) && $0.suffix == ".h" })
+        let directories = entries.filter({ fileSystem.isDirectory($0) })
+        
+        // Look for `includeDir/moduleName.h`.
+        let flatUmbrellaHeader = includeDir.appending(component: moduleName + ".h")
+        if fileSystem.isFile(flatUmbrellaHeader) {
+            // In this case we expect no directories next to the header.
+            if directories.count != 0 {
+                return .none
+            }
+            return .umbrellaHeader(flatUmbrellaHeader)
+        }
+
+        // Look for `includeDir/moduleName/moduleName.h`.
+        let nestedUmbrellaHeader = includeDir.appending(components: moduleName, moduleName + ".h")
+        if fileSystem.isFile(nestedUmbrellaHeader) {
+            // In this case we expect no headers and no other directories next to the directory containing the header.
+            if directories.count != 1 {
+                return .none
+            }
+            if headers.count != 0 {
+                return .none
+            }
+            return .umbrellaHeader(nestedUmbrellaHeader)
+        }
+        
+        // Otherwise, treat the public-headers directory as an umbrella directory anyway, for backward compatibility.
+        return .umbrellaDirectory(includeDir)
+    }
+
     /// Generates a module map based on the layout of the target's public headers, or does nothing if an error occurs or no module map is appropriate.  Any diagnostics are added to the receiver's diagnostics engine.
     public mutating func generateModuleMap(inDir wd: AbsolutePath) throws {
         assert(target.type == .library)

Sources/PackageLoading/PackageBuilder.swift

@@ -742,6 +742,8 @@ public final class PackageBuilder {
                 buildSettings: buildSettings
             )
         } else {
+            let moduleMapType = try ModuleMapGenerator.determineModuleMapType(includeDir: publicHeadersPath, moduleName: potentialModule.name.spm_mangledToC99ExtendedIdentifier(), fileSystem: fileSystem)
+
             return ClangTarget(
                 name: potentialModule.name,
                 bundleName: bundleName,
@@ -750,6 +752,7 @@ public final class PackageBuilder {
                 cLanguageStandard: manifest.cLanguageStandard,
                 cxxLanguageStandard: manifest.cxxLanguageStandard,
                 includeDir: publicHeadersPath,
+                moduleMapType: moduleMapType,
                 headers: headers,
                 isTest: potentialModule.isTest,
                 sources: sources,

Sources/PackageModel/Target.swift

@@ -356,6 +356,9 @@ public class ClangTarget: Target {
 
     /// The path to include directory.
     public let includeDir: AbsolutePath
+    
+    /// The target's module map type; determined by the file system layout, and controls whether the build system will use a custom module map, generate a module map, etc.
+    public let moduleMapType: ModuleMapType
 
     /// The headers present in the target.
     ///
@@ -379,6 +382,7 @@ public class ClangTarget: Target {
         cLanguageStandard: String?,
         cxxLanguageStandard: String?,
         includeDir: AbsolutePath,
+        moduleMapType: ModuleMapType,
         headers: [AbsolutePath] = [],
         isTest: Bool = false,
         sources: Sources,
@@ -392,6 +396,7 @@ public class ClangTarget: Target {
         self.cLanguageStandard = cLanguageStandard
         self.cxxLanguageStandard = cxxLanguageStandard
         self.includeDir = includeDir
+        self.moduleMapType = moduleMapType
         self.headers = headers
         super.init(
             name: name,
@@ -407,12 +412,13 @@ public class ClangTarget: Target {
     }
 
     private enum CodingKeys: String, CodingKey {
-        case includeDir, headers, isCXX, cLanguageStandard, cxxLanguageStandard
+        case includeDir, moduleMapType, headers, isCXX, cLanguageStandard, cxxLanguageStandard
     }
 
     public override func encode(to encoder: Encoder) throws {
         var container = encoder.container(keyedBy: CodingKeys.self)
         try container.encode(includeDir, forKey: .includeDir)
+        try container.encode(moduleMapType, forKey: .moduleMapType)
         try container.encode(headers, forKey: .headers)
         try container.encode(isCXX, forKey: .isCXX)
         try container.encode(cLanguageStandard, forKey: .cLanguageStandard)
@@ -423,6 +429,7 @@ public class ClangTarget: Target {
     required public init(from decoder: Decoder) throws {
         let container = try decoder.container(keyedBy: CodingKeys.self)
         self.includeDir = try container.decode(AbsolutePath.self, forKey: .includeDir)
+        self.moduleMapType = try container.decode(ModuleMapType.self, forKey: .moduleMapType)
         self.headers = try container.decode([AbsolutePath].self, forKey: .headers)
         self.isCXX = try container.decode(Bool.self, forKey: .isCXX)
         self.cLanguageStandard = try container.decodeIfPresent(String.self, forKey: .cLanguageStandard)
@@ -486,6 +493,52 @@ public class BinaryTarget: Target {
     }
 }
 
+/// A type of module map layout.  Contains all the information needed to generate or use a module map for a target that can have C-style headers.
+public enum ModuleMapType: Equatable, Codable {
+    /// No supported module map layout.
+    case none
+    /// A custom module map file.
+    case custom(AbsolutePath)
+    /// An umbrella header to be included in the module map.
+    case umbrellaHeader(AbsolutePath)
+    /// An umbrella directory to be included in the module map.
+    case umbrellaDirectory(AbsolutePath)
+
+    private enum CodingKeys: String, CodingKey {
+        case none, custom, umbrellaHeader, umbrellaDirectory
+    }
+    
+    public init(from decoder: Decoder) throws {
+        let container = try decoder.container(keyedBy: CodingKeys.self)
+        if let path = try container.decodeIfPresent(AbsolutePath.self, forKey: .custom) {
+            self = .custom(path)
+        }
+        else if let path = try container.decodeIfPresent(AbsolutePath.self, forKey: .umbrellaHeader) {
+            self = .umbrellaHeader(path)
+        }
+        else if let path = try container.decodeIfPresent(AbsolutePath.self, forKey: .umbrellaDirectory) {
+            self = .umbrellaDirectory(path)
+        }
+        else {
+            self = .none
+        }
+    }
+    
+    public func encode(to encoder: Encoder) throws {
+        var container = encoder.container(keyedBy: CodingKeys.self)
+        switch self {
+        case .none:
+            break
+        case .custom(let path):
+            try container.encode(path, forKey: .custom)
+        case .umbrellaHeader(let path):
+            try container.encode(path, forKey: .umbrellaHeader)
+        case .umbrellaDirectory(let path):
+            try container.encode(path, forKey: .umbrellaDirectory)
+        }
+    }
+}
+
 extension Target: CustomStringConvertible {
     public var description: String {
         return "<\(Swift.type(of: self)): \(name)>"

Tests/PackageLoadingTests/ModuleMapGenerationTests.swift

@@ -146,7 +146,8 @@ class ModuleMapGeneration: XCTestCase {
 
 func ModuleMapTester(_ name: String, includeDir: String = "include", in fileSystem: FileSystem, _ body: (ModuleMapResult) -> Void) {
     let includeDir = AbsolutePath.root.appending(component: includeDir)
-    let target = ClangTarget(name: name, cLanguageStandard: nil, cxxLanguageStandard: nil, includeDir: includeDir, isTest: false, sources: Sources(paths: [], root: .root))
+    let moduleMapType = (try? ModuleMapGenerator.determineModuleMapType(includeDir: includeDir, moduleName: name.spm_mangledToC99ExtendedIdentifier(), fileSystem: fileSystem)) ?? ModuleMapType.none
+    let target = ClangTarget(name: name, cLanguageStandard: nil, cxxLanguageStandard: nil, includeDir: includeDir, moduleMapType: moduleMapType, isTest: false, sources: Sources(paths: [], root: .root))
     let diagnostics = DiagnosticsEngine()
     var generator = ModuleMapGenerator(for: target, fileSystem: fileSystem, diagnostics: diagnostics)
     do {

Tests/PackageLoadingTests/PackageBuilderTests.swift

@@ -211,6 +211,7 @@ class PackageBuilderTests: XCTestCase {
             package.checkModule("clib") { module in
                 module.check(c99name: "clib", type: .library)
                 module.checkSources(root: "/Sources/clib", paths: "clib.c")
+                module.check(moduleMapType: .custom(AbsolutePath("/Sources/clib/include/module.modulemap")))
             }
         }
     }
@@ -242,6 +243,7 @@ class PackageBuilderTests: XCTestCase {
             package.checkModule("clib") { module in
                 module.check(c99name: "clib", type: .library)
                 module.checkSources(root: "/Sources", paths: "clib/clib.c", "clib/clib2.c", "clib/nested/nested.c")
+                module.check(moduleMapType: .umbrellaHeader(AbsolutePath("/Sources/lib/include/clib.h")))
             }
         }
     }
@@ -614,12 +616,14 @@ class PackageBuilderTests: XCTestCase {
                 module.check(c99name: "Foo", type: .library)
                 module.checkSources(root: "/Sources/Foo", paths: "Foo.c")
                 module.check(includeDir: "/Sources/Foo/inc")
+                module.check(moduleMapType: .custom(AbsolutePath("/Sources/Foo/inc/module.modulemap")))
             }
 
             package.checkModule("Bar") { module in
                 module.check(c99name: "Bar", type: .library)
                 module.checkSources(root: "/Sources/Bar", paths: "Bar.c")
                 module.check(includeDir: "/Sources/Bar/include")
+                module.check(moduleMapType: .custom(AbsolutePath("/Sources/Bar/inc/module.modulemap")))
             }
         }
     }
@@ -1710,6 +1714,7 @@ class PackageBuilderTests: XCTestCase {
             package.checkModule("lib") { module in
                 module.checkSources(root: "/Sources/lib", paths: "lib.c")
                 module.check(includeDir: "/Sources/lib/include")
+                module.check(moduleMapType: .umbrellaHeader(AbsolutePath("/Sources/lib/include/lib.h")))
             }
         }
     }
@@ -1734,6 +1739,7 @@ class PackageBuilderTests: XCTestCase {
             package.checkModule("lib") { module in
                 module.checkSources(root: "/Sources/lib", paths: "movie.mkv", "lib.c")
                 module.check(includeDir: "/Sources/lib/include")
+                module.check(moduleMapType: .umbrellaHeader(AbsolutePath("/Sources/lib/include/lib.h")))
             }
         }
     }
@@ -2179,6 +2185,13 @@ final class PackageBuilderTester {
             XCTAssertEqual(target.includeDir.pathString, includeDir, file: file, line: line)
         }
 
+        func check(moduleMapType: ModuleMapType, file: StaticString = #file, line: UInt = #line) {
+            guard case let target as ClangTarget = target else {
+                return XCTFail("Module map type is being checked on a non-Clang target", file: file, line: line)
+            }
+            XCTAssertEqual(target.moduleMapType, moduleMapType, file: file, line: line)
+        }
+
         func check(c99name: String? = nil, type: PackageModel.Target.Kind? = nil, file: StaticString = #file, line: UInt = #line) {
             if let c99name = c99name {
                 XCTAssertEqual(target.c99name, c99name, file: file, line: line)