Refactor Build

This makes it more maintainable by splitting out the code into separate files and independent functions based on purpose. The code is more encapsulated and its boundaries more defined.

Ready for static library implementation.

Author: mxcl

Sources/Build/Buildable.swift

@@ -0,0 +1,58 @@
+/*
+ This source file is part of the Swift.org open source project
+
+ Copyright 2015 - 2016 Apple Inc. and the Swift project authors
+ Licensed under Apache License v2.0 with Runtime Library Exception
+
+ See http://swift.org/LICENSE.txt for license information
+ See http://swift.org/CONTRIBUTORS.txt for Swift project authors
+*/
+
+import PackageType
+
+protocol Buildable {
+    var targetName: String { get }
+    var isTest: Bool { get }
+}
+
+extension Module: Buildable {
+    var isTest: Bool {
+        return self is TestModule
+    }
+
+    var Xcc: [String] {
+        return recursiveDependencies.flatMap { module -> [String] in
+            if let module = module as? CModule {
+                return ["-Xcc", "-fmodule-map-file=\(module.moduleMapPath)"]
+            } else {
+                return []
+            }
+        }
+    }
+
+    var targetName: String {
+        return "<\(name).module>"
+    }
+}
+
+extension Product: Buildable {
+    var isTest: Bool {
+        if case .Test = type {
+            return true
+        }
+        return false
+    }
+
+    var targetName: String {
+        switch type {
+        case .Library(.Dynamic):
+            return "<\(name).dylib>"
+        case .Test:
+            return "<\(name).test>"
+        case .Library(.Static):
+            return "<\(name).a>"
+        case .Executable:
+            return "<\(name).exe>"
+        }
+    }
+}

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

@@ -0,0 +1,71 @@
+/*
+ This source file is part of the Swift.org open source project
+
+ Copyright 2015 - 2016 Apple Inc. and the Swift project authors
+ Licensed under Apache License v2.0 with Runtime Library Exception
+
+ See http://swift.org/LICENSE.txt for license information
+ See http://swift.org/CONTRIBUTORS.txt for Swift project authors
+*/
+
+import PackageType
+import Utility
+import POSIX
+
+//FIXME: Incremental builds
+
+extension Command {
+    static func compile(clangModule module: ClangModule, configuration conf: Configuration, prefix: String) -> (Command, Command) {
+
+        let wd = Path.join(prefix, "\(module.c99name).build")
+        let mkdir = Command.createDirectory(wd)
+
+        let inputs = module.dependencies.map{ $0.targetName } + module.sources.paths + [mkdir.node]
+        let productPath = Path.join(prefix, "lib\(module.c99name).so")
+
+        var args: [String] = []
+    #if os(Linux)
+        args += ["-fPIC"]
+    #endif
+        args += ["-fmodules", "-fmodule-name=\(module.name)"]
+        args += ["-L\(prefix)"]
+
+        for case let dep as ClangModule in module.dependencies {
+            let includeFlag: String
+            //add `-iquote` argument to the include directory of every target in the package in the
+            //transitive closure of the target being built allowing the use of `#include "..."`
+            //add `-I` argument to the include directory of every target outside the package in the
+            //transitive closure of the target being built allowing the use of `#include <...>`
+            //FIXME: To detect external deps we're checking if their path's parent.parent directory
+            //is `Packages` as external deps will get copied to `Packages` dir. There should be a
+            //better way to do this.
+            if dep.path.parentDirectory.parentDirectory.basename == "Packages" {
+                includeFlag = "-I"
+            } else {
+                includeFlag = "-iquote"
+            }
+            args += [includeFlag, dep.path]
+            args += ["-l\(dep.c99name)"] //FIXME: giving path to other module's -fmodule-map-file is not linking that module
+        }
+
+        switch conf {
+        case .Debug:
+            args += ["-g", "-O0"]
+        case .Release:
+            args += ["-O2"]
+        }
+
+        args += module.sources.paths
+        args += ["-shared", "-o", productPath]
+
+        let clang = ShellTool(
+            description: "Compiling \(module.name)",
+            inputs: inputs,
+            outputs: [productPath, module.targetName],
+            args: [Toolchain.clang] + args)
+
+        let command = Command(node: module.targetName, tool: clang)
+
+        return (command, mkdir)
+    }
+}

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

@@ -0,0 +1,57 @@
+/*
+ This source file is part of the Swift.org open source project
+
+ Copyright 2015 - 2016 Apple Inc. and the Swift project authors
+ Licensed under Apache License v2.0 with Runtime Library Exception
+
+ See http://swift.org/LICENSE.txt for license information
+ See http://swift.org/CONTRIBUTORS.txt for Swift project authors
+*/
+
+import PackageType
+import Utility
+
+extension Command {
+    static func compile(swiftModule module: SwiftModule, configuration conf: Configuration, prefix: String, otherArgs: [String]) throws -> (Command, [Command]) {
+
+        let otherArgs = otherArgs + module.Xcc
+
+        func cmd(tool: ToolProtocol) -> Command {
+            return Command(node: module.targetName, tool: tool)
+        }
+
+        switch conf {
+        case .Debug:
+            var args = ["-j8","-Onone","-g","-D","SWIFT_PACKAGE", "-enable-testing"]
+
+        #if os(OSX)
+            if let platformPath = Toolchain.platformPath {
+                let path = Path.join(platformPath, "Developer/Library/Frameworks")
+                args += ["-F", path]
+            } else {
+                throw Error.InvalidPlatformPath
+            }
+        #endif
+            let tool = SwiftcTool(module: module, prefix: prefix, otherArgs: args + otherArgs)
+            let mkdirs = Set(tool.objects.map{ $0.parentDirectory }).map(Command.createDirectory)
+            return (cmd(tool), mkdirs)
+
+        case .Release:
+            let inputs = module.dependencies.map{ $0.targetName } + module.sources.paths
+            var args = ["-c", "-emit-module", "-D", "SWIFT_PACKAGE", "-O", "-whole-module-optimization", "-I", prefix] + otherArgs
+            let productPath = Path.join(prefix, "\(module.c99name).o")
+
+            if module.type == .Library {
+                args += ["-parse-as-library"]
+            }
+
+            let tool = ShellTool(
+                description: "Compiling \(module.name)",
+                inputs: inputs,
+                outputs: [productPath, module.targetName],
+                args: [Toolchain.swiftc, "-o", productPath] + args + module.sources.paths + otherArgs)
+
+            return (cmd(tool), [])
+        }
+    }
+}

Sources/Build/Command.link().swift

@@ -0,0 +1,97 @@
+/*
+ This source file is part of the Swift.org open source project
+
+ Copyright 2015 - 2016 Apple Inc. and the Swift project authors
+ Licensed under Apache License v2.0 with Runtime Library Exception
+
+ See http://swift.org/LICENSE.txt for license information
+ See http://swift.org/CONTRIBUTORS.txt for Swift project authors
+*/
+
+import func POSIX.mkdir
+import PackageType
+import Utility
+
+extension Command {
+    static func link(product: Product, configuration conf: Configuration, prefix: String, otherArgs: [String]) throws -> Command {
+
+        let objects: [String]
+        switch conf {
+        case .Release:
+            objects = product.buildables.map{ Path.join(prefix, "\($0.c99name).o") }
+        case .Debug:
+            objects = product.buildables.flatMap{ return SwiftcTool(module: $0, prefix: prefix, otherArgs: []).objects }
+        }
+
+        let outpath = Path.join(prefix, product.outname)
+
+        var args = [Toolchain.swiftc] + otherArgs
+
+        switch product.type {
+        case .Library(.Static):
+            fatalError("Unimplemented")
+        case .Test:
+          #if os(OSX)
+            args += ["-Xlinker", "-bundle"]
+
+            if let platformPath = Toolchain.platformPath {
+                let path = Path.join(platformPath, "Developer/Library/Frameworks")
+                args += ["-F", path]
+            } else {
+                throw Error.InvalidPlatformPath
+            }
+
+            // TODO should be llbuild rules∫
+            if conf == .Debug {
+                try mkdir(outpath.parentDirectory)
+                try fopen(outpath.parentDirectory.parentDirectory, "Info.plist", mode: .Write) { fp in
+                    try fputs(product.Info.plist, fp)
+                }
+            }
+          #else
+            // HACK: To get a path to LinuxMain.swift, we just grab the
+            //       parent directory of the first test module we can find.
+            let firstTestModule = product.modules.flatMap{ $0 as? TestModule }.first!
+            let testDirectory = firstTestModule.sources.root.parentDirectory
+            let main = Path.join(testDirectory, "LinuxMain.swift")
+            args.append(main)
+            for module in product.modules {
+                args += module.Xcc
+            }
+            args.append("-emit-executable")
+            args += ["-I", prefix]
+          #endif
+        case .Library(.Dynamic):
+            args.append("-emit-library")
+        case .Executable:
+            args.append("-emit-executable")
+            if conf == .Release {
+                args += ["-Xlinker", "-dead_strip"]
+            }
+        }
+
+        if conf == .Debug {
+            args += ["-g"]
+        }
+
+        args += ["-L\(prefix)"]
+        args += ["-o", outpath]
+        args += objects
+
+        let inputs = product.modules.flatMap{ [$0.targetName] + SwiftcTool(module: $0, prefix: prefix, otherArgs: []).inputs }
+
+        let shell = ShellTool(
+            description: "Linking \(outpath.prettyPath)",
+            inputs: inputs,
+            outputs: [product.targetName, outpath],
+            args: args)
+
+        return Command(node: product.targetName, tool: shell)
+    }
+}
+
+extension Product {
+    private var buildables: [SwiftModule] {
+        return recursiveDependencies(modules.map{$0}).flatMap{ $0 as? SwiftModule }
+    }
+}

Sources/Build/Command.swift

@@ -0,0 +1,18 @@
+/*
+ This source file is part of the Swift.org open source project
+
+ Copyright 2015 - 2016 Apple Inc. and the Swift project authors
+ Licensed under Apache License v2.0 with Runtime Library Exception
+
+ See http://swift.org/LICENSE.txt for license information
+ See http://swift.org/CONTRIBUTORS.txt for Swift project authors
+*/
+
+struct Command {
+    let node: String
+    let tool: ToolProtocol
+
+    static func createDirectory(path: String) -> Command {
+        return Command(node: path, tool: MkdirTool(path: path))
+    }
+}