WIP: Ability to write out package manifests as source code, providing more flexibility for things like mechanical package manifest generation.

Note that this is _not_ suitable for editing the package manifest, since that would need to preserve whitespace and comments.  Rather, this is for things like automatically generating packages from test sets, or for generating the initial configuration of packages (e.g. a more flexible `package init`).

This is still a WIP, and still needs support for:
- resources
- build settings
- binary targets

Additionally, there are FIXMEs to resolve and many more unit tests to add.

rdar://70271810

Author: abertelrud

Sources/PackageModel/ManifestSourceGeneration.swift

@@ -0,0 +1,326 @@
+/*
+ This source file is part of the Swift.org open source project
+
+ Copyright (c) 2020 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 TSCBasic
+import TSCUtility
+import Foundation
+
+/// Extensions on Manifest for generating source code expressing its contents
+/// in canonical declarative form.  Note that this bakes in the results of any
+/// algorithmically generated manifest content, so it is not suitable for the
+/// mechanical editing of package manifests.  Rather, it is intended for such
+/// tasks as manifest creation as part of package instantiation, etc.
+extension Manifest {
+    
+    /// Generates and returns a string containing the contents of the manifest
+    /// in canonical declarative form.
+    public var generatedManifestFileContents: String {
+        return """
+            // swift-tools-version: \(toolsVersion.description)
+            import PackageDescription
+
+            let package = \(SourceCodeFragment(from: self).generateSourceCode())
+            """
+    }
+}
+
+
+/// Convenience initializers for package manifest structures.
+fileprivate extension SourceCodeFragment {
+    
+    /// Instantiates a SourceCodeFragment to represent an entire manifest.
+    convenience init(from manifest: Manifest) {
+        var params: [SourceCodeFragment] = []
+        
+        params.append(SourceCodeFragment(key: "name", string: manifest.name))
+        
+        if let defaultLoc = manifest.defaultLocalization {
+            // FIXME: The value being emitted here is probably not correct.
+            let locName = String(describing: defaultLoc)
+            params.append(SourceCodeFragment(key: "defaultLocalization", string: locName))
+        }
+        
+        if !manifest.platforms.isEmpty {
+            let nodes = manifest.platforms.map{ SourceCodeFragment(from: $0) }
+            params.append(SourceCodeFragment(key: "platforms", subnodes: nodes))
+        }
+        
+        // FIXME: Add support for `pkgConfig` and `providers` properties.
+        
+        if !manifest.products.isEmpty {
+            let nodes = manifest.products.map{ SourceCodeFragment(from: $0) }
+            params.append(SourceCodeFragment(key: "products", subnodes: nodes))
+        }
+
+        if !manifest.dependencies.isEmpty {
+            let nodes = manifest.dependencies.map{ SourceCodeFragment(from: $0) }
+            params.append(SourceCodeFragment(key: "dependencies", subnodes: nodes))
+        }
+
+        if !manifest.targets.isEmpty {
+            let nodes = manifest.targets.map{ SourceCodeFragment(from: $0) }
+            params.append(SourceCodeFragment(key: "targets", subnodes: nodes))
+        }
+        
+        if let swiftLanguageVersions = manifest.swiftLanguageVersions {
+            let nodes = swiftLanguageVersions.map{ SourceCodeFragment(from: $0) }
+            params.append(SourceCodeFragment(key: "swiftLanguageVersions", subnodes: nodes))
+        }
+
+        if let cLanguageStandard = manifest.cLanguageStandard {
+            // FIXME: The value being emitted here is probably not correct.
+            params.append(SourceCodeFragment(key: "cLanguageStandard", string: cLanguageStandard))
+        }
+
+        if let cxxLanguageStandard = manifest.cxxLanguageStandard {
+            // FIXME: The value being emitted here is probably not correct.
+            params.append(SourceCodeFragment(key: "cxxLanguageStandard", string: cxxLanguageStandard))
+        }
+
+        self.init("Package", delimiters: .parentheses, subnodes: params)
+    }
+    
+    /// Instantiates a SourceCodeFragment to represent a single platform.
+    convenience init(from platform: PlatformDescription) {
+        // FIXME: The name and value being emitted here is probably not correct.
+        let name = platform.platformName
+        let version = platform.version
+        self.init(".\(name)(\(version.quotedForPackageManifest))")
+    }
+    
+    /// Instantiates a SourceCodeFragment to represent a single package dependency.
+    convenience init(from dependency: PackageDependencyDescription) {
+        var params: [SourceCodeFragment] = []
+        
+        if let explicitName = dependency.explicitName {
+            params.append(SourceCodeFragment(key: "name", string: explicitName))
+        }
+        switch dependency.requirement {
+        case .exact(let version):
+            params.append(SourceCodeFragment(key: "url", string: dependency.url))
+            params.append(SourceCodeFragment(".exact(\(version.description.quotedForPackageManifest))"))
+        case .range(let range):
+            params.append(SourceCodeFragment(key: "url", string: dependency.url))
+            params.append(SourceCodeFragment(".range(\(range.description.quotedForPackageManifest))"))
+        case .revision(let revision):
+            params.append(SourceCodeFragment(key: "url", string: dependency.url))
+            params.append(SourceCodeFragment(".revision(\(revision.quotedForPackageManifest)"))
+        case .branch(let branch):
+            params.append(SourceCodeFragment(key: "url", string: dependency.url))
+            params.append(SourceCodeFragment(".branch(\(branch.quotedForPackageManifest)"))
+        case .localPackage:
+            params.append(SourceCodeFragment(key: "path", string: dependency.url))
+        }
+        self.init(".package", delimiters: .parentheses, multiline: false, subnodes: params)
+    }
+    
+    /// Instantiates a SourceCodeFragment to represent a single product.
+    convenience init(from product: ProductDescription) {
+        let literal: String
+        var params: [SourceCodeFragment] = []
+
+        params.append(SourceCodeFragment(key: "name", string: product.name))
+        switch product.type {
+        case .library(let type):
+            literal = ".library"
+            if type != .automatic {
+                params.append(SourceCodeFragment(key: "type", enum: type.rawValue))
+            }
+        case .executable:
+            literal = ".executable"
+        case .test:
+            literal = ".test"
+        }
+        if !product.targets.isEmpty {
+            params.append(SourceCodeFragment(key: "targets", strings: product.targets))
+        }
+        self.init(literal, delimiters: .parentheses, subnodes: params)
+    }
+    
+    /// Instantiates a SourceCodeFragment to represent a single target.
+    convenience init(from target: TargetDescription) {
+        let literal: String
+        var params: [SourceCodeFragment] = []
+
+        params.append(SourceCodeFragment(key: "name", string: target.name))
+        switch target.type {
+        case .regular:
+            literal = ".target"
+        case .test:
+            literal = ".testTarget"
+        case .system:
+            literal = ".systemTarget"
+        case .binary:
+            literal = ".binaryTarget"
+        }
+        if !target.dependencies.isEmpty {
+            let nodes = target.dependencies.map{ SourceCodeFragment(from: $0) }
+            params.append(SourceCodeFragment(key: "dependencies", subnodes: nodes))
+        }
+        // FIXME: Add build settings, etc, etc
+        self.init(literal, delimiters: .parentheses, subnodes: params)
+    }
+
+    /// Instantiates a SourceCodeFragment to represent a single target dependency.
+    convenience init(from dependency: TargetDescription.Dependency) {
+        var params: [SourceCodeFragment] = []
+
+        switch dependency {
+        case .target(name: let name, condition: let condition):
+            params.append(SourceCodeFragment(key: "name", string: name))
+            if let condition = condition {
+                let configNode = SourceCodeFragment(from: condition)
+                params.append(SourceCodeFragment("condition: \(configNode.generateSourceCode())"))
+            }
+            self.init(".target", delimiters: .parentheses, subnodes: params)
+            
+        case .product(name: let name, package: let packageName, condition: let condition):
+            params.append(SourceCodeFragment(key: "name", string: name))
+            if let packageName = packageName {
+                params.append(SourceCodeFragment(key: "package", string: packageName))
+            }
+            if let condition = condition {
+                let configNode = SourceCodeFragment(from: condition)
+                params.append(SourceCodeFragment("condition: \(configNode.generateSourceCode())"))
+            }
+            self.init(".product", delimiters: .parentheses, subnodes: params)
+            
+        case .byName(name: let name, condition: let condition):
+            if let condition = condition {
+                params.append(SourceCodeFragment(key: "name", string: name))
+                let configNode = SourceCodeFragment(from: condition)
+                params.append(SourceCodeFragment("condition: \(configNode.generateSourceCode())"))
+                self.init(".product", delimiters: .parentheses, multiline: false, subnodes: params)
+            }
+            else {
+                self.init(name.quotedForPackageManifest)
+            }
+        }
+    }
+    
+    /// Instantiates a SourceCodeFragment to represent a single dependency condition.
+    convenience init(from condition: PackageConditionDescription) {
+        var params: [SourceCodeFragment] = []
+
+        if !condition.platformNames.isEmpty {
+            let nodes = condition.platformNames.map{ SourceCodeFragment(".\($0)") }
+            params.append(SourceCodeFragment(key: "platforms", multiline: false, subnodes: nodes))
+        }
+        if let configName = condition.config {
+            params.append(SourceCodeFragment(key: "configuration", enum: configName))
+        }
+        self.init(".when", delimiters: .parentheses, multiline: false, subnodes: params)
+    }
+
+    /// Instantiates a SourceCodeFragment to represent a single Swift language version.
+    convenience init(from version: SwiftLanguageVersion) {
+        let version = String(describing: version)  // FIXME
+        self.init(".version(\(version.quotedForPackageManifest))")
+    }
+}
+
+
+/// Convenience initializers for key-value pairs of simple types.
+fileprivate extension SourceCodeFragment {
+    
+    /// Initializes a SourceCodeFragment for a boolean in a generated manifest.
+    convenience init(key: String, boolean: Bool) {
+        self.init(key + ": " + (boolean ? "true" : "false"))
+    }
+
+    /// Initializes a SourceCodeFragment for a quoted string in a generated manifest.
+    convenience init(key: String, string: String) {
+        self.init(key + ": " + string.quotedForPackageManifest)
+    }
+
+    /// Initializes a SourceCodeFragment for an enum in a generated manifest.
+    convenience init(key: String, enum: String) {
+        self.init(key + ": ." + `enum`)
+    }
+
+    /// Initializes a SourceCodeFragment for a string list in a generated manifest.
+    convenience init(key: String, strings: [String]) {
+        let subnodes = strings.map{ SourceCodeFragment($0.quotedForPackageManifest) }
+        self.init(key + ": ", delimiters: .brackets, subnodes: subnodes)
+    }
+
+    /// Initializes a SourceCodeFragment for a list of nodes in a generated manifest.
+    convenience init(key: String, multiline: Bool = true, subnodes: [SourceCodeFragment]) {
+        self.init(key + ": ", delimiters: .brackets, multiline: multiline, subnodes: subnodes)
+    }
+}
+
+
+
+/// Helper type to emit source code.  Represents one node of source code, as a
+/// arbitrary string followed by an optional child list, optionally enclosed in
+/// a pair of delimiters.  The code generation works by creating source code
+/// fragments and then rendering them as source code with proper formatting.
+fileprivate class SourceCodeFragment {
+    let literal: String
+    var delimiters: Delimiters
+    var multiline: Bool
+    var subnodes: [SourceCodeFragment]
+
+    enum Delimiters {
+        case none
+        case brackets
+        case parentheses
+    }
+    
+    init(_ literal: String, delimiters: Delimiters = .none,
+         multiline: Bool = true, subnodes: [SourceCodeFragment] = []) {
+        self.literal = literal
+        self.delimiters = delimiters
+        self.multiline = multiline
+        self.subnodes = subnodes
+    }
+    
+    func generateSourceCode(indent: String = "") -> String {
+        var string = literal
+        if !subnodes.isEmpty {
+            switch delimiters {
+            case .none: break
+            case .brackets: string.append("[")
+            case .parentheses: string.append("(")
+            }
+            if multiline { string.append("\n") }
+            for (idx, subnode) in subnodes.enumerated() {
+                let subindent = indent + "    "
+                if multiline { string.append(subindent) }
+                string.append(subnode.generateSourceCode(indent: subindent))
+                if idx < subnodes.count-1 {
+                    string.append(multiline ? ",\n" : ", ")
+                }
+            }
+            if multiline {
+                string.append("\n")
+                string.append(indent)
+            }
+            switch delimiters {
+            case .none: break
+            case .brackets: string.append("]")
+            case .parentheses: string.append(")")
+            }
+        }
+        return string
+    }
+}
+
+
+fileprivate extension String {
+    
+    var quotedForPackageManifest: String {
+        return "\"" + self
+            .replacingOccurrences(of: "\\", with: "\\\\")
+            .replacingOccurrences(of: "\"", with: "\\\"")
+            + "\""
+    }
+}