Fix some warnings with ProcessEnvironmentBlock

Package.swift

@@ -351,7 +351,7 @@ let package = Package(
  /** Support for building using Xcode's build system */
  name: "XCBuildSupport",
  dependencies: ["DriverSupport", "SPMBuildCore", "PackageGraph"],
- exclude: ["CMakeLists.txt", "CODEOWNERS"]
+ exclude: ["CODEOWNERS"]
  ),
  .target(
  /** High level functionality */

Sources/Basics/CMakeLists.txt

@@ -34,6 +34,7 @@ add_library(Basics
  FileSystem/TemporaryFile.swift
  FileSystem/TSCAdapters.swift
  FileSystem/VFSOverlay.swift
+ Git.swift
  SourceControlURL.swift
  HTTPClient/HTTPClient.swift
  HTTPClient/HTTPClientConfiguration.swift

Sources/Basics/Concurrency/ConcurrencyHelpers.swift

@@ -20,7 +20,7 @@ import func TSCBasic.tsc_await
 
 public enum Concurrency {
  public static var maxOperations: Int {
- ProcessEnv.vars["SWIFTPM_MAX_CONCURRENT_OPERATIONS"].flatMap(Int.init) ?? ProcessInfo.processInfo
+ ProcessEnv.block["SWIFTPM_MAX_CONCURRENT_OPERATIONS"].flatMap(Int.init) ?? ProcessInfo.processInfo
  .activeProcessorCount
  }
 }

Sources/Basics/EnvironmentVariables.swift

@@ -11,35 +11,38 @@
 //===----------------------------------------------------------------------===//
 
 import class Foundation.ProcessInfo
+import typealias TSCBasic.ProcessEnvironmentBlock
+import struct TSCBasic.ProcessEnvironmentKey
+import enum TSCBasic.ProcessEnv
 
-public typealias EnvironmentVariables = [String: String]
+public typealias EnvironmentVariables = ProcessEnvironmentBlock
 
-extension EnvironmentVariables {
+extension ProcessEnvironmentBlock {
  public static func empty() -> EnvironmentVariables {
  [:]
  }
 
  public static func process() -> EnvironmentVariables {
- ProcessInfo.processInfo.environment
+ ProcessEnv.block
  }
 
- public mutating func prependPath(_ key: String, value: String) {
+ public mutating func prependPath(_ key: ProcessEnvironmentKey, value: String) {
  var values = value.isEmpty ? [] : [value]
  if let existing = self[key], !existing.isEmpty {
  values.append(existing)
  }
  self.setPath(key, values)
  }
 
- public mutating func appendPath(_ key: String, value: String) {
+ public mutating func appendPath(_ key: ProcessEnvironmentKey, value: String) {
  var values = value.isEmpty ? [] : [value]
  if let existing = self[key], !existing.isEmpty {
  values.insert(existing, at: 0)
  }
  self.setPath(key, values)
  }
 
- private mutating func setPath(_ key: String, _ values: [String]) {
+ private mutating func setPath(_ key: ProcessEnvironmentKey, _ values: [String]) {
  #if os(Windows)
  let delimiter = ";"
  #else
@@ -49,22 +52,17 @@ extension EnvironmentVariables {
  }
 
  /// `PATH` variable in the process's environment (`Path` under Windows).
- public var path: String? {
- #if os(Windows)
- let pathArg = "Path"
- #else
- let pathArg = "PATH"
- #endif
- return self[pathArg]
+ package var path: String? {
+ ProcessEnv.path
  }
 }
 
 // filter env variable that should not be included in a cache as they change
 // often and should not be considered in business logic
 // rdar://107029374
-extension EnvironmentVariables {
+extension ProcessEnvironmentBlock {
  // internal for testing
- static let nonCachableKeys: Set<String> = [
+ static let nonCachableKeys: Set<ProcessEnvironmentKey> = [
  "TERM",
  "TERM_PROGRAM",
  "TERM_PROGRAM_VERSION",
@@ -82,7 +80,7 @@ extension EnvironmentVariables {
  "SSH_AUTH_SOCK",
  ]
 
- public var cachable: EnvironmentVariables {
+ package var cachable: EnvironmentVariables {
  return self.filter { !Self.nonCachableKeys.contains($0.key) }
  }
 }

Sources/Basics/Git.swift

@@ -0,0 +1,65 @@
+/*
+ This source file is part of the Swift.org open source project
+
+ Copyright (c) 2014 - 2024 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 class Foundation.ProcessInfo
+import TSCBasic
+
+package enum Git {
+ /// A shell command to run for Git. Can be either a name or a path.
+ /// - Note: modification is not thread safe, designed for testing only
+ package static var tool: String = "git\(executableFileSuffix)"
+
+ /// Returns true if the git reference name is well formed.
+ package static func checkRefFormat(ref: String) -> Bool {
+ do {
+ let result = try Process.popen(args: tool, "check-ref-format", "--allow-onelevel", ref)
+ return result.exitStatus == .terminated(code: 0)
+ } catch {
+ return false
+ }
+ }
+
+ private static var _gitEnvironment = ProcessEnv.block
+
+ /// Returns the environment variables for launching the git subprocess.
+ ///
+ /// This contains the current environment with custom overrides for using
+ /// git from swift build.
+ /// - Note: modification is not thread safe, designed for testing only
+ package static var environmentBlock: ProcessEnvironmentBlock {
+ get {
+ var env = Self._gitEnvironment
+
+ // These variables are inserted into the environment when shelling out
+ // to git if not already present.
+ let underrideVariables: ProcessEnvironmentBlock = [
+ // Disable terminal prompts in git. This will make git error out and return
+ // when it needs a user/pass etc instead of hanging the terminal (SR-3981).
+ "GIT_TERMINAL_PROMPT": "0",
+
+ // The above is env variable is not enough. However, ssh_config's batch
+ // mode is made for this purpose. see: https://linux.die.net/man/5/ssh_config
+ "GIT_SSH_COMMAND": "ssh -oBatchMode=yes",
+ ]
+
+ for (key, value) in underrideVariables {
+ // Skip this key is already present in the env.
+ if env.keys.contains(key) { continue }
+
+ env[key] = value
+ }
+
+ return env
+ }
+ set {
+ Self._gitEnvironment = newValue
+ }
+ }
+}

Sources/Basics/ImportScanning.swift

@@ -26,12 +26,12 @@ public protocol ImportScanner {
  func scanImports(_ filePathToScan: AbsolutePath) async throws -> [String]
 }
 
-public struct SwiftcImportScanner: ImportScanner {
+package struct SwiftcImportScanner: ImportScanner {
  private let swiftCompilerEnvironment: EnvironmentVariables
  private let swiftCompilerFlags: [String]
  private let swiftCompilerPath: AbsolutePath
 
- public init(
+ package init(
  swiftCompilerEnvironment: EnvironmentVariables,
  swiftCompilerFlags: [String],
  swiftCompilerPath: AbsolutePath
@@ -46,7 +46,7 @@ public struct SwiftcImportScanner: ImportScanner {
  filePathToScan.pathString,
  "-scan-dependencies", "-Xfrontend", "-import-prescan"] + self.swiftCompilerFlags
 
- let result = try await TSCBasic.Process.popen(arguments: cmd, environment: self.swiftCompilerEnvironment)
+ let result = try await TSCBasic.Process.popen(arguments: cmd, environmentBlock: self.swiftCompilerEnvironment)
 
  let stdout = try result.utf8Output()
  return try JSONDecoder.makeWithDefaults().decode(Imports.self, from: stdout).imports

Sources/Build/BuildDescription/ClangTargetBuildDescription.swift

@@ -22,17 +22,17 @@ import struct SPMBuildCore.PrebuildCommandResult
 import enum TSCBasic.ProcessEnv
 
 /// Target description for a Clang target i.e. C language family target.
-public final class ClangTargetBuildDescription {
+package final class ClangTargetBuildDescription {
  /// The target described by this target.
- public let target: ResolvedTarget
+ package let target: ResolvedTarget
 
  /// The underlying clang target.
- public let clangTarget: ClangTarget
+ package let clangTarget: ClangTarget
 
  /// The tools version of the package that declared the target. This can
  /// can be used to conditionalize semantically significant changes in how
  /// a target is built.
- public let toolsVersion: ToolsVersion
+ package let toolsVersion: ToolsVersion
 
  /// The build parameters.
  let buildParameters: BuildParameters
@@ -43,7 +43,7 @@ public final class ClangTargetBuildDescription {
  }
 
  /// The list of all resource files in the target, including the derived ones.
- public var resources: [Resource] {
+ package var resources: [Resource] {
  self.target.underlying.resources + self.pluginDerivedResources
  }
 
@@ -61,7 +61,7 @@ public final class ClangTargetBuildDescription {
  }
 
  /// The modulemap file for this target, if any.
- public private(set) var moduleMap: AbsolutePath?
+ package private(set) var moduleMap: AbsolutePath?
 
  /// Path to the temporary directory for this target.
  var tempsPath: AbsolutePath
@@ -78,13 +78,13 @@ public final class ClangTargetBuildDescription {
  private var pluginDerivedResources: [Resource]
 
  /// Path to the resource accessor header file, if generated.
- public private(set) var resourceAccessorHeaderFile: AbsolutePath?
+ package private(set) var resourceAccessorHeaderFile: AbsolutePath?
 
  /// Path to the resource Info.plist file, if generated.
- public private(set) var resourceBundleInfoPlistPath: AbsolutePath?
+ package private(set) var resourceBundleInfoPlistPath: AbsolutePath?
 
  /// The objects in this target.
- public var objects: [AbsolutePath] {
+ package var objects: [AbsolutePath] {
  get throws {
  try compilePaths().map(\.object)
  }
@@ -100,12 +100,12 @@ public final class ClangTargetBuildDescription {
  private let fileSystem: FileSystem
 
  /// If this target is a test target.
- public var isTestTarget: Bool {
+ package var isTestTarget: Bool {
  target.type == .test
  }
 
  /// The results of applying any build tool plugins to this target.
- public let buildToolPluginInvocationResults: [BuildToolPluginInvocationResult]
+ package let buildToolPluginInvocationResults: [BuildToolPluginInvocationResult]
 
  /// Create a new target description with target and build parameters.
  init(
@@ -182,7 +182,7 @@ public final class ClangTargetBuildDescription {
  }
 
  /// An array of tuples containing filename, source, object and dependency path for each of the source in this target.
- public func compilePaths()
+ package func compilePaths()
  throws -> [(filename: RelativePath, source: AbsolutePath, object: AbsolutePath, deps: AbsolutePath)]
  {
  let sources = [
@@ -206,7 +206,7 @@ public final class ClangTargetBuildDescription {
  /// NOTE: The parameter to specify whether to get C++ semantics is currently optional, but this is only for revlock
  /// avoidance with clients. Callers should always specify what they want based either the user's indication or on a
  /// default value (possibly based on the filename suffix).
- public func basicArguments(
+ package func basicArguments(
  isCXX isCXXOverride: Bool? = .none,
  isC: Bool = false
  ) throws -> [String] {
@@ -308,7 +308,7 @@ public final class ClangTargetBuildDescription {
  return args
  }
 
- public func emitCommandLine(for filePath: AbsolutePath) throws -> [String] {
+ package func emitCommandLine(for filePath: AbsolutePath) throws -> [String] {
  let standards = [
  (clangTarget.cxxLanguageStandard, SupportedLanguageExtension.cppExtensions),
  (clangTarget.cLanguageStandard, SupportedLanguageExtension.cExtensions),

Sources/Build/BuildDescription/PluginDescription.swift

@@ -21,24 +21,24 @@ import protocol Basics.FileSystem
 /// But because the package graph and build plan are not loaded for incremental
 /// builds, this information is included in the BuildDescription, and the plugin
 /// targets are compiled directly.
-public final class PluginDescription: Codable {
+package final class PluginDescription: Codable {
  /// The identity of the package in which the plugin is defined.
- public let package: PackageIdentity
+ package let package: PackageIdentity
 
  /// The name of the plugin target in that package (this is also the name of
  /// the plugin).
- public let targetName: String
+ package let targetName: String
 
  /// The names of any plugin products in that package that vend the plugin
  /// to other packages.
- public let productNames: [String]
+ package let productNames: [String]
 
  /// The tools version of the package that declared the target. This affects
  /// the API that is available in the PackagePlugin module.
- public let toolsVersion: ToolsVersion
+ package let toolsVersion: ToolsVersion
 
  /// Swift source files that comprise the plugin.
- public let sources: Sources
+ package let sources: Sources
 
  /// Initialize a new plugin target description. The target is expected to be
  /// a `PluginTarget`.

Sources/Build/BuildDescription/ProductBuildDescription.swift

@@ -21,25 +21,25 @@ import SPMBuildCore
 import struct TSCBasic.SortedArray
 
 /// The build description for a product.
-public final class ProductBuildDescription: SPMBuildCore.ProductBuildDescription {
+package final class ProductBuildDescription: SPMBuildCore.ProductBuildDescription {
  /// The reference to the product.
- public let package: ResolvedPackage
+ package let package: ResolvedPackage
 
  /// The reference to the product.
- public let product: ResolvedProduct
+ package let product: ResolvedProduct
 
  /// The tools version of the package that declared the product. This can
  /// can be used to conditionalize semantically significant changes in how
  /// a target is built.
- public let toolsVersion: ToolsVersion
+ package let toolsVersion: ToolsVersion
 
  /// The build parameters.
- public let buildParameters: BuildParameters
+ package let buildParameters: BuildParameters
 
  /// All object files to link into this product.
  ///
  // Computed during build planning.
- public internal(set) var objects = SortedArray<AbsolutePath>()
+ package internal(set) var objects = SortedArray<AbsolutePath>()
 
  /// The dynamic libraries this product needs to link with.
  // Computed during build planning.
@@ -128,7 +128,7 @@ public final class ProductBuildDescription: SPMBuildCore.ProductBuildDescription
  }
 
  /// The arguments to the librarian to create a static library.
- public func archiveArguments() throws -> [String] {
+ package func archiveArguments() throws -> [String] {
  let librarian = self.buildParameters.toolchain.librarianPath.pathString
  let triple = self.buildParameters.triple
  if triple.isWindows(), librarian.hasSuffix("link") || librarian.hasSuffix("link.exe") {
@@ -141,7 +141,7 @@ public final class ProductBuildDescription: SPMBuildCore.ProductBuildDescription
  }
 
  /// The arguments to link and create this product.
- public func linkArguments() throws -> [String] {
+ package func linkArguments() throws -> [String] {
  var args = [buildParameters.toolchain.swiftCompilerPath.pathString]
  args += self.buildParameters.sanitizers.linkSwiftFlags()
  args += self.additionalFlags
@@ -390,7 +390,7 @@ public final class ProductBuildDescription: SPMBuildCore.ProductBuildDescription
 }
 
 extension SortedArray where Element == AbsolutePath {
- public static func +=<S: Sequence>(lhs: inout SortedArray, rhs: S) where S.Iterator.Element == AbsolutePath {
+ package static func +=<S: Sequence>(lhs: inout SortedArray, rhs: S) where S.Iterator.Element == AbsolutePath {
  lhs.insert(contentsOf: rhs)
  }
 }