deprecate static APIs with inefficient defaults

motivation: configuration work has pointed out that some of the static APIs (which are questionable to begin with) use inefficient defaults

changes:
* deprecate Workspace.create,  Workspace.loadRootGraph, PackageBuilder.loadRootPackage, ManifestLoader.loadRootManifest and replace them with instance methods on workspace
* add a simple constructor to workspace, that uses the host toolchain by default
* adjust call-sites, test and examples

Author: tomerd

Examples/package-info/Package.swift

@@ -1,8 +1,13 @@
-// swift-tools-version:4.2
+// swift-tools-version:5.1
+
 import PackageDescription
 
 let package = Package(
     name: "package-info",
+    platforms: [
+        .macOS(.v10_15),
+        .iOS(.v13)
+    ],
     dependencies: [
         // This just points to the SwiftPM at the root of this repository.
         .package(path: "../../"),

Examples/package-info/Sources/package-info/main.swift

@@ -6,35 +6,29 @@ import Workspace
 // PREREQUISITES
 // ============
 
-// We will need to know where the Swift compiler is.
-let swiftCompiler: AbsolutePath = {
-    let string: String
-    #if os(macOS)
-    string = try! Process.checkNonZeroExit(args: "xcrun", "--sdk", "macosx", "-f", "swiftc").spm_chomp()
-    #else
-    string = try! Process.checkNonZeroExit(args: "which", "swiftc").spm_chomp()
-    #endif
-    return AbsolutePath(string)
-}()
-
 // We need a package to work with.
-// This assumes there is one in the current working directory:
-let packagePath = localFileSystem.currentWorkingDirectory!
+// This computes the path of this package root based on the file location
+let packagePath = AbsolutePath(#file).parentDirectory.parentDirectory.parentDirectory
 
 // LOADING
 // =======
 
-// Note:
-// This simplified API has been added since 0.4.0 was released.
-// See older revisions for examples that work with 0.4.0.
-
 // There are several levels of information available.
 // Each takes longer to load than the level above it, but provides more detail.
 let diagnostics = DiagnosticsEngine()
-let identityResolver = DefaultIdentityResolver()
-let manifest = try tsc_await { ManifestLoader.loadRootManifest(at: packagePath, swiftCompiler: swiftCompiler, swiftCompilerFlags: [], identityResolver: identityResolver, on: .global(), completion: $0) }
-let loadedPackage = try tsc_await { PackageBuilder.loadRootPackage(at: packagePath, swiftCompiler: swiftCompiler, swiftCompilerFlags: [], identityResolver: identityResolver, diagnostics: diagnostics, on: .global(), completion: $0) }
-let graph = try Workspace.loadRootGraph(at: packagePath, swiftCompiler: swiftCompiler, swiftCompilerFlags: [], identityResolver: identityResolver, diagnostics: diagnostics)
+let workspace = try Workspace(forRootPackage: packagePath)
+let manifest = try tsc_await { workspace.loadRootManifest(at: packagePath, diagnostics: diagnostics, completion: $0) }
+
+let package = try tsc_await { workspace.loadRootPackage(at: packagePath, diagnostics: diagnostics, completion: $0) }
+guard !diagnostics.hasErrors else {
+    fatalError("error package manifest: \(diagnostics)")
+}
+
+let graph = try workspace.loadPackageGraph(rootPath: packagePath, diagnostics: diagnostics)
+guard !diagnostics.hasErrors else {
+    fatalError("error loading package dependencies: \(diagnostics)")
+}
+
 
 // EXAMPLES
 // ========
@@ -46,7 +40,7 @@ let targets = manifest.targets.map({ $0.name }).joined(separator: ", ")
 print("Targets:", targets)
 
 // Package
-let executables = loadedPackage.targets.filter({ $0.type == .executable }).map({ $0.name })
+let executables = package.targets.filter({ $0.type == .executable }).map({ $0.name })
 print("Executable targets:", executables)
 
 // PackageGraph

Sources/Commands/APIDigester.swift

@@ -104,7 +104,7 @@ struct APIDigesterBaselineDumper {
         try workingCopy.checkout(revision: baselineRevision)
 
         // Create the workspace for this package.
-        let workspace = Workspace.create(
+        let workspace = try Workspace(
             forRootPackage: baselinePackageRoot,
             manifestLoader: manifestLoader,
             repositoryManager: repositoryManager

Sources/PackageLoading/ManifestLoader.swift

@@ -120,6 +120,7 @@ public final class ManifestLoader: ManifestLoaderProtocol {
     ///   - diagnostics: Optional.  The diagnostics engine.
     ///   - on: The dispatch queue to perform asynchronous operations on.
     ///   - completion: The completion handler .
+    @available(*, deprecated, message: "use workspace API instead")
     public static func loadRootManifest(
         at path: AbsolutePath,
         swiftCompiler: AbsolutePath,
@@ -131,7 +132,7 @@ public final class ManifestLoader: ManifestLoaderProtocol {
         completion: @escaping (Result<Manifest, Error>) -> Void
     ) {
         do {
-            let toolchain = try ToolchainConfiguration(swiftCompiler: swiftCompiler, swiftCompilerFlags: swiftCompilerFlags)
+            let toolchain = ToolchainConfiguration(swiftCompiler: swiftCompiler, swiftCompilerFlags: swiftCompilerFlags)
             let loader = ManifestLoader(toolchain: toolchain)
             let toolsVersion = try ToolsVersionLoader().load(at: path, fileSystem: fileSystem)
             let packageLocation = fileSystem.isFile(path) ? path.parentDirectory : path

Sources/PackageLoading/PackageBuilder.swift

@@ -242,7 +242,7 @@ public final class PackageBuilder {
     /// Create the special REPL product for this package.
     private let createREPLProduct: Bool
 
-    /// The additionla file detection rules.
+    /// The additional file detection rules.
     private let additionalFileRules: [FileRuleDescription]
 
     /// Minimum deployment target of XCTest per platform.
@@ -296,6 +296,7 @@ public final class PackageBuilder {
     ///   - diagnostics: Optional.  The diagnostics engine.
     ///   - on: The dispatch queue to perform asynchronous operations on.
     ///   - completion: The completion handler .
+    @available(*, deprecated, message: "use workspace API instead")
     public static func loadRootPackage(
         at path: AbsolutePath,
         swiftCompiler: AbsolutePath,

Sources/PackageModel/ToolchainConfiguration.swift

@@ -35,35 +35,31 @@ public struct ToolchainConfiguration {
     /// XCTest Location
     public let xctestLocation: AbsolutePath?
 
+    /// Creates the set of manifest resources associated with a `swiftc` executable.
+    ///
+    /// - Parameters:
+    ///     - swiftCompiler: The absolute path of the associated `swiftc` executable.
+    ///     - swiftCompilerFlags: Extra flags to pass the Swift compiler.: Extra flags to pass the Swift compiler.
+    ///     - libDir: The path of the library resources.
+    ///     - binDir: The bin directory.
+    ///     - sdkRoot: The path to SDK root.
+    ///     - xctestLocation: XCTest Location
     public init(
         swiftCompiler: AbsolutePath,
-        swiftCompilerFlags: [String],
-        libDir: AbsolutePath,
+        swiftCompilerFlags: [String] = [],
+        libDir: AbsolutePath? = nil,
         binDir: AbsolutePath? = nil,
         sdkRoot: AbsolutePath? = nil,
         xctestLocation: AbsolutePath? = nil
     ) {
         self.swiftCompiler = swiftCompiler
         self.swiftCompilerFlags = swiftCompilerFlags
-        self.libDir = libDir
+        self.libDir = libDir ?? Self.libDir(forBinDir: swiftCompiler.parentDirectory)
         self.binDir = binDir
         self.sdkRoot = sdkRoot
         self.xctestLocation = xctestLocation
     }
 
-    /// Creates the set of manifest resources associated with a `swiftc` executable.
-    ///
-    /// - Parameters:
-    ///     - swiftCompiler: The absolute path of the associated `swiftc` executable.
-    public init(swiftCompiler: AbsolutePath, swiftCompilerFlags: [String]) throws {
-        let binDir = swiftCompiler.parentDirectory
-        self.init(
-            swiftCompiler: swiftCompiler,
-            swiftCompilerFlags: swiftCompilerFlags,
-            libDir: Self.libDir(forBinDir: binDir)
-        )
-    }
-
     public static func libDir(forBinDir binDir: AbsolutePath) -> AbsolutePath {
         return binDir.parentDirectory.appending(components: "lib", "swift", "pm")
     }

Sources/SPMTestSupport/Toolchain.swift

@@ -1,30 +1,74 @@
 /*
  This source file is part of the Swift.org open source project
 
- Copyright (c) 2021 Apple Inc. and the Swift project authors
+ Copyright (c) 2014 - 2017 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 SPMBuildCore
 import Foundation
+//import PackageLoading
 import PackageModel
 import Workspace
 import TSCBasic
 
 #if os(macOS)
-private func macOSBundleRoot() -> AbsolutePath {
+private func bundleRoot() -> AbsolutePath {
     for bundle in Bundle.allBundles where bundle.bundlePath.hasSuffix(".xctest") {
         return AbsolutePath(bundle.bundlePath).parentDirectory
     }
     fatalError()
 }
 #endif
 
-private func resolveBinDir() -> AbsolutePath {
+/*
+public class Resources: ManifestResourceProvider {
+
+    public var swiftCompiler: AbsolutePath {
+        return toolchain.manifestResources.swiftCompiler
+    }
+
+    public var libDir: AbsolutePath {
+        return toolchain.manifestResources.libDir
+    }
+
+    public var binDir: AbsolutePath? {
+        return toolchain.manifestResources.binDir
+    }
+
+    public var swiftCompilerFlags: [String] {
+        return []
+    }
+
+  #if os(macOS)
+    public var sdkPlatformFrameworksPath: AbsolutePath {
+        return Destination.sdkPlatformFrameworkPaths()!.fwk
+    }
+  #endif
+
+    public let toolchain: UserToolchain
+
+    public static let `default` = Resources()
+
+    private init() {
+        let binDir: AbsolutePath
+      #if os(macOS)
+        binDir = bundleRoot()
+      #else
+        binDir = AbsolutePath(CommandLine.arguments[0], relativeTo: localFileSystem.currentWorkingDirectory!).parentDirectory
+      #endif
+        toolchain = try! UserToolchain(destination: Destination.hostDestination(binDir))
+    }
+}
+*/
+
+private func binDir() -> AbsolutePath {
 #if os(macOS)
-    return macOSBundleRoot()
+    return bundleRoot()
 #else
     return AbsolutePath(CommandLine.arguments[0], relativeTo: localFileSystem.currentWorkingDirectory!).parentDirectory
 #endif
@@ -54,7 +98,7 @@ extension ToolchainConfiguration {
 extension UserToolchain {
     public static var `default`: Self {
         get {
-            let binDir = resolveBinDir()
+            let binDir = binDir()
             return try! .init(destination: Destination.hostDestination(binDir))
         }
     }