Auto generate module map file for C libs

Fixtures/ClangModules/ModuleMapGenerationCases/Package.swift

@@ -0,0 +1,7 @@
+import PackageDescription
+
+let package = Package(
+    name: "ModuleMapGenerationCases",
+    targets: [
+		Target(name: "Baz", dependencies: ["FlatInclude", "UmbrellaHeader", "UmbellaModuleNameInclude", "UmbrellaHeaderFlat"])]
+)

Fixtures/ClangModules/ModuleMapGenerationCases/Sources/Baz/main.swift

@@ -0,0 +1,9 @@
+import UmbellaModuleNameInclude
+import FlatInclude
+import UmbrellaHeader
+import UmbrellaHeaderFlat
+
+let _ = foo()
+let _ = bar()
+let _ = jaz()
+let _ = umbrellaHeaderFlat()

Fixtures/ClangModules/ModuleMapGenerationCases/Sources/FlatInclude/FlatInclude.c

@@ -0,0 +1,8 @@
+#include "include/FlatIncludeHeader.h"
+
+int bar() {
+    int a = 6;
+    int b = a;
+    a = b;
+    return a;
+}

Fixtures/ClangModules/ModuleMapGenerationCases/Sources/FlatInclude/include/FlatIncludeHeader.h

@@ -0,0 +1 @@
+int bar();

Fixtures/ClangModules/ModuleMapGenerationCases/Sources/NoIncludeDir/Jaz.c

@@ -0,0 +1,7 @@
+
+int noDir() {
+    int a = 6;
+    int b = a;
+    a = b;
+    return a;
+}

Fixtures/ClangModules/ModuleMapGenerationCases/Sources/UmbellaModuleNameInclude/Jaz.c

@@ -0,0 +1,8 @@
+#include "include/UmbellaModuleNameInclude/Paz.h"
+
+int jaz() {
+    int a = 6;
+    int b = a;
+    a = b;
+    return a;
+}

Fixtures/ClangModules/ModuleMapGenerationCases/Sources/UmbellaModuleNameInclude/include/UmbellaModuleNameInclude/Paz.h

@@ -0,0 +1 @@
+int jaz();

Fixtures/ClangModules/ModuleMapGenerationCases/Sources/UmbrellaHeader/UmbrellaHeader.c

@@ -0,0 +1,8 @@
+#include "include/UmbrellaHeader/UmbrellaHeader.h"
+
+int foo() {
+    int a = 5;
+    int b = a;
+    a = b;
+    return a;
+}

Fixtures/ClangModules/ModuleMapGenerationCases/Sources/UmbrellaHeader/include/UmbrellaHeader/UmbrellaHeader.h

@@ -0,0 +1 @@
+int foo();

Fixtures/ClangModules/ModuleMapGenerationCases/Sources/UmbrellaHeaderFlat/UmbrellaHeader.c

@@ -0,0 +1,8 @@
+#include "include/UmbrellaHeaderFlat.h"
+
+int umbrellaHeaderFlat() {
+    int a = 5;
+    int b = a;
+    a = b;
+    return a;
+}

Fixtures/ClangModules/ModuleMapGenerationCases/Sources/UmbrellaHeaderFlat/include/UmbrellaHeaderFlat.h

@@ -0,0 +1 @@
+int umbrellaHeaderFlat();

Sources/Build/Buildable.swift

@@ -9,20 +9,44 @@
 */
 
 import PackageType
+import struct Utility.Path
 
 protocol Buildable {
     var targetName: String { get }
     var isTest: Bool { get }
 }
 
+extension CModule {
+    ///Returns the build directory path of a CModule
+    func buildDirectory(prefix: String) -> String {
+        return Path.join(prefix, "\(c99name).build")
+    }
+}
+
 extension Module: Buildable {
     var isTest: Bool {
         return self is TestModule
     }
 
-    var Xcc: [String] {
+    func XccFlags(prefix: String) -> [String] {
         return recursiveDependencies.flatMap { module -> [String] in
-            if let module = module as? CModule {
+            if let module = module as? ClangModule {
+                ///For ClangModule we check if there is a user provided module map
+                ///otherwise we return with path of generated one.
+                ///We will fail before this is ever called if there is no module map.
+                ///FIXME: The user provided modulemap should be copied to build dir
+                ///but that requires copying the complete include dir because it'll
+                ///mostly likely contain relative paths.
+                ///FIXME: This is already computed when trying to generate modulemap
+                ///in ClangModule's `generateModuleMap(inDir wd: String)`
+                ///there shouldn't be need to redo this but is difficult in 
+                ///current architecture
+                if module.moduleMapPath.isFile {
+                    return ["-Xcc", "-fmodule-map-file=\(module.moduleMapPath)"]
+                }
+                let genModuleMap = Path.join(module.buildDirectory(prefix), module.moduleMap)
+                return ["-Xcc", "-fmodule-map-file=\(genModuleMap)"]
+            } else if let module = module as? CModule {
                 return ["-Xcc", "-fmodule-map-file=\(module.moduleMapPath)"]
             } else {
                 return []

Sources/Build/Command.compile(ClangModule).swift

@@ -67,9 +67,14 @@ private extension Sources {
 }
 
 extension Command {
-    static func compile(clangModule module: ClangModule, externalModules: Set<Module>, configuration conf: Configuration, prefix: String, CC: String) -> ([Command], Command) {
+    static func compile(clangModule module: ClangModule, externalModules: Set<Module>, configuration conf: Configuration, prefix: String, CC: String) throws -> ([Command], Command) {
 
-        let wd = Path.join(prefix, "\(module.c99name).build")
+        let wd = module.buildDirectory(prefix)
+
+        if module.type == .Library {
+            try module.generateModuleMap(inDir: wd)
+        }
+
         let mkdir = Command.createDirectory(wd)
 
         ///------------------------------ Compile -----------------------------------------

Sources/Build/Command.compile(SwiftModule).swift

@@ -14,7 +14,7 @@ import Utility
 extension Command {
     static func compile(swiftModule module: SwiftModule, configuration conf: Configuration, prefix: String, otherArgs: [String], SWIFT_EXEC: String) throws -> (Command, [Command]) {
 
-        let otherArgs = otherArgs + module.Xcc
+        let otherArgs = otherArgs + module.XccFlags(prefix)
 
         func cmd(tool: ToolProtocol) -> Command {
             return Command(node: module.targetName, tool: tool)

Sources/Build/Command.link().swift

@@ -81,7 +81,7 @@ extension Command {
             let main = Path.join(testDirectory, "LinuxMain.swift")
             args.append(main)
             for module in product.modules {
-                args += module.Xcc
+                args += module.XccFlags(prefix)
             }
             args.append("-emit-executable")
             args += ["-I", prefix]

Sources/Build/describe().swift

@@ -43,17 +43,7 @@ public func describe(prefix: String, _ conf: Configuration, _ modules: [Module],
             targets.append(compile, for: module)
 
         case let module as ClangModule:
-            //FIXME: Generate modulemaps if possible
-            //Since we're not generating modulemaps currently we'll just emit empty module map file
-            //if it not present
-            if module.type == .Library && !module.moduleMapPath.isFile {
-                try POSIX.mkdir(module.moduleMapPath.parentDirectory)
-                try fopen(module.moduleMapPath, mode: .Write) { fp in
-                    try fputs("\n", fp)
-                }
-            }
-
-            let (compile, mkdir) = Command.compile(clangModule: module, externalModules: externalModules, configuration: conf, prefix: prefix, CC: CC)
+            let (compile, mkdir) = try Command.compile(clangModule: module, externalModules: externalModules, configuration: conf, prefix: prefix, CC: CC)
             commands += compile
             commands.append(mkdir)
             targets.main.cmds += compile

Sources/Build/misc.swift

@@ -10,6 +10,9 @@
 
 import func POSIX.getenv
 import func POSIX.popen
+import func POSIX.mkdir
+import func POSIX.fopen
+import func libc.fclose
 import PackageType
 import Utility
 
@@ -29,8 +32,104 @@ func platformFrameworksPath() throws -> String {
 }
 
 extension CModule {
+
+    var moduleMap: String {
+        return "module.modulemap"
+    }
+
     var moduleMapPath: String {
-        return Path.join(path, "module.modulemap")
+        return Path.join(path, moduleMap)
+    }
+}
+
+extension ClangModule {
+
+    public enum ModuleMapError: ErrorProtocol {
+        case UnsupportedIncludeLayoutForModule(String)
+    }
+
+    ///FIXME: we recompute the generated modulemap's path
+    ///when building swift modules in `XccFlags(prefix: String)`
+    ///there shouldn't be need to redo this there but is difficult 
+    ///in current architecture
+    public func generateModuleMap(inDir wd: String) throws {
+
+        ///Return if module map is already present
+        guard !moduleMapPath.isFile else {
+            return
+        }
+
+        let includeDir = path
+
+        ///Warn and return if no include directory
+        guard includeDir.isDirectory else {
+            print("warning: No include directory found, a library can not be imported without any public headers.")
+            return
+        }
+
+        let walked = walk(includeDir, recursively: false).map{$0}
+
+        let files = walked.filter{$0.isFile && $0.hasSuffix(".h")}
+        let dirs = walked.filter{$0.isDirectory}
+
+        ///We generate modulemap for a C module `foo` if:
+        ///* `umbrella header "path/to/include/foo/foo.h"` exists and `foo` is the only
+        ///   directory under include directory
+        ///* `umbrella header "path/to/include/foo.h"` exists and include contains no other
+        ///   directory
+        ///* `umbrella "path/to/include"` in all other cases
+
+        let umbrellaHeaderFlat = Path.join(includeDir, "\(c99name).h")
+        if umbrellaHeaderFlat.isFile {
+            guard dirs.isEmpty else { throw ModuleMapError.UnsupportedIncludeLayoutForModule(name) }
+            try createModuleMap(inDir: wd, type: .Header(umbrellaHeaderFlat))
+            return
+        }
+        diagnoseInvalidUmbrellaHeader(includeDir)
+
+        let umbrellaHeader = Path.join(includeDir, c99name, "\(c99name).h")
+        if umbrellaHeader.isFile {
+            guard dirs.count == 1 && files.isEmpty else { throw ModuleMapError.UnsupportedIncludeLayoutForModule(name) }
+            try createModuleMap(inDir: wd, type: .Header(umbrellaHeader))
+            return
+        }
+        diagnoseInvalidUmbrellaHeader(Path.join(includeDir, c99name))
+
+        try createModuleMap(inDir: wd, type: .Directory(includeDir))
+    }
+
+    ///warn user if in case module name and c99name are different and there a `name.h` umbrella header
+    private func diagnoseInvalidUmbrellaHeader(path: String) {
+        let umbrellaHeader = Path.join(path, "\(c99name).h")
+        let invalidUmbrellaHeader = Path.join(path, "\(name).h")
+        if c99name != name && invalidUmbrellaHeader.isFile {
+            print("warning: \(invalidUmbrellaHeader) should be renamed to \(umbrellaHeader) to be used as an umbrella header")
+        }
+    }
+
+    private enum UmbrellaType {
+        case Header(String)
+        case Directory(String)
+    }
+
+    private func createModuleMap(inDir wd: String, type: UmbrellaType) throws {
+        try POSIX.mkdir(wd)
+        let moduleMapFile = Path.join(wd, self.moduleMap)
+        let moduleMap = try fopen(moduleMapFile, mode: .Write)
+        defer { fclose(moduleMap) }
+
+        var output = "module \(c99name) {\n"
+        switch type {
+        case .Header(let header):
+            output += "    umbrella header \"\(header)\"\n"
+        case .Directory(let path):
+            output += "    umbrella \"\(path)\"\n"
+        }
+        output += "    link \"\(c99name)\"\n"
+        output += "    export *\n"
+        output += "}\n"
+
+        try fputs(output, moduleMap)
     }
 }
 

Sources/PackageType/Module.swift

@@ -93,7 +93,6 @@ public class ClangModule: CModule {
 
     public init(name: String, sources: Sources) {
         self.sources = sources
-        //TODO: generate module map using swiftpm if layout can support
         super.init(name: name, path: sources.root + "/include")
     }
 }

Tests/Functional/TestClangModules.swift

@@ -73,7 +73,7 @@ class TestClangModulesTestCase: XCTestCase {
             XCTAssertEqual(output, "hello 5")
         }
     }
-
+    
     func testCUsingCDep2() {
         //The C dependency "Foo" has different layout
         fixture(name: "DependencyResolution/External/CUsingCDep2") { prefix in
@@ -82,6 +82,17 @@ class TestClangModulesTestCase: XCTestCase {
             XCTAssertDirectoryExists(prefix, "Bar/Packages/Foo-1.2.3")
         }
     }
+
+    func testModuleMapGenerationCases() {
+        fixture(name: "ClangModules/ModuleMapGenerationCases") { prefix in
+            XCTAssertBuilds(prefix)
+            XCTAssertFileExists(prefix, ".build", "debug", "libUmbrellaHeader.so")
+            XCTAssertFileExists(prefix, ".build", "debug", "libFlatInclude.so")
+            XCTAssertFileExists(prefix, ".build", "debug", "libUmbellaModuleNameInclude.so")
+            XCTAssertFileExists(prefix, ".build", "debug", "libNoIncludeDir.so")
+            XCTAssertFileExists(prefix, ".build", "debug", "Baz")
+        }
+    }
 }
 
 
@@ -95,6 +106,7 @@ extension TestClangModulesTestCase {
             ("testiquoteDep", testiquoteDep),
             ("testCUsingCDep", testCUsingCDep),
             ("testCExecutable", testCExecutable),
+            ("testModuleMapGenerationCases", testModuleMapGenerationCases),
         ]
     }
 }