1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
|
//===----------------------------------------------------------------------===//
//
// This source file is part of the Swift open source project
//
// Copyright (c) 2023-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 the list of Swift project authors
//
//===----------------------------------------------------------------------===//
import struct Foundation.URL
private import struct Basics.AbsolutePath
private import func Basics.resolveSymlinks
private import SPMBuildCore
// FIXME: should import these module with `private` or `internal` access control
import class Build.BuildPlan
import class Build.ClangModuleBuildDescription
import class Build.SwiftModuleBuildDescription
import struct PackageGraph.ResolvedModule
import struct PackageGraph.ModulesGraph
import enum PackageGraph.BuildTriple
public typealias BuildTriple = PackageGraph.BuildTriple
public protocol BuildTarget {
var sources: [URL] { get }
/// The name of the target. It should be possible to build a target by passing this name to `swift build --target`
var name: String { get }
var buildTriple: BuildTriple { get }
/// Whether the target is part of the root package that the user opened or if it's part of a package dependency.
var isPartOfRootPackage: Bool { get }
func compileArguments(for fileURL: URL) throws -> [String]
}
private struct WrappedClangTargetBuildDescription: BuildTarget {
private let description: ClangModuleBuildDescription
let isPartOfRootPackage: Bool
init(description: ClangModuleBuildDescription, isPartOfRootPackage: Bool) {
self.description = description
self.isPartOfRootPackage = isPartOfRootPackage
}
public var sources: [URL] {
return (try? description.compilePaths().map { URL(fileURLWithPath: $0.source.pathString) }) ?? []
}
public var name: String {
return description.clangTarget.name
}
public var buildTriple: BuildTriple {
return description.target.buildTriple
}
public func compileArguments(for fileURL: URL) throws -> [String] {
let filePath = try resolveSymlinks(try AbsolutePath(validating: fileURL.path))
let commandLine = try description.emitCommandLine(for: filePath)
// First element on the command line is the compiler itself, not an argument.
return Array(commandLine.dropFirst())
}
}
private struct WrappedSwiftTargetBuildDescription: BuildTarget {
private let description: SwiftModuleBuildDescription
let isPartOfRootPackage: Bool
init(description: SwiftModuleBuildDescription, isPartOfRootPackage: Bool) {
self.description = description
self.isPartOfRootPackage = isPartOfRootPackage
}
public var name: String {
return description.target.name
}
public var buildTriple: BuildTriple {
return description.target.buildTriple
}
var sources: [URL] {
return description.sources.map { URL(fileURLWithPath: $0.pathString) }
}
func compileArguments(for fileURL: URL) throws -> [String] {
// Note: we ignore the `fileURL` here as the expectation is that we get a command line for the entire target
// in case of Swift.
let commandLine = try description.emitCommandLine(scanInvocation: false)
// First element on the command line is the compiler itself, not an argument.
return Array(commandLine.dropFirst())
}
}
public struct BuildDescription {
private let buildPlan: Build.BuildPlan
/// The inputs of the build plan so we don't need to re-compute them on every call to
/// `fileAffectsSwiftOrClangBuildSettings`.
private let inputs: [BuildPlan.Input]
// FIXME: should not use `BuildPlan` in the public interface
public init(buildPlan: Build.BuildPlan) {
self.buildPlan = buildPlan
self.inputs = buildPlan.inputs
}
// FIXME: should not use `ResolvedTarget` in the public interface
public func getBuildTarget(for target: ResolvedModule, in modulesGraph: ModulesGraph) -> BuildTarget? {
if let description = buildPlan.targetMap[target.id] {
switch description {
case .clang(let description):
return WrappedClangTargetBuildDescription(
description: description,
isPartOfRootPackage: modulesGraph.rootPackages.map(\.id).contains(description.package.id)
)
case .swift(let description):
return WrappedSwiftTargetBuildDescription(
description: description,
isPartOfRootPackage: modulesGraph.rootPackages.map(\.id).contains(description.package.id)
)
}
} else {
if target.type == .plugin, let package = self.buildPlan.graph.package(for: target) {
return PluginTargetBuildDescription(
target: target,
toolsVersion: package.manifest.toolsVersion,
isPartOfRootPackage: modulesGraph.rootPackages.map(\.id).contains(package.id)
)
}
return nil
}
}
/// Returns all targets within the module graph in topological order, starting with low-level targets (that have no
/// dependencies).
public func allTargetsInTopologicalOrder(in modulesGraph: ModulesGraph) throws -> [BuildTarget] {
try modulesGraph.allModulesInTopologicalOrder.compactMap {
getBuildTarget(for: $0, in: modulesGraph)
}
}
/// Returns `true` if the file at the given path might influence build settings for a `swiftc` or `clang` invocation
/// generated by SwiftPM.
public func fileAffectsSwiftOrClangBuildSettings(_ url: URL) -> Bool {
guard let filePath = try? AbsolutePath(validating: url.path) else {
return false
}
for input in self.inputs {
switch input {
case .directoryStructure(let path):
if path.isAncestor(of: filePath) {
return true
}
case .file(let path):
if filePath == path {
return true
}
}
}
return false
}
}
|
