add macro for adding mutating func for struct

Author: NullIsOne

Components/Macro/.gitignore

@@ -0,0 +1,8 @@
+.DS_Store
+/.build
+/Packages
+xcuserdata/
+DerivedData/
+.swiftpm/configuration/registries.json
+.swiftpm/xcode/package.xcworkspace/contents.xcworkspacedata
+.netrc

Components/Macro/.swiftpm/xcode/package.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>IDEDidComputeMac32BitWarning</key>
+	<true/>
+</dict>
+</plist>

Components/Macro/Package.resolved

@@ -0,0 +1,56 @@
+// swift-tools-version: 5.9
+// The swift-tools-version declares the minimum version of Swift required to build this package.
+
+import PackageDescription
+import CompilerPluginSupport
+
+let package = Package(
+    name: "Macro",
+    platforms: [.macOS(.v10_15), .iOS(.v13), .tvOS(.v13), .watchOS(.v6), .macCatalyst(.v13)],
+    products: [
+        // Products define the executables and libraries a package produces, making them visible to other packages.
+        .library(
+            name: "Macro",
+            targets: ["Macro"]
+        ),
+        .executable(
+            name: "MacroClient",
+            targets: ["MacroClient"]
+        ),
+    ],
+    dependencies: [
+        // Depend on the latest Swift 5.9 prerelease of SwiftSyntax
+        .package(url: "https://github.com/apple/swift-syntax.git", from: "509.0.0-swift-5.9-DEVELOPMENT-SNAPSHOT-2023-04-25-b"),
+    ],
+    targets: [
+        // Targets are the basic building blocks of a package, defining a module or a test suite.
+        // Targets can depend on other targets in this package and products from dependencies.
+        // Macro implementation that performs the source transformation of a macro.
+        .macro(
+            name: "Macros",
+            dependencies: [
+                .product(name: "SwiftSyntaxMacros", package: "swift-syntax"),
+                .product(name: "SwiftCompilerPlugin", package: "swift-syntax")
+            ]
+        ),
+
+        // Library that exposes a macro as part of its API, which is used in client programs.
+        .target(name: "Macro",
+                dependencies: [
+                    "Macros"
+                ]
+        ),
+
+        // A client of the library, which is able to use the macro in its own code.
+        .executableTarget(name: "MacroClient", dependencies: ["Macro"]),
+
+        // A test target used to develop the macro implementation.
+        .testTarget(
+            name: "MacroTests",
+            dependencies: [
+                "Macro",
+                .product(name: "SwiftSyntaxMacrosTestSupport", package: "swift-syntax"),
+            ]
+        ),
+    ]
+)

Components/Macro/Package.swift

@@ -0,0 +1,6 @@
+// The Swift Programming Language
+// https://docs.swift.org/swift-book
+
+/// A macro which generate `mutating func` for all variables inside struct.
+@attached(member, names: named(set))
+public macro Mutable() = #externalMacro(module: "Macros", type: "MutableMacro")

Components/Macro/Sources/Macro/MutableMacroDefinition.swift

@@ -0,0 +1,37 @@
+import Macro
+
+// MARK: - Precondition
+
+@Mutable
+struct SomeStruct {
+    let id: Int = Int.random(in: Int.min...Int.max)
+    var someFlag: Bool = false
+    var someString: String = ""
+}
+
+// MARK: - Helpers
+
+extension SomeStruct {
+
+    func debugPrintAll() {
+        debugPrint(someFlag)
+        debugPrint(someString)
+    }
+
+}
+
+// MARK: - Debugging
+
+var someStruct = SomeStruct()
+
+someStruct.debugPrintAll()
+
+someStruct.set(someFlag: true)
+someStruct.set(someString: "echo")
+
+someStruct.debugPrintAll()
+
+someStruct.set(someFlag: false)
+someStruct.set(someString: "horray")
+
+someStruct.debugPrintAll()

Components/Macro/Sources/MacroClient/main.swift

@@ -0,0 +1,13 @@
+//
+//  MacroError.swift
+//
+//
+//  Created by Никита Коробейников on 16.06.2023.
+//
+
+public enum MacroError: Error {
+
+    case onlyApplicableToStruct
+    case typeAnnotationRequiredFor(variableName: String)
+
+}

Components/Macro/Sources/Macros/MacroError.swift

@@ -0,0 +1,54 @@
+import SwiftCompilerPlugin
+import SwiftSyntax
+import SwiftSyntaxBuilder
+import SwiftSyntaxMacros
+
+/// A macro which generate `mutating func` for all variables inside struct.
+public struct MutableMacro: MemberMacro {
+
+    public static func expansion<Declaration, Context>(of node: AttributeSyntax,
+                                                       providingMembersOf declaration: Declaration,
+                                                       in context: Context) throws -> [DeclSyntax]
+    where Declaration: DeclGroupSyntax,
+          Context: MacroExpansionContext {
+              guard let structDecl = declaration.as(StructDeclSyntax.self) else {
+                  throw MacroError.onlyApplicableToStruct
+              }
+
+              let variables = structDecl.memberBlock
+                  .members
+
+                  .compactMap { $0.decl.as(VariableDeclSyntax.self) }
+                  .filter { $0.bindingKeyword.text == "var" }
+
+              let functions = try variables.compactMap { variableDecl -> FunctionDeclSyntax? in
+                  guard let variableBinding = variableDecl.bindings.first,
+                        let variableType = variableBinding.typeAnnotation?.type else {
+                      throw MacroError.typeAnnotationRequiredFor(variableName: variableDecl.bindings.first?.pattern.description ?? "unknown")
+                  }
+
+                  let variableName = TokenSyntax(stringLiteral: variableBinding.pattern.description)
+
+                  let parameter = FunctionParameterSyntax(firstName: variableName, type: variableType)
+                  let parameterList = FunctionParameterListSyntax(arrayLiteral: parameter)
+                  let modifiers = ModifierListSyntax(arrayLiteral: .init(name: .keyword(.mutating)))
+                  let bodyItem = CodeBlockItemSyntax.Item.expr(.init(stringLiteral: "self.\(variableName.text)=\(variableName.text)"))
+                  let body = CodeBlockSyntax(statements: .init(arrayLiteral: .init(item: bodyItem)))
+                  return FunctionDeclSyntax(modifiers: modifiers,
+                                            identifier: .identifier("set"),
+                                            signature: .init(input: .init(parameterList: parameterList)),
+                                            body: body
+                  )
+              }
+
+              return functions.compactMap { $0.as(DeclSyntax.self) }
+    }
+
+}
+
+@main
+struct MacroPlugin: CompilerPlugin {
+    let providingMacros: [Macro.Type] = [
+        MutableMacro.self,
+    ]
+}

Components/Macro/Sources/Macros/MutableMacro.swift

@@ -0,0 +1,40 @@
+import SwiftSyntaxMacros
+import SwiftSyntaxMacrosTestSupport
+import XCTest
+import Macros
+
+let testMacros: [String: Macro.Type] = [
+    "mutable": MutableMacro.self,
+]
+
+final class MutableMacroTests: XCTestCase {
+
+    func testMutableMacro_expansion() {
+        assertMacroExpansion(
+            """
+            @Mutable
+            struct SomeStruct {
+               let id: String = ""
+               var someVar: Bool = false
+            }
+            """,
+            expandedSource: """
+            @Mutable
+            struct SomeStruct {
+                let id: String = ""
+                var someVar: Bool = false
+
+                mutating func set(someVar: Bool) {
+                    self.someVar = someVar
+                }
+            }
+            """,
+            macros: testMacros
+        )
+    }
+
+    func testMutableMacro_application() {
+        // TODO: - check that macro throwing error 
+    }
+
+}