Support ToolbarContentBuilder

Author: carson-katri

Sources/LiveViewNative/Stylesheets/ViewReference.swift

@@ -182,7 +182,7 @@ struct _TextReferenceObserver: ViewModifier {
 /// <ToolbarItem template="item2" />
 /// ```
 @_documentation(visibility: public)
-struct ToolbarContentReference: @preconcurrency Decodable {
+struct ToolbarContentReference: @preconcurrency Decodable, @preconcurrency AttributeDecodable {
     let value: [String]
 
     init(from decoder: any Decoder) throws {
@@ -195,6 +195,12 @@ struct ToolbarContentReference: @preconcurrency Decodable {
         }
     }
 
+    init(from attribute: Attribute?, on element: ElementNode) throws {
+        guard let value = attribute?.value
+        else { throw AttributeDecodingError.missingAttribute(Self.self) }
+        self.value = [value]
+    }
+    
     @MainActor
     func resolve<R: RootRegistry>(on element: ElementNode, in context: LiveContext<R>) -> some ToolbarContent {
         ToolbarTreeBuilder<R>().fromNodes(
@@ -223,7 +229,7 @@ struct ToolbarContentReference: @preconcurrency Decodable {
 /// <ToolbarItem template="item2" id="item2" />
 /// ```
 @_documentation(visibility: public)
-struct CustomizableToolbarContentReference: @preconcurrency Decodable {
+struct CustomizableToolbarContentReference: @preconcurrency Decodable, @preconcurrency AttributeDecodable {
     let value: [String]
 
     init(from decoder: any Decoder) throws {
@@ -236,6 +242,12 @@ struct CustomizableToolbarContentReference: @preconcurrency Decodable {
         }
     }
 
+    init(from attribute: Attribute?, on element: ElementNode) throws {
+        guard let value = attribute?.value
+        else { throw AttributeDecodingError.missingAttribute(Self.self) }
+        self.value = [value]
+    }
+    
     @MainActor
     func resolve<R: RootRegistry>(on element: ElementNode, in context: LiveContext<R>) -> some CustomizableToolbarContent {
         CustomizableToolbarTreeBuilder<R>().fromNodes(

Sources/ModifierGenerator/StyleDefinitionGenerator/StyleDefinitionGenerator.swift

@@ -188,6 +188,14 @@ public final class StyleDefinitionGenerator: SyntaxVisitor {
             .filter(\.isPublic)
             .filter({ !denylist.contains($0.name.text) })
         {
+            // special case for `toolbar` to exclude `ViewReference` clauses.
+            if modifier.name.text == "toolbar" {
+                guard !modifier.signature.parameterClause.parameters.contains(where: {
+                    return $0.type.as(IdentifierTypeSyntax.self)?.genericArgumentClause?.arguments.first?.argument.as(IdentifierTypeSyntax.self)?.name.text == "ViewReference"
+                })
+                else { continue }
+            }
+            
             // the 2nd member is always the enum decl
             // 1st member is the body(content:) block
             let offset = modifiers[modifier.name.text]?.memberBlock.members

Sources/SwiftSyntaxExtensions/NormalizableDeclSyntax.swift

@@ -38,7 +38,7 @@ public extension NormalizableDeclSyntax {
                 ?? parameter.type.as(AttributedTypeSyntax.self)?.baseType.as(FunctionTypeSyntax.self)
                 ?? (parameter.type.as(AttributedTypeSyntax.self)?.baseType ?? parameter.type.as(OptionalTypeSyntax.self)?.wrappedType)?.as(TupleTypeSyntax.self)?.elements.first?.type.as(FunctionTypeSyntax.self)
             {
-                guard functionType.returnClause.type.isVoid || parameter.isViewBuilder
+                guard functionType.returnClause.type.isVoid || parameter.isViewBuilder || parameter.isToolbarContentBuilder
                 else { return false }
             }
 
@@ -134,6 +134,31 @@ public extension NormalizableDeclSyntax {
                             .with(\.type, TypeSyntax(IdentifierTypeSyntax(name: .identifier("ViewReference"))))
                             .makeAttributeReference()
                     }
+                    if parameter.isToolbarContentBuilder {
+                        if let returnType = parameter.type.as(FunctionTypeSyntax.self)?.returnClause.type.as(IdentifierTypeSyntax.self),
+                           let genericType  = genericWhereClause?.requirements.lazy.compactMap({ requirement -> TypeSyntax? in
+                               switch requirement.requirement {
+                               case let .conformanceRequirement(conformance):
+                                   guard conformance.leftType.as(IdentifierTypeSyntax.self)?.name.text == returnType.name.text
+                                   else { return nil }
+                                   return conformance.rightType
+                               default:
+                                   return nil
+                               }
+                           }).first,
+                           genericType.as(MemberTypeSyntax.self)?.name.text == "CustomizableToolbarContent"
+                        {
+                            return parameter
+                                .with(\.attributes, AttributeListSyntax())
+                                .with(\.type, TypeSyntax(IdentifierTypeSyntax(name: .identifier("CustomizableToolbarContentReference"))))
+                                .makeAttributeReference()
+                        } else {
+                            return parameter
+                                .with(\.attributes, AttributeListSyntax())
+                                .with(\.type, TypeSyntax(IdentifierTypeSyntax(name: .identifier("ToolbarContentReference"))))
+                                .makeAttributeReference()
+                        }
+                    }
                     if let functionType = parameter.type.as(FunctionTypeSyntax.self) {
                         // closures that return values other than `Void` are not supported.
                         // we *might* be able to support those if the closure is `async`.

Sources/SwiftSyntaxExtensions/ValueResolution.swift

@@ -29,6 +29,27 @@ public extension FunctionParameterSyntax {
         })
     }
 
+    /// Checks if this parameter is augmented with the `@ToolbarContentBuilder` result builder.
+    var isToolbarContentBuilder: Bool {
+        return attributes.contains(where: {
+            switch $0 {
+            case let .attribute(attribute):
+                if let memberType = attribute.attributeName.as(MemberTypeSyntax.self) {
+                    // @SwiftUI.ToolbarContentBuilder
+                    return memberType.baseType.as(IdentifierTypeSyntax.self)?.name.text == "SwiftUI"
+                        && memberType.name.text == "ToolbarContentBuilder"
+                } else if let type = attribute.attributeName.as(IdentifierTypeSyntax.self) {
+                    // @ToolbarContentBuilder
+                    return type.name.text == "ToolbarContentBuilder"
+                } else {
+                    return false
+                }
+            default:
+                return false
+            }
+        })
+    }
+    
     /// Wraps this parameter's type with `AttributeReference<_>`.
     func makeAttributeReference() -> Self {
         return with(\.type, TypeSyntax(
@@ -115,7 +136,8 @@ public extension FunctionParameterSyntax {
             {
                 resolvedAttribute = FunctionCallExprSyntax.resolveAttributeReference(resolvedAttribute)
             }
-            if attributeReferenceType.genericArgumentClause!.arguments.first!.argument.as(IdentifierTypeSyntax.self)?.name.text == "ViewReference" {
+            if let typeName = attributeReferenceType.genericArgumentClause!.arguments.first!.argument.as(IdentifierTypeSyntax.self)?.name.text,
+               typeName == "ViewReference" || typeName == "ToolbarContentReference" || typeName == "CustomizableToolbarContentReference" {
                 // `ViewReference` should be converted into a closure that resolves the `ViewReference`.
                 return ExprSyntax(
                     ClosureExprSyntax {