WIP: Adopt new PIF builder in SwiftBuildSupport

Author: pmattos

Sources/SwiftBuildSupport/BuildSystem.swift

@@ -14,7 +14,7 @@ extension BuildSubset {
     var pifTargetName: String {
         switch self {
         case .product(let name, _):
-            _PackagePIFProjectBuilder.targetName(for: name)
+            PackagePIFBuilder.targetName(forProductName: name)
         case .target(let name, _):
             name
         case .allExcludingTests:

Sources/SwiftBuildSupport/PIF.swift

@@ -17,6 +17,8 @@ import PackageModel
 
 import struct TSCBasic.ByteString
 
+import enum SwiftBuild.ProjectModel
+
 /// The Project Interchange Format (PIF) is a structured representation of the
 /// project model created by clients to send to SwiftBuild.
 ///
@@ -31,35 +33,41 @@ public enum PIF {
     /// are represented by the objects which do not use a content-based signature scheme (workspaces and projects,
     /// currently).
     static let schemaVersion = 11
-
+    
     /// The type used for identifying PIF objects.
     public typealias GUID = String
-
+    
     /// The top-level PIF object.
     public struct TopLevelObject: Encodable {
         public let workspace: PIF.Workspace
-
+        
         public init(workspace: PIF.Workspace) {
             self.workspace = workspace
         }
-
+        
         public func encode(to encoder: Encoder) throws {
             var container = encoder.unkeyedContainer()
-
+            
             // Encode the workspace.
             try container.encode(workspace)
-
+            
             // Encode the projects and their targets.
             for project in workspace.projects {
                 try container.encode(project)
-
-                for target in project.targets {
-                    try container.encode(target)
+                let targets = project.underlying.targets
+                
+                for target in targets where !target.id.hasSuffix(.dynamic) {
+                    try container.encode(Target(wrapping: target))
+                }
+                
+                // Add *dynamic variants* at the end just to have a clear split from other targets.
+                for target in targets where target.id.hasSuffix(.dynamic) {
+                    try container.encode(Target(wrapping: target))
                 }
             }
         }
     }
-
+    
     /// Represents a high-level PIF object.
     ///
     /// For instance, a JSON serialized *workspace* might look like this:
@@ -82,89 +90,235 @@ public enum PIF {
         class var type: String {
             fatalError("\(self) missing implementation")
         }
-
-        let type: String?
-
+        
+        let type: String
+        
         fileprivate init() {
-            type = Swift.type(of: self).type
+            type = Self.type
         }
-
+        
         fileprivate enum CodingKeys: CodingKey {
             case type
             case signature, contents // Used by subclasses.
         }
-
+        
         public func encode(to encoder: Encoder) throws {
             var container = encoder.container(keyedBy: CodingKeys.self)
-            try container.encode(Swift.type(of: self).type, forKey: .type)
+            try container.encode(type, forKey: .type)
         }
-
+        
         required public init(from decoder: Decoder) throws {
             let container = try decoder.container(keyedBy: CodingKeys.self)
-            type = try container.decode(String.self, forKey: .type)
+            self.type = try container.decode(String.self, forKey: .type)
+            
+            guard self.type == Self.type else {
+                throw InternalError("Expected same type for high-level object: \(self.type)")
+            }
         }
     }
-
+    
     public final class Workspace: HighLevelObject {
         override class var type: String { "workspace" }
-
+        
         public let guid: GUID
         public var name: String
         public var path: AbsolutePath
         public var projects: [Project]
         var signature: String?
 
-        public init(guid: GUID,  name: String, path: AbsolutePath, projects: [Project]) {
+        public init(guid: GUID, name: String, path: AbsolutePath, projects: [ProjectModel.Project]) {
             precondition(!guid.isEmpty)
             precondition(!name.isEmpty)
-            precondition(Set(projects.map({ $0.guid })).count == projects.count)
-
+            precondition(Set(projects.map(\.id)).count == projects.count)
+            
             self.guid = guid
             self.name = name
             self.path = path
-            self.projects = projects
+            self.projects = projects.map { Project(wrapping: $0) }
             super.init()
         }
-
+        
         private enum CodingKeys: CodingKey {
-            case guid, name, path, projects, signature
+            case guid, name, path, projects
         }
-
+        
         public override func encode(to encoder: Encoder) throws {
             try super.encode(to: encoder)
+            
             var superContainer = encoder.container(keyedBy: HighLevelObject.CodingKeys.self)
             var contents = superContainer.nestedContainer(keyedBy: CodingKeys.self, forKey: .contents)
+            
             try contents.encode("\(guid)@\(schemaVersion)", forKey: .guid)
             try contents.encode(name, forKey: .name)
             try contents.encode(path, forKey: .path)
-
+            try contents.encode(projects.map(\.signature), forKey: .projects)
+            
             if encoder.userInfo.keys.contains(.encodeForSwiftBuild) {
                 guard let signature else {
-                    throw InternalError("Expected to have workspace signature when encoding for SwiftBuild")
+                    throw InternalError("Expected to have workspace *signature* when encoding for SwiftBuild")
                 }
                 try superContainer.encode(signature, forKey: .signature)
-                try contents.encode(projects.map({ $0.signature }), forKey: .projects)
-            } else {
-                try contents.encode(projects, forKey: .projects)
             }
         }
-
+        
         public required init(from decoder: Decoder) throws {
             let superContainer = try decoder.container(keyedBy: HighLevelObject.CodingKeys.self)
             let contents = try superContainer.nestedContainer(keyedBy: CodingKeys.self, forKey: .contents)
-
+            
             let guidString = try contents.decode(GUID.self, forKey: .guid)
             self.guid = String(guidString.dropLast("\(schemaVersion)".count + 1))
             self.name = try contents.decode(String.self, forKey: .name)
             self.path = try contents.decode(AbsolutePath.self, forKey: .path)
             self.projects = try contents.decode([Project].self, forKey: .projects)
+            
+            try super.init(from: decoder)
+        }
+    }
+    
+    public final class Project: HighLevelObject {
+        override class var type: String { "project" }
+        
+        public fileprivate(set) var underlying: ProjectModel.Project
+        var signature: String?
+
+        var id: ProjectModel.GUID { underlying.id }
+        
+        public init(wrapping underlying: ProjectModel.Project) {
+            precondition(!underlying.name.isEmpty)
+            precondition(!underlying.id.value.isEmpty)
+            precondition(!underlying.path.isEmpty)
+            precondition(!underlying.projectDir.isEmpty)
+            /* precondition(!underlying.developmentRegion!.isEmpty) */
+            
+            precondition(Set(underlying.targets.map(\.id)).count == underlying.targets.count)
+            precondition(Set(underlying.buildConfigs.map(\.id)).count == underlying.buildConfigs.count)
+            
+            self.underlying = underlying
+            super.init()
+        }
+        
+        public override func encode(to encoder: any Encoder) throws {
+            try super.encode(to: encoder)
+            var superContainer = encoder.container(keyedBy: HighLevelObject.CodingKeys.self)
+            try superContainer.encode(underlying, forKey: .contents)
+
+            if encoder.userInfo.keys.contains(.encodeForSwiftBuild) {
+                guard let signature else {
+                    throw InternalError("Expected to have project *signature* when encoding for SwiftBuild")
+                }
+                try superContainer.encode(signature, forKey: .signature)
+            }
+        }
+        
+        public required init(from decoder: Decoder) throws {
+            let superContainer = try decoder.container(keyedBy: HighLevelObject.CodingKeys.self)
+            self.underlying = try superContainer.decode(ProjectModel.Project.self, forKey: .contents)
+            
+            try super.init(from: decoder)
+        }
+    }
+    
+    private final class Target: HighLevelObject {
+        override class var type: String { "target" }
+        
+        public fileprivate(set) var underlying: ProjectModel.BaseTarget
+        
+        var id: ProjectModel.GUID { underlying.id }
+        
+        public init(wrapping underlying: ProjectModel.BaseTarget) {
+            precondition(!underlying.id.value.isEmpty)
+            precondition(!underlying.common.name.isEmpty)
+            
+            self.underlying = underlying
+            super.init()
+        }
+        
+        public override func encode(to encoder: any Encoder) throws {
+            try super.encode(to: encoder)
+            var superContainer = encoder.container(keyedBy: HighLevelObject.CodingKeys.self)
+            try superContainer.encode(underlying, forKey: .contents)
+
+            if encoder.userInfo.keys.contains(.encodeForSwiftBuild) {
+                guard let signature = underlying.common.signature else {
+                    throw InternalError("Expected to have target *signature* when encoding for SwiftBuild")
+                }
+                try superContainer.encode(signature, forKey: .signature)
+            }
+        }
+        
+        public required init(from decoder: Decoder) throws {
+            fatalError("Decoding not implemented")
+            /*
+            let superContainer = try decoder.container(keyedBy: HighLevelObject.CodingKeys.self)
+            self.underlying = try superContainer.decode(ProjectModel.BaseTarget.self, forKey: .contents)
+            
             try super.init(from: decoder)
+            */
+        }
+    }
+}
+
+extension CodingUserInfoKey {
+    public static let encodingPIFSignature: CodingUserInfoKey = CodingUserInfoKey(rawValue: "encodingPIFSignature")!
+
+    /// Perform the encoding for SwiftBuild consumption.
+    public static let encodeForSwiftBuild: CodingUserInfoKey = CodingUserInfoKey(rawValue: "encodeForXCBuild")!
+}
+
+// MARK: - PIF Signature Support
+
+protocol PIFSignableObject {
+    var signature: String? { get set }
+    var name: String { get }
+}
+
+extension PIF.Workspace: PIFSignableObject {}
+extension SwiftBuild.ProjectModel.Project: PIFSignableObject {
+    var signature: String? { get { "" } set { } }
+
+}
+extension SwiftBuild.ProjectModel.TargetCommon: PIFSignableObject {}
+
+extension PIF {
+    /// Add signature to workspace and its high-level subobjects.
+    static func sign(workspace: PIF.Workspace) throws {
+        let encoder = JSONEncoder.makeWithDefaults()
+
+        func signature(of obj: some Encodable) throws -> String {
+            let signatureContent = try encoder.encode(obj)
+            let signatureBytes = ByteString(signatureContent)
+            let signature = signatureBytes.sha256Checksum
+            return signature
+        }
+
+        for project in workspace.projects {
+            for targetIndex in project.underlying.targets.indices {
+                let targetSignature = try signature(of: project.underlying.targets[targetIndex])
+                project.underlying.targets[targetIndex].common.signature = targetSignature
+            }
+            project.signature = try signature(of: project)
+        }
+        workspace.signature = try signature(of: workspace)
+    }
+    
+    static func ____sign(workspace: PIF.Workspace) throws {
+        for project in workspace.projects {
+            for targetIndex in project.underlying.targets.indices {
+                let targetSignature = project.underlying.targets[targetIndex].id.value
+                project.underlying.targets[targetIndex].common.signature = targetSignature
+            }
+            project.signature = project.id.value
         }
+        workspace.signature = workspace.guid
     }
+}
 
+
+    /*
+    
     /// A PIF project, consisting of a tree of groups and file references, a list of targets, and some additional
     /// information.
-    public final class Project: HighLevelObject {
+    public final class __Project: HighLevelObject {
         override class var type: String { "project" }
 
         public let guid: GUID
@@ -1134,8 +1288,7 @@ public enum PIF {
             multipleValueSettings = try container.decodeIfPresent(OrderedDictionary<MultipleValueSetting, [String]>.self, forKey: .multipleValueSettings) ?? [:]
         }
     }
-}
-
+     
 /// Represents a filetype recognized by the Xcode build system.
 public struct SwiftBuildFileType: CaseIterable {
     public static let xcassets: SwiftBuildFileType = SwiftBuildFileType(
@@ -1258,43 +1411,11 @@ extension PIF.FileReference {
     }
 }
 
-extension CodingUserInfoKey {
-    public static let encodingPIFSignature: CodingUserInfoKey = CodingUserInfoKey(rawValue: "encodingPIFSignature")!
-
-    /// Perform the encoding for SwiftBuild consumption.
-    public static let encodeForSwiftBuild: CodingUserInfoKey = CodingUserInfoKey(rawValue: "encodeForXCBuild")!
-}
-
-private struct UntypedTarget: Decodable {
-    struct TargetContents: Decodable {
-        let type: String
-    }
-    let contents: TargetContents
-}
-
-// MARK: - PIF Signature Support
-
-protocol PIFSignableObject: AnyObject {
-    var signature: String? { get set }
-}
-extension PIF.Workspace: PIFSignableObject {}
-extension PIF.Project: PIFSignableObject {}
-extension PIF.BaseTarget: PIFSignableObject {}
+ private struct UntypedTarget: Decodable {
+     struct TargetContents: Decodable {
+         let type: String
+     }
+     let contents: TargetContents
+ }
 
-extension PIF {
-    /// Add signature to workspace and its subobjects.
-    public static func sign(_ workspace: PIF.Workspace) throws {
-        let encoder = JSONEncoder.makeWithDefaults()
-
-        func sign<T: PIFSignableObject & Encodable>(_ obj: T) throws {
-            let signatureContent = try encoder.encode(obj)
-            let bytes = ByteString(signatureContent)
-            obj.signature = bytes.sha256Checksum
-        }
-
-        let projects = workspace.projects
-        try projects.flatMap{ $0.targets }.forEach(sign)
-        try projects.forEach(sign)
-        try sign(workspace)
-    }
-}
+*/