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
|
//===----------------------------------------------------------------------===//
//
// This source file is part of the Swift open source project
//
// Copyright (c) 2025 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
//
//===----------------------------------------------------------------------===//
public import SWBUtil
public struct BuildFile: Sendable {
// FIXME: Change this to an Int once we don't need the rawValue initializer elsewhere.
public enum HeaderVisibility: String, CaseIterable, Serializable, Sendable, Codable {
case `public`
case `private`
}
// FIXME: Change this to an Int once we don't need the rawValue initializer elsewhere.
public enum MigCodegenFiles: String, CaseIterable, Serializable, Sendable, Codable {
case client
case server
case both
}
public enum IntentsCodegenVisibility: String, CaseIterable, Serializable, Sendable, Codable {
case `public`
case `private`
case project
case noCodegen = "no_codegen"
}
public enum ResourceRule: String, CaseIterable, Serializable, Sendable, Codable {
case process
case copy
case embedInCode
}
public enum BuildableItemGUID: Sendable {
/// A file like reference type.
case reference(guid: String)
/// A target product reference type.
case targetProduct(guid: String)
/// A reference by name.
case namedReference(name: String, fileTypeIdentifier: String)
}
public let guid: String
public let buildableItemGUID: BuildableItemGUID
public let additionalArgs: MacroExpressionSource?
public let decompress: Bool
public let headerVisibility: HeaderVisibility?
public let migCodegenFiles: MigCodegenFiles?
public let intentsCodegenVisibility: IntentsCodegenVisibility
public let resourceRule: ResourceRule
public let codeSignOnCopy: Bool
public let removeHeadersOnCopy: Bool
public let shouldLinkWeakly: Bool
public let assetTags: Set<String>
public let platformFilters: Set<PlatformFilter>
public let shouldWarnIfNoRuleToProcess: Bool
public init(guid: String, buildableItemGUID: BuildableItemGUID, additionalArgs: MacroExpressionSource?, decompress: Bool = false, headerVisibility: HeaderVisibility?, migCodegenFiles: MigCodegenFiles?, intentsCodegenFiles: Bool = false, intentsCodegenVisibility: IntentsCodegenVisibility? = nil, resourceRule: ResourceRule = .process, codeSignOnCopy: Bool, removeHeadersOnCopy: Bool, shouldLinkWeakly: Bool, assetTags: Set<String> = Set() /* this default is here for revlock with PIF Generation */, platformFilters: Set<PlatformFilter> = [], shouldWarnIfNoRuleToProcess: Bool = true) {
self.guid = guid
self.buildableItemGUID = buildableItemGUID
self.additionalArgs = additionalArgs
self.decompress = decompress
self.headerVisibility = headerVisibility
self.migCodegenFiles = migCodegenFiles
if let intentsCodegenVisibility {
self.intentsCodegenVisibility = intentsCodegenVisibility
} else {
self.intentsCodegenVisibility = intentsCodegenFiles ? .public : .noCodegen
}
self.resourceRule = resourceRule
self.codeSignOnCopy = codeSignOnCopy
self.removeHeadersOnCopy = removeHeadersOnCopy
self.shouldLinkWeakly = shouldLinkWeakly
self.assetTags = assetTags
self.platformFilters = platformFilters
self.shouldWarnIfNoRuleToProcess = shouldWarnIfNoRuleToProcess
}
}
// MARK: SerializableCodable
extension BuildFile: PendingSerializableCodable {
public init(fromLegacy deserializer: any Deserializer) throws {
try deserializer.beginAggregate(14)
self.guid = try deserializer.deserialize()
self.buildableItemGUID = try deserializer.deserialize()
self.additionalArgs = try deserializer.deserialize()
self.decompress = try deserializer.deserialize()
self.headerVisibility = try deserializer.deserialize()
self.migCodegenFiles = try deserializer.deserialize()
self.intentsCodegenVisibility = try deserializer.deserialize()
self.resourceRule = try deserializer.deserialize()
self.codeSignOnCopy = try deserializer.deserialize()
self.removeHeadersOnCopy = try deserializer.deserialize()
self.shouldLinkWeakly = try deserializer.deserialize()
self.assetTags = try deserializer.deserialize()
self.platformFilters = try deserializer.deserialize()
self.shouldWarnIfNoRuleToProcess = try deserializer.deserialize()
}
public func legacySerialize<T: Serializer>(to serializer: T) {
serializer.serializeAggregate(14) {
serializer.serialize(guid)
serializer.serialize(buildableItemGUID)
serializer.serialize(additionalArgs)
serializer.serialize(decompress)
serializer.serialize(headerVisibility)
serializer.serialize(migCodegenFiles)
serializer.serialize(intentsCodegenVisibility)
serializer.serialize(resourceRule)
serializer.serialize(codeSignOnCopy)
serializer.serialize(removeHeadersOnCopy)
serializer.serialize(shouldLinkWeakly)
serializer.serialize(assetTags)
serializer.serialize(platformFilters)
serializer.serialize(shouldWarnIfNoRuleToProcess)
}
}
}
extension BuildFile.BuildableItemGUID: PendingSerializableCodable {
public init(fromLegacy deserializer: any Deserializer) throws {
try deserializer.beginAggregate(2)
switch try deserializer.deserialize() as Int {
case 0:
self = .reference(guid: try deserializer.deserialize())
case 1:
self = .targetProduct(guid: try deserializer.deserialize())
case 2:
try deserializer.beginAggregate(2)
let name: String = try deserializer.deserialize()
let fileTypeIdentifier: String = try deserializer.deserialize()
self = .namedReference(name: name, fileTypeIdentifier: fileTypeIdentifier)
case let v:
throw DeserializerError.unexpectedValue("Unexpected type code (\(v))")
}
}
public func legacySerialize<T: Serializer>(to serializer: T) {
serializer.serializeAggregate(2) {
switch self {
case .reference(let value):
serializer.serialize(0 as Int)
serializer.serialize(value)
case .targetProduct(let value):
serializer.serialize(1 as Int)
serializer.serialize(value)
case .namedReference(let name, let fileTypeIdentifier):
serializer.serialize(2 as Int)
serializer.beginAggregate(2)
serializer.serialize(name)
serializer.serialize(fileTypeIdentifier)
serializer.endAggregate()
}
}
}
}
|
