Merge pull request #322 from tayloraswift/simplify-toolchain-spec

simplify toolchain path specification interface

Author: tayloraswift

Sources/SymbolGraphBuilder/Builds/SSGC.PackageBuild.swift

@@ -188,21 +188,21 @@ extension SSGC.PackageBuild:SSGC.DocumentationBuild
 {
     func compile(updating status:SSGC.StatusStream?,
         cache:FilePath.Directory,
-        with swift:SSGC.Toolchain,
+        with toolchain:SSGC.Toolchain,
         clean:Bool = true) throws -> (SymbolGraphMetadata, any SSGC.DocumentationSources)
     {
         switch self.type
         {
         case .package:
             try self.compileSwiftPM(updating: status,
                 cache: cache,
-                with: swift,
+                with: toolchain,
                 clean: clean)
 
         case .book:
             try self.compileBook(updating: status,
                 cache: cache,
-                with: swift)
+                with: toolchain)
         }
     }
 }
@@ -212,7 +212,7 @@ extension SSGC.PackageBuild
     @_spi(testable) public
     func compileBook(updating status:SSGC.StatusStream? = nil,
         cache _:FilePath.Directory,
-        with swift:SSGC.Toolchain) throws -> (SymbolGraphMetadata, SSGC.BookSources)
+        with toolchain:SSGC.Toolchain) throws -> (SymbolGraphMetadata, SSGC.BookSources)
     {
         switch self.id
         {
@@ -239,8 +239,8 @@ extension SSGC.PackageBuild
                 scope: self.id.pin?.location.owner,
                 name: self.id.package),
             commit: self.id.commit,
-            triple: swift.triple,
-            swift: swift.id,
+            triple: toolchain.splash.triple,
+            swift: toolchain.splash.swift,
             tools: nil,
             manifests: [],
             requirements: [],
@@ -255,7 +255,7 @@ extension SSGC.PackageBuild
     @_spi(testable) public
     func compileSwiftPM(updating status:SSGC.StatusStream? = nil,
         cache:FilePath.Directory,
-        with swift:SSGC.Toolchain,
+        with toolchain:SSGC.Toolchain,
         clean:Bool = true) throws -> (SymbolGraphMetadata, SSGC.PackageSources)
     {
         if  clean
@@ -277,7 +277,7 @@ extension SSGC.PackageBuild
         }
 
         let manifestVersions:[MinorVersion] = try self.listExtraManifests()
-        var manifest:SPM.Manifest = try swift.manifest(package: self.root,
+        var manifest:SPM.Manifest = try toolchain.manifest(package: self.root,
             json: artifacts / "\(self.id.package).package.json",
             leaf: true)
 
@@ -289,7 +289,7 @@ extension SSGC.PackageBuild
         let pins:[SPM.DependencyPin]
         do
         {
-            pins = try swift.resolve(package: self.root)
+            pins = try toolchain.resolve(package: self.root)
         }
         catch SystemProcessError.exit(let code, let invocation)
         {
@@ -300,7 +300,7 @@ extension SSGC.PackageBuild
 
         do
         {
-            try swift.build(package: self.root,
+            try toolchain.build(package: self.root,
                 using: self.scratch,
                 flags: self.flags.dumping(symbols: .default, to: artifacts))
         }
@@ -309,14 +309,14 @@ extension SSGC.PackageBuild
             throw SSGC.PackageBuildError.swift_build(code, invocation)
         }
 
-        let platform:SymbolGraphMetadata.Platform = try swift.platform()
+        let platform:SymbolGraphMetadata.Platform = try toolchain.platform()
         var packages:SSGC.PackageGraph = .init(platform: platform)
 
         for pin:SPM.DependencyPin in pins
         {
             print("Dumping manifest for package '\(pin.identity)' at \(pin.state)")
 
-            let manifest:SPM.Manifest = try swift.manifest(
+            let manifest:SPM.Manifest = try toolchain.manifest(
                 package: self.scratch.location / "checkouts" / "\(pin.location.name)",
                 json: artifacts / "\(pin.identity).package.json",
                 leaf: false)
@@ -329,14 +329,17 @@ extension SSGC.PackageBuild
             as: self.id.package)
 
         //  Dump the standard library’s symbols, unless they’re already cached.
-        let artifactsCached:FilePath.Directory = try swift.dump(
+        let artifactsCached:FilePath.Directory = try toolchain.dump(
             standardLibrary: .init(platform: platform),
             options: .default,
             cache: cache)
         for (module, include):(Symbol.Module, [FilePath.Directory]) in try self.modulesToDump(
             among: modules)
         {
-            try swift.dump(module: module, to: artifacts, options: .default, include: include)
+            try toolchain.dump(module: module,
+                to: artifacts,
+                options: .default,
+                include: include)
         }
 
         //  This step is considered part of documentation building.
@@ -374,8 +377,8 @@ extension SSGC.PackageBuild
                 scope: self.id.pin?.location.owner,
                 name: self.id.package),
             commit: self.id.commit,
-            triple: swift.triple,
-            swift: swift.id,
+            triple: toolchain.splash.triple,
+            swift: toolchain.splash.swift,
             tools: manifest.format,
             manifests: manifestVersions,
             requirements: manifest.requirements,

Sources/SymbolGraphBuilder/SSGC.Compile.swift

@@ -46,27 +46,21 @@ extension SSGC
         var outputLog:FilePath? = nil
 
         @Option(
-            name: [.customLong("swift-runtime")],
-            help: "The path to the Swift runtime directory, usually ending in /usr/lib",
+            name: [.customLong("swift-toolchain"), .customShort("u")],
+            help: "The path to a Swift toolchain directory, usually ending in 'usr'",
             completion: .directory)
-        var swiftRuntime:FilePath.Directory? = nil
+        var swiftTools:FilePath.Directory?
 
         @Option(
             name: [.customLong("swiftpm-cache")],
             help: "The path to the SwiftPM cache directory to use",
             completion: .directory)
         var swiftCache:FilePath.Directory?
 
-        @Option(
-            name: [.customLong("swift"), .customShort("s")],
-            help: "The path to the Swift toolchain",
-            completion: .file(extensions: []))
-        var swiftPath:FilePath? = nil
-
         @Option(
             name: [.customLong("sdk"), .customShort("k")],
-            help: "The Swift SDK to use")
-        var swiftSDK:AppleSDK? = nil
+            help: "The Apple SDK to use")
+        var appleSDK:AppleSDK? = nil
 
         @Option(
             name: [.customLong("package-name"), .customShort("n")],
@@ -221,10 +215,8 @@ extension SSGC.Compile
         status:SSGC.StatusStream?,
         logger:SSGC.Logger) throws
     {
-        let toolchain:SSGC.Toolchain = try .detect(swiftRuntime: self.swiftRuntime,
-            swiftCache: self.swiftCache,
-            swiftPath: self.swiftPath,
-            swiftSDK: self.swiftSDK,
+        let toolchain:SSGC.Toolchain = try .detect(appleSDK: self.appleSDK,
+            paths: .init(swiftPM: self.swiftCache, usr: self.swiftTools),
             pretty: self.pretty)
 
         let object:SymbolGraphObject<Void>

Sources/SymbolGraphBuilder/Standard library/SSGC.StandardLibraryBuild.swift

@@ -21,18 +21,18 @@ extension SSGC.StandardLibraryBuild:SSGC.DocumentationBuild
 {
     func compile(updating _:SSGC.StatusStream?,
         cache:FilePath.Directory,
-        with swift:SSGC.Toolchain,
+        with toolchain:SSGC.Toolchain,
         clean _:Bool) throws -> (SymbolGraphMetadata, any SSGC.DocumentationSources)
     {
-        let standardLibrary:SSGC.StandardLibrary = .init(platform: try swift.platform())
+        let standardLibrary:SSGC.StandardLibrary = .init(platform: try toolchain.platform())
 
-        let artifacts:FilePath.Directory = try swift.dump(standardLibrary: standardLibrary,
+        let artifacts:FilePath.Directory = try toolchain.dump(standardLibrary: standardLibrary,
             options: .default,
             cache: cache)
 
-        let metadata:SymbolGraphMetadata = .swift(swift.id,
-            commit: swift.commit,
-            triple: swift.triple,
+        let metadata:SymbolGraphMetadata = .swift(toolchain.splash.swift,
+            commit: toolchain.splash.commit,
+            triple: toolchain.splash.triple,
             products: standardLibrary.products)
 
         let sources:SSGC.StandardLibrarySources = .init(modules: standardLibrary.modules,

Sources/SymbolGraphBuilder/Toolchains/SSGC.Toolchain.Paths.swift

@@ -0,0 +1,61 @@
+import System
+
+extension SSGC.Toolchain
+{
+    @frozen public
+    struct Paths
+    {
+        /// A path to the SwiftPM cache directory to use.
+        @usableFromInline
+        let swiftPM:FilePath.Directory?
+        /// A path to a Swift toolchain to use, usually ending in `usr`.
+        @usableFromInline
+        let usr:FilePath.Directory?
+
+        @inlinable public
+        init(swiftPM:FilePath.Directory?, usr:FilePath.Directory?)
+        {
+            self.swiftPM = swiftPM
+            self.usr = usr
+        }
+    }
+}
+extension SSGC.Toolchain.Paths
+{
+    /// Returns the path to the `swift` executable, or just the string `swift`.
+    var swiftCommand:String
+    {
+        guard
+        let usr:FilePath.Directory = self.usr
+        else
+        {
+            return "swift"
+        }
+
+        let swift:FilePath = usr / "bin" / "swift"
+        return swift.string
+    }
+
+    var libIndexStore:FilePath
+    {
+        let name:FilePath.Component
+        let usr:FilePath.Directory
+
+        #if os(macOS)
+
+            name = "libIndexStore.dylib"
+            usr = self.usr ?? """
+            /Applications/Xcode.app/Contents/Developer/Toolchains\
+            /XcodeDefault.xctoolchain/usr
+            """
+
+        #else
+
+            name = "libIndexStore.so"
+            usr = self.usr ?? "/usr"
+
+        #endif
+
+        return usr / "lib" / name
+    }
+}

Sources/SymbolGraphBuilder/Toolchains/SSGC.Toolchain.Splash.swift

@@ -0,0 +1,98 @@
+import SemanticVersions
+import SymbolGraphs
+
+extension SSGC.Toolchain
+{
+    @frozen public
+    struct Splash
+    {
+        public
+        let commit:SymbolGraphMetadata.Commit?
+        public
+        let triple:Triple
+        public
+        let swift:SwiftVersion
+
+        private
+        init(commit:SymbolGraphMetadata.Commit?,
+            triple:Triple,
+            swift:SwiftVersion)
+        {
+            self.commit = commit
+            self.triple = triple
+            self.swift = swift
+        }
+    }
+}
+extension SSGC.Toolchain.Splash
+{
+    public
+    init(parsing splash:String) throws
+    {
+        //  Splash should consist of two complete lines and a final newline. If the final
+        //  newline isn’t present, the output was clipped.
+        let lines:[Substring] = splash.split(separator: "\n", omittingEmptySubsequences: false)
+        guard lines.count == 3
+        else
+        {
+            throw SSGC.ToolchainError.malformedSplash
+        }
+
+        let toolchain:[Substring] = lines[0].split(separator: " ")
+        let triple:[Substring] = lines[1].split(separator: " ")
+
+        guard
+            triple.count == 2,
+            triple[0] == "Target:",
+        let triple:Triple = .init(triple[1])
+        else
+        {
+            throw SSGC.ToolchainError.malformedSplash
+        }
+
+        var k:Int = toolchain.endIndex
+        for (i, j):(Int, Int) in zip(toolchain.indices, toolchain.indices.dropFirst())
+        {
+            if  toolchain[i ... j] == ["Swift", "version"]
+            {
+                k = toolchain.index(after: j)
+                break
+            }
+        }
+        if  k == toolchain.endIndex
+        {
+            throw SSGC.ToolchainError.malformedSplash
+        }
+
+        let id:SwiftVersion
+        if  let version:NumericVersion = .init(toolchain[k])
+        {
+            id = .init(version: PatchVersion.init(padding: version))
+        }
+
+        else if
+            let version:MinorVersion = .init(toolchain[k].prefix { $0 != "-" })
+        {
+            id = .init(
+                version: .v(version.components.major, version.components.minor, 0),
+                nightly: .DEVELOPMENT_SNAPSHOT)
+        }
+        else
+        {
+            throw SSGC.ToolchainError.malformedSwiftVersion
+        }
+
+        let commit:SymbolGraphMetadata.Commit?
+        if  case nil = id.nightly,
+            let word:Substring = toolchain[toolchain.index(after: k)...].first
+        {
+            commit = .parenthesizedSwiftRelease(word)
+        }
+        else
+        {
+            commit = nil
+        }
+
+        self.init(commit: commit, triple: triple, swift: id)
+    }
+}