Adding support for result builders + better consolidating

Author: goergisn

ReferencePackages/UpdatedPackage/Sources/ReferencePackage/ReferencePackage.swift

@@ -57,6 +57,13 @@ public struct CustomStruct<T: Strideable>: CustomProtocol {
     public func function() -> Int { 0 }
 }
 
+// MARK: - ResultBuilder
+
+@resultBuilder
+public struct SomeResultBuilder {
+    public static func buildBlock(_ components: String) -> String { return components }
+}
+
 // MARK: - Generic public class
 
 public class CustomClass<T: Equatable> {
@@ -75,7 +82,11 @@ public class CustomClass<T: Equatable> {
     public func asyncThrowingFunc<Element>(_ element: Element) async throws where Element: Strideable {}
     public func rethrowingFunc(throwingArg: @escaping () throws -> String) rethrows {}
 
-    public init(weakObject: CustomClass? = nil, optionalVar: T? = nil) {
+    public init(
+        weakObject: CustomClass? = nil,
+        optionalVar: T? = nil,
+        @SomeResultBuilder content: () -> String
+    ) {
         self.weakObject = weakObject
         self.optionalVar = optionalVar
 
@@ -85,7 +96,9 @@ public class CustomClass<T: Equatable> {
     public init?() {}
 
     public convenience init!(value: T) {
-        self.init(optionalVar: value)
+        self.init(optionalVar: value) {
+            "SomeString"
+        }
     }
 
     public subscript(index: Int) -> T? {

Sources/PublicModules/PADSwiftInterfaceDiff/SwiftInterfaceAnalyzer/SwiftInterfaceChangeConsolidator.swift

@@ -31,22 +31,27 @@ struct SwiftInterfaceChangeConsolidator: SwiftInterfaceChangeConsolidating {
     /// This can lead to false positive matches in cases where one `removal` could potentially be matched to multiple `additions` or vice versa.
     /// e.g. a second `addition` `init(unrelated: String)` might be matched as a change of `init(foo: Int, bar: Int)`
     /// as they share the same comparison features but might not be an actual change but a genuine addition.
-    /// This is acceptable for now but might be improved in the future (e.g. calculating a matching-percentage)
+    ///
+    /// We try to prevent these false matches by first trying to find a matching the `diffableName` (e.g. function signature)
+    /// and only then trying to find a match by matching based on the `consoldiatableName` (e.g. function name)
+    ///
+    /// False positives are acceptable for now but might be improved in the future (e.g. calculating a matching-percentage)
     func consolidate(_ changes: [IndependentSwiftInterfaceChange]) -> [Change] {
 
-        var independentChanges = changes
+        // Sorting the independent changes to reduce the chance on false positives
+        // as the actually diffable signatures should now be closer together
+        var independentChanges = changes.sorted { $0.element.diffableSignature < $1.element.diffableSignature }
         var consolidatedChanges = [Change]()
 
         while !independentChanges.isEmpty {
             let change = independentChanges.removeFirst()
-
-            // Trying to find 2 independent changes that could actually have been a change instead of an addition/removal
-            guard let nameAndTypeMatchIndex = independentChanges.firstIndex(where: { $0.isConsolidatable(with: change) }) else {
+            
+            guard let matchIndex = findMatchIndex(for: change, in: independentChanges) else {
                 consolidatedChanges.append(change.toConsolidatedChange)
                 continue
             }
 
-            let match = independentChanges.remove(at: nameAndTypeMatchIndex)
+            let match = independentChanges.remove(at: matchIndex)
             let oldDescription = change.oldFirst ? change.element.description : match.element.description
             let newDescription = change.oldFirst ? match.element.description : change.element.description
             let listOfChanges = listOfChanges(between: change, and: match)
@@ -79,6 +84,24 @@ struct SwiftInterfaceChangeConsolidator: SwiftInterfaceChangeConsolidating {
             lhs.differences(to: rhs)
         }
     }
+    
+    /// Trying to find a match for an independent change
+    /// that could actually have been a change instead of an addition/removal
+    private func findMatchIndex(
+        for change: IndependentSwiftInterfaceChange,
+        in independentChanges: [IndependentSwiftInterfaceChange]
+    ) -> Int? {
+        
+        if let signatureMatchIndex = independentChanges.firstIndex(where: { $0.element.isDiffable(with: change.element) && $0.changeType.name != change.changeType.name }) {
+            return signatureMatchIndex
+        }
+        
+        if let nameAndTypeMatchIndex = independentChanges.firstIndex(where: { $0.isConsolidatable(with: change) }) {
+            return nameAndTypeMatchIndex
+        }
+        
+        return nil
+    }
 }
 
 extension IndependentSwiftInterfaceChange {

Sources/PublicModules/PADSwiftInterfaceDiff/SwiftInterfaceParser/DeclSyntax+SwiftInterface/DeclSyntax+Convenience.swift

@@ -16,6 +16,12 @@ extension SyntaxCollection {
 
 extension AttributeListSyntax {
 
+    private var translationTable: [String: String] {
+        [
+            "@_functionBuilder": "@resultBuilder"
+        ]
+    }
+    
     private var excludedAttributes: Set<String> {
         [
             "@_hasMissingDesignatedInitializers",
@@ -26,7 +32,10 @@ extension AttributeListSyntax {
     /// Produces a description where all elements in the list are mapped to their `trimmedDescription`
     var sanitizedList: [String] {
         self.compactMap {
-            let description = $0.trimmedDescription
+            var description = $0.trimmedDescription
+            if let translation = translationTable[description] {
+                description = translation
+            }
             if excludedAttributes.contains(description) { return nil }
             return description
         }

Sources/PublicModules/PADSwiftInterfaceDiff/SwiftInterfaceParser/DeclSyntax+SwiftInterface/FunctionDeclSyntax+SwiftInterface.swift

@@ -25,6 +25,7 @@ extension FunctionDeclSyntax {
 
         let parameters: [SwiftInterfaceFunction.Parameter] = self.signature.parameterClause.parameters.map {
             .init(
+                attributes: $0.attributes.sanitizedList,
                 firstName: $0.firstName.trimmedDescription,
                 secondName: $0.secondName?.trimmedDescription,
                 type: $0.type.trimmedDescription,

Sources/PublicModules/PADSwiftInterfaceDiff/SwiftInterfaceParser/DeclSyntax+SwiftInterface/InitializerDeclSyntax+SwiftInterface.swift

@@ -23,8 +23,9 @@ extension InitializerDeclSyntax {
             }
         }
 
-        let parameters: [SwiftInterfaceInitializer.Parameter] = self.signature.parameterClause.parameters.map {
+        let parameters: [SwiftInterfaceFunction.Parameter] = self.signature.parameterClause.parameters.map {
             .init(
+                attributes: $0.attributes.sanitizedList,
                 firstName: $0.firstName.trimmedDescription,
                 secondName: $0.secondName?.trimmedDescription,
                 type: $0.type.trimmedDescription,

Sources/PublicModules/PADSwiftInterfaceDiff/SwiftInterfaceParser/SwiftInterfaceElement+Declaration/SwiftInterfaceElement+Function.swift

@@ -10,6 +10,9 @@ extension SwiftInterfaceFunction {
 
     struct Parameter {
 
+        /// e.g. @discardableResult, @MainActor, @objc, @_spi(...), ...
+        let attributes: [String]
+        
         let firstName: String
 
         /// optional second "internal" name - can be ignored
@@ -20,10 +23,12 @@ extension SwiftInterfaceFunction {
         let defaultValue: String?
 
         var description: String {
-            var description = [
+            let names = [
                 firstName,
                 secondName
-            ].compactMap { $0 }.joined(separator: " ")
+            ].compactMap { $0 }
+            
+            var description = (attributes + names).joined(separator: " ")
 
             if description.isEmpty {
                 description += "\(type)"

Sources/PublicModules/PADSwiftInterfaceDiff/SwiftInterfaceParser/SwiftInterfaceElement+Declaration/SwiftInterfaceElement+Initializer.swift

@@ -6,40 +6,6 @@
 
 import Foundation
 
-extension SwiftInterfaceInitializer {
-
-    struct Parameter {
-
-        let firstName: String
-
-        /// optional second "internal" name - can be ignored
-        let secondName: String?
-
-        let type: String
-
-        let defaultValue: String?
-
-        var description: String {
-            var description = [
-                firstName,
-                secondName
-            ].compactMap { $0 }.joined(separator: " ")
-
-            if description.isEmpty {
-                description += "\(type)"
-            } else {
-                description += ": \(type)"
-            }
-
-            if let defaultValue {
-                description += " = \(defaultValue)"
-            }
-
-            return description
-        }
-    }
-}
-
 class SwiftInterfaceInitializer: SwiftInterfaceElement {
 
     /// e.g. @discardableResult, @MainActor, @objc, @_spi(...), ...
@@ -50,7 +16,7 @@ class SwiftInterfaceInitializer: SwiftInterfaceElement {
     /// e.g. <T>
     let genericParameterDescription: String?
 
-    let parameters: [Parameter]
+    let parameters: [SwiftInterfaceFunction.Parameter]
 
     /// e.g. async, throws, rethrows
     let effectSpecifiers: [String]
@@ -83,7 +49,7 @@ class SwiftInterfaceInitializer: SwiftInterfaceElement {
         modifiers: [String],
         optionalMark: String?,
         genericParameterDescription: String?,
-        parameters: [Parameter],
+        parameters: [SwiftInterfaceFunction.Parameter],
         effectSpecifiers: [String],
         genericWhereClauseDescription: String?
     ) {

Sources/PublicModules/PADSwiftInterfaceDiff/SwiftInterfaceParser/SwiftInterfaceElement/SwiftInterfaceElement.swift

@@ -111,7 +111,9 @@ extension SwiftInterfaceElement {
     /// If we used the `name` it could cause a false positive with other functions named `init` (e.g. convenience inits) when trying to find matching elements during this finding phase.
     /// In a later consolidation phase removals/additions are compared again based on their `name` to combine them to a `change`
     func isDiffable(with otherElement: any SwiftInterfaceElement) -> Bool {
-        parentPath == otherElement.parentPath && type(of: self) == type(of: otherElement) && diffableSignature == otherElement.diffableSignature
+        diffableSignature == otherElement.diffableSignature &&
+            type(of: self) == type(of: otherElement) &&
+            parentPath == otherElement.parentPath
     }
 }
 

Tests/IntegrationTests/Resources/expected-reference-changes-swift-interface-private.md

@@ -1,11 +1,17 @@
-# ⚠️ 54 public changes detected ⚠️
+# ⚠️ 56 public changes detected ⚠️
 _Comparing `new_private` to `old_private`_
-<table><tr><td>❇️</td><td><b>31 Additions</b></td></tr><tr><td>🔀</td><td><b>21 Modifications</b></td></tr><tr><td>❌</td><td><b>2 Removals</b></td></tr></table>
+<table><tr><td>❇️</td><td><b>32 Additions</b></td></tr><tr><td>🔀</td><td><b>22 Modifications</b></td></tr><tr><td>❌</td><td><b>2 Removals</b></td></tr></table>
 
 ---
 ## `ReferencePackage`
 #### ❇️ Added
 ```javascript
+@resultBuilder
+public struct SomeResultBuilder {
+  public static func buildBlock(_ components: Swift.String) -> Swift.String
+}
+```
+```javascript
 public enum RawValueEnum: Swift.Equatable, Swift.Hashable, Swift.RawRepresentable, Swift.String {
   case one
   case two
@@ -156,6 +162,25 @@ Changes:
 ```
 ```javascript
 // From
+public init(
+  weakObject: ReferencePackage.CustomClass<T>? = nil,
+  optionalVar: T? = nil
+)
+
+// To
+public init(
+  weakObject: ReferencePackage.CustomClass<T>? = nil,
+  optionalVar: T? = nil,
+  @ReferencePackage.SomeResultBuilder content: () -> Swift.String
+)
+
+/**
+Changes:
+- Added parameter `@ReferencePackage.SomeResultBuilder content: () -> Swift.String`
+*/
+```
+```javascript
+// From
 public init()
 
 // To

Tests/IntegrationTests/Resources/expected-reference-changes-swift-interface-public.md

@@ -1,11 +1,17 @@
-# ⚠️ 45 public changes detected ⚠️
+# ⚠️ 47 public changes detected ⚠️
 _Comparing `new_public` to `old_public`_
-<table><tr><td>❇️</td><td><b>28 Additions</b></td></tr><tr><td>🔀</td><td><b>15 Modifications</b></td></tr><tr><td>❌</td><td><b>2 Removals</b></td></tr></table>
+<table><tr><td>❇️</td><td><b>29 Additions</b></td></tr><tr><td>🔀</td><td><b>16 Modifications</b></td></tr><tr><td>❌</td><td><b>2 Removals</b></td></tr></table>
 
 ---
 ## `ReferencePackage`
 #### ❇️ Added
 ```javascript
+@resultBuilder
+public struct SomeResultBuilder {
+  public static func buildBlock(_ components: Swift.String) -> Swift.String
+}
+```
+```javascript
 public enum RawValueEnum: Swift.Equatable, Swift.Hashable, Swift.RawRepresentable, Swift.String {
   case one
   case two
@@ -141,6 +147,25 @@ Changes:
 ```
 ```javascript
 // From
+public init(
+  weakObject: ReferencePackage.CustomClass<T>? = nil,
+  optionalVar: T? = nil
+)
+
+// To
+public init(
+  weakObject: ReferencePackage.CustomClass<T>? = nil,
+  optionalVar: T? = nil,
+  @ReferencePackage.SomeResultBuilder content: () -> Swift.String
+)
+
+/**
+Changes:
+- Added parameter `@ReferencePackage.SomeResultBuilder content: () -> Swift.String`
+*/
+```
+```javascript
+// From
 public init()
 
 // To