[Product] Make product type cases as lower case

Since this is no longer in public API change the cases according to
swift 3 API guidelines.

Author: aciidgh

Sources/Build/BuildPlan.swift

@@ -280,19 +280,19 @@ public final class ProductBuildDescription {
         args += ["-module-name", product.name]
 
         switch product.type {
-        case .Library(.Static):
+        case .library(.static):
             // No arguments for static libraries.
             return []
-        case .Test:
+        case .test:
             // Test products are bundle on macOS, executable on linux.
           #if os(macOS)
             args += ["-Xlinker", "-bundle"]
           #else
             args += ["-emit-executable"]
           #endif
-        case .Library(.Dynamic):
+        case .library(.dynamic):
             args += ["-emit-library"]
-        case .Executable:
+        case .executable:
             args += ["-emit-executable"]
         }
         args += objects.map{$0.asString}
@@ -376,7 +376,7 @@ public class BuildPlan {
             var objects = allModules.filter{ $0.type == .library }.flatMap{ targetMap[$0]!.objects }
 
             // Add objects from main module, if product is an executable.
-            if product.type == .Executable {
+            if product.type == .executable {
                 // FIXME: This should come from product type enum instead of manual search.
                 let mainModule = product.modules.first{$0.type == .executable}!
                 objects += targetMap[mainModule]!.objects
@@ -386,7 +386,7 @@ public class BuildPlan {
             // FIXME: Create a module and target for LinuxMain file on linux.
             // This module just contains one source file (LinuxMain.swift) which acts as manifest to the tests on linux.
             // This will go away once it is possible to auto detect tests.
-            if product.type == .Test {
+            if product.type == .test {
                 let module = SwiftModule(linuxMain: product.linuxMainTest, name: product.name, dependencies: product.modules)
                 let target = SwiftTargetDescription(module: module, buildParameters: buildParameters)
                 targetMap[module] = .swift(target)

Sources/Build/Buildable.swift

@@ -24,21 +24,21 @@ extension Module: Buildable {
 
 extension Product: Buildable {
     var isTest: Bool {
-        if case .Test = type {
+        if case .test = type {
             return true
         }
         return false
     }
 
     var targetName: String {
         switch type {
-        case .Library(.Dynamic):
+        case .library(.dynamic):
             return "<\(name).dylib>"
-        case .Test:
+        case .test:
             return "<\(name).test>"
-        case .Library(.Static):
+        case .library(.static):
             return "<\(name).a>"
-        case .Executable:
+        case .executable:
             return "<\(name).exe>"
         }
     }

Sources/Build/llbuild.swift

@@ -94,7 +94,7 @@ public struct LLbuildManifestGenerator {
     private func createLinkCommand(_ buildProduct: ProductBuildDescription) -> Command {
         let tool: ToolProtocol
         // Create archive tool for static library and shell tool for rest of the products.
-        if buildProduct.product.type == .Library(.Static) {
+        if buildProduct.product.type == .library(.static) {
             tool = ArchiveTool(inputs: buildProduct.objects.map{$0.asString}, outputs: [buildProduct.binary.asString])
         } else {
             tool = ShellTool(

Sources/Commands/SwiftTestTool.swift

@@ -132,7 +132,7 @@ public class SwiftTestTool: SwiftTool<TestToolOptions> {
         // FIXME: We should also check if the package has any test
         // modules, which isn't trivial (yet).
         let testProducts = graph.products.filter{
-            if case .Test = $0.type {
+            if case .test = $0.type {
                 return true
             } else {
                 return false

Sources/PackageLoading/PackageBuilder.swift

@@ -567,7 +567,7 @@ public struct PackageBuilder {
 
         for case let module as SwiftModule in modules {
             if module.type == .executable {
-                let product = Product(name: module.name, type: .Executable, modules: [module])
+                let product = Product(name: module.name, type: .executable, modules: [module])
                 products.append(product)
             }
         }
@@ -576,7 +576,7 @@ public struct PackageBuilder {
 
         for case let module as ClangModule in modules {
             if module.type == .executable {
-                let product = Product(name: module.name, type: .Executable, modules: [module])
+                let product = Product(name: module.name, type: .executable, modules: [module])
                 products.append(product)
             }
         }
@@ -599,7 +599,7 @@ public struct PackageBuilder {
             // TODO and then we should prefix all modules with their package probably.
             // Add suffix 'PackageTests' to test product so the module name of linux executable don't collide with
             // main package, if present.
-            let product = Product(name: manifest.name + "PackageTests", type: .Test, modules: testModules)
+            let product = Product(name: manifest.name + "PackageTests", type: .test, modules: testModules)
             products.append(product)
         }
 
@@ -626,15 +626,15 @@ public struct PackageBuilder {
             switch product {
             case .exe(let p):
                 // FIXME: We should handle/diagnose name collisions between local and vended executables (SR-3562).
-                products += [Product(name: p.name, type: .Executable, modules: try modulesFrom(targetNames: p.targets, product: p.name))]
+                products += [Product(name: p.name, type: .executable, modules: try modulesFrom(targetNames: p.targets, product: p.name))]
             case .lib(let p):
                 // Get the library type.
                 let type: ProductType
                 switch p.type {
-                case .static?: type = .Library(.Static)
-                case .dynamic?: type = .Library(.Dynamic)
+                case .static?: type = .library(.static)
+                case .dynamic?: type = .library(.dynamic)
                 // FIXME: For now infer nil as dylibs, we need to expand PackageModel.Product to store this information.
-                case nil: type = .Library(.Dynamic)
+                case nil: type = .library(.dynamic)
                 }
                 products += [Product(name: p.name, type: type, modules: try modulesFrom(targetNames: p.targets, product: p.name))]
             }

Sources/PackageModel/Product.swift

@@ -11,26 +11,26 @@
 import Basic
 
 public enum LibraryType {
-    case Static
-    case Dynamic
+    case `static`
+    case `dynamic`
 }
 
 public enum ProductType {
-    case Test
-    case Executable
-    case Library(LibraryType)
+    case test
+    case executable
+    case library(LibraryType)
 }
 
 extension ProductType: CustomStringConvertible {
     public var description: String {
         switch self {
-        case .Test:
+        case .test:
             return "test"
-        case .Executable:
+        case .executable:
             return "exe"
-        case .Library(.Static):
+        case .library(.static):
             return "a"
-        case .Library(.Dynamic):
+        case .library(.dynamic):
             return "dylib"
         }
     }
@@ -51,7 +51,7 @@ public class Product {
 
     /// Path to the main file for test product on linux.
     public var linuxMainTest: AbsolutePath {
-        precondition(type == .Test, "This property is only valid for test product type")
+        precondition(type == .test, "This property is only valid for test product type")
         // FIXME: This is hacky, we should get this from package builder.
         let testDirectory = modules.first{$0.isTest}!.sources.root.parentDirectory
         return testDirectory.appending(component: "LinuxMain.swift")
@@ -66,13 +66,13 @@ public class Product {
 
     public var outname: RelativePath {
         switch type {
-        case .Executable:
+        case .executable:
             return RelativePath(name)
-        case .Library(.Static):
+        case .library(.static):
             return RelativePath("lib\(name).a")
-        case .Library(.Dynamic):
+        case .library(.dynamic):
             return RelativePath("lib\(name).\(Product.dynamicLibraryExtension)")
-        case .Test:
+        case .test:
             let base = "\(name).xctest"
             #if os(macOS)
                 return RelativePath("\(base)/Contents/MacOS/\(name)")
@@ -95,7 +95,7 @@ extension Product: CustomStringConvertible {
     public var description: String {
         let base = outname.basename
         switch type {
-        case .Test:
+        case .test:
             return "\(base).xctest"
         default:
             return base
@@ -106,17 +106,17 @@ extension Product: CustomStringConvertible {
 extension ProductType: Equatable {}
 public func ==(lhs: ProductType, rhs: ProductType) -> Bool {
     switch (lhs, rhs) {
-    case (.Executable, .Executable):
+    case (.executable, .executable):
         return true
-    case (.Executable, _):
+    case (.executable, _):
         return false
-    case (.Test, .Test):
+    case (.test, .test):
         return true
-    case (.Test, _):
+    case (.test, _):
         return false
-    case (.Library(let lhsType), .Library(let rhsType)):
+    case (.library(let lhsType), .library(let rhsType)):
         return lhsType == rhsType
-    case (.Library(_), _):
+    case (.library(_), _):
         return false
     }
 }

Tests/PackageLoadingTests/ConventionTests.swift

@@ -678,23 +678,23 @@ class ConventionTests: XCTestCase {
             }
 
             result.checkProduct("libpmS") { productResult in
-                productResult.check(type: .Library(.Static), modules: ["Bar", "Foo"])
+                productResult.check(type: .library(.static), modules: ["Bar", "Foo"])
             }
 
             result.checkProduct("libpmD") { productResult in
-                productResult.check(type: .Library(.Dynamic), modules: ["Bar", "Foo"])
+                productResult.check(type: .library(.dynamic), modules: ["Bar", "Foo"])
             }
 
             result.checkProduct("libpmA") { productResult in
-                productResult.check(type: .Library(.Dynamic), modules: ["Foo"])
+                productResult.check(type: .library(.dynamic), modules: ["Foo"])
             }
 
             result.checkProduct("executable") { productResult in
-                productResult.check(type: .Executable, modules: ["Foo", "exe"])
+                productResult.check(type: .executable, modules: ["Foo", "exe"])
             }
 
             result.checkProduct("exe") { productResult in
-                productResult.check(type: .Executable, modules: ["exe"])
+                productResult.check(type: .executable, modules: ["exe"])
             }
         }
     }
@@ -717,7 +717,7 @@ class ConventionTests: XCTestCase {
             }
 
             result.checkProduct("FooPackageTests") { productResult in
-                productResult.check(type: .Test, modules: ["FooTests"])
+                productResult.check(type: .test, modules: ["FooTests"])
             }
         }
 
@@ -750,7 +750,7 @@ class ConventionTests: XCTestCase {
             }
 
             result.checkProduct("FooPackageTests") { productResult in
-                productResult.check(type: .Test, modules: ["BarTests", "FooTests"])
+                productResult.check(type: .test, modules: ["BarTests", "FooTests"])
             }
         }
     }