Retain Result Builder static methods. Closes #420 (#432)

Author: ileitch

CHANGELOG.md

@@ -14,6 +14,7 @@
 - Retain parameters on protocol function members implemented by an external type.
 - Unused function parameters on unimplemented protocol function members are now retained, as the function may still be referenced from an existential type.
 - Fix incorrect redundant public accessibility on a public superclass when a subclass is used in another module.
+- Result Builder static methods are now retained.
 
 ## 2.8.2 (2021-11-06)
 

Sources/PeripheryKit/Analyzer/Analyzer.swift

@@ -46,6 +46,7 @@ public final class Analyzer {
         StringInterpolationAppendInterpolationRetainer.self,
         PropertyWrapperRetainer.self,
         OptionalProtocolMemberRetainer.self,
+        ResultBuilderRetainer.self,
 
         PlainExtensionEliminator.self,
         AncestralReferenceEliminator.self,

Sources/PeripheryKit/Analyzer/Visitors/PropertyWrapperRetainer.swift

@@ -14,7 +14,7 @@ final class PropertyWrapperRetainer: SourceGraphVisitor {
     }
 
     func visit() {
-        for decl in graph.declarations(ofKinds: [.struct, .class]) {
+        for decl in graph.declarations(ofKinds: Declaration.Kind.toplevelAttributableKind) {
             if decl.attributes.contains("propertyWrapper") {
                 decl.declarations
                     .filter { $0.kind == .varInstance && specialProperties.contains($0.name ?? "") }

Sources/PeripheryKit/Analyzer/Visitors/ResultBuilderRetainer.swift

@@ -0,0 +1,34 @@
+import Foundation
+
+/// Retains static methods used by the Result Builder language feature.
+final class ResultBuilderRetainer: SourceGraphVisitor {
+    static func make(graph: SourceGraph) -> Self {
+        return self.init(graph: graph)
+    }
+
+    private let graph: SourceGraph
+    private let resultBuilderMethods = Set<String>([
+        "buildExpression(_:)",
+        "buildOptional(_:)",
+        "buildEither(first:)",
+        "buildEither(second:)",
+        "buildArray(_:)",
+        "buildBlock(_:)"
+    ])
+
+    required init(graph: SourceGraph) {
+        self.graph = graph
+    }
+
+    func visit() {
+        for decl in graph.declarations(ofKinds: Declaration.Kind.toplevelAttributableKind) {
+            if decl.attributes.contains("resultBuilder") {
+                for childDecl in decl.declarations {
+                    if let name = childDecl.name, resultBuilderMethods.contains(name) {
+                        graph.markRetained(childDecl)
+                    }
+                }
+            }
+        }
+    }
+}

Sources/PeripheryKit/Indexer/Declaration.swift

@@ -117,6 +117,10 @@ public final class Declaration {
             rawValue.hasPrefix("function.accessor")
         }
 
+        static var toplevelAttributableKind: Set<Kind> {
+            [.class, .struct, .enum]
+        }
+
         public var displayName: String? {
             switch self {
             case .class:

Sources/PeripheryKit/Syntax/DeclarationVisitor.swift

@@ -240,15 +240,18 @@ final class DeclarationVisitor: PeripherySyntaxVisitor {
         genericWhereClause: GenericWhereClauseSyntax? = nil,
         at position: AbsolutePosition
     ) {
-        let modifierNames = modifiers?.map { $0.name.text } ?? []
+        let modifierNames = modifiers?.withoutTrivia().map { $0.name.text } ?? []
         let accessibility = modifierNames.mapFirst { Accessibility(rawValue: $0) }
-
+        let attributeNames = attributes?.withoutTrivia().compactMap {
+            AttributeSyntax($0)?.attributeName.text ?? CustomAttributeSyntax($0)?.attributeName.firstToken?.text
+        } ?? []
         let location = sourceLocationBuilder.location(at: position)
+
         results.append((
             location,
             accessibility,
             modifierNames,
-            attributes?.compactMap { AttributeSyntax($0)?.attributeName.text } ?? [],
+            attributeNames,
             CommentCommand.parseCommands(in: trivia),
             type(for: variableType),
             typeLocations(for: variableType),

Tests/Fixtures/RetentionFixtures/testRetainsExternalAssociatedTypeTypeAlias.swift

@@ -1,5 +1,5 @@
 import Foundation
-import RetentionFixturesCrossModule
+import ExternalModuleFixtures
 
 struct Fixture110: ExternalAssociatedType {
     typealias Value = Void

Tests/Fixtures/RetentionFixtures/testRetainsResultBuilderMethods.swift

@@ -0,0 +1,44 @@
+#if swift(>=5.4)
+import Foundation
+
+@resultBuilder
+class FixtureClass130 {
+    typealias Component = [Int]
+    typealias Expression = Int
+
+    static func buildExpression(_ element: Expression) -> Component {
+        [element]
+    }
+
+    static func buildOptional(_ component: Component?) -> Component {
+        guard let component = component else { return [] }
+        return component
+    }
+
+    static func buildEither(first component: Component) -> Component {
+        component
+    }
+
+    static func buildEither(second component: Component) -> Component {
+        component
+    }
+
+    static func buildArray(_ components: [Component]) -> Component {
+        Array(components.joined())
+    }
+
+    static func buildBlock(_ components: Component...) -> Component {
+        Array(components.joined())
+    }
+}
+
+public class FixtureClass130Retainer {
+    public func build() {
+        _ = buildNonPublic {}
+    }
+
+    func buildNonPublic(@FixtureClass130 _ content: () -> [Int]) -> [Int] {
+        content()
+    }
+}
+#endif

Tests/PeripheryTests/RetentionTest.swift

@@ -998,12 +998,27 @@ final class RetentionTest: SourceGraphTestCase {
         }
     }
 
+    #if swift(>=5.4)
+    func testRetainsResultBuilderMethods() {
+        analyze(retainPublic: true) {
+            assertReferenced(.class("FixtureClass130")) {
+                self.assertReferenced(.functionMethodStatic("buildExpression(_:)"))
+                self.assertReferenced(.functionMethodStatic("buildOptional(_:)"))
+                self.assertReferenced(.functionMethodStatic("buildEither(first:)"))
+                self.assertReferenced(.functionMethodStatic("buildEither(second:)"))
+                self.assertReferenced(.functionMethodStatic("buildArray(_:)"))
+                self.assertReferenced(.functionMethodStatic("buildBlock(_:)"))
+            }
+        }
+    }
+    #endif
+
     // MARK: - Unused Parameters
 
     func testRetainsParamUsedInOverriddenMethod() {
         analyze(retainPublic: true) {
             assertReferenced(.class("FixtureClass101Base")) {
-                // Not used and not overriden.
+                // Not used and not overridden.
                 self.assertReferenced(.functionMethodInstance("func1(param:)")) {
                     self.assertNotReferenced(.varParameter("param"))
                 }