Merge `static products'

Author: mxcl

Fixtures/Miscellaneous/StaticProduct/Foo.swift

@@ -0,0 +1,3 @@
+public class Foo {
+    var bar: Int = 0
+}

Fixtures/Miscellaneous/StaticProduct/Package.swift

@@ -0,0 +1,7 @@
+import PackageDescription
+
+let package = Package(name: "Foo")
+
+let archive = Product(name: "Bar", type: .Library(.Static), modules: "Foo")
+
+products.append(archive)

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,124 @@
+/*
+ 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
+
+
+//FIXME messy :/
+
+
+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: [String]
+        switch product.type {
+        case .Library(.Dynamic), .Executable, .Test:
+            args = [Toolchain.swiftc] + otherArgs
+
+            if conf == .Debug {
+                args += ["-g"]
+            }
+            args += ["-L\(prefix)"]
+            args += ["-o", outpath]
+
+        case .Library(.Static):
+            //FIXME proper static archive llbuild tool
+            //NOTE HACK this works because llbuild runs it with via a shell
+            //FIXME this is coincidental, do properly
+            args = ["rm", "-f", outpath, "&&", "ar", "cr"]
+        }
+
+        let inputs = product.modules.flatMap { module -> [String] in
+            switch conf {
+            case .Debug:
+                let tool = SwiftcTool(module: module, prefix: prefix, otherArgs: [])
+                // must return tool’s outputs and inputs as shell nodes don't calculate more than that
+                return tool.inputs + tool.outputs
+            case .Release:
+                return objects
+            }
+        }
+
+        switch product.type {
+        case .Library(.Static):
+            args.append(outpath)
+        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")
+        }
+
+        args += objects
+
+        if case .Library(.Static) = product.type {
+            //HACK we need to be executed passed-through to the shell
+            // otherwise we cannot do the rm -f first
+            //FIXME make a proper static archive tool for llbuild
+            args = [args.joined(separator: " ")] //TODO escape!
+        }
+
+        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))
+    }
+}