Макросы в Swift

struct User: Codable {
	let name: String
	let registrationDate: Date
	let friendsIds: [String]
}

updates = [
	"name": "Nikita"
	"registrationDate": FieldValue.serverTimestamp(),
	"friendsIds": FieldValue.arrayUnion(["1", "2", "3"])
]

struct User: Codable {
	var name: String?
	var registrationDate: FieldValue?
	var friendsIds: FieldValue?
}

@attached(member, names: named(Editable))
public macro FirebaseEditable() = #externalMacro(module: "PumpkinMacrosStorage", type: "FirebaseEditableMacro")

...

public struct FirebaseEditableMacro: MemberMacro {

	public static func expansion(
		of node: AttributeSyntax,
		providingMembersOf declaration: some DeclGroupSyntax,
		in context: some MacroExpansionContext
	) throws -> [DeclSyntax] {

		guard declaration.is(StructDeclSyntax.self) else {
			
			// Выводим ошибку в XCode средствами Diagnostic
			let errorDiagnose = Diagnostic(
				node: Syntax(node),
				message: MistakeDiagnostic.notAStruct
			)

			context.diagnose(errorDiagnose)

			return []
		}

		//  Получаем список пропертей
		let variables = declaration.memberBlock.members.compactMap {
			$0.decl.as(VariableDeclSyntax.self)
		}

		// Создаем определение структуры
		let editableStructure = try StructDeclSyntax("struct Editable: Codable") {
		
			// Заполняем ее пропертями
			for variable in variables {
				variable.byReplacingTypeToFieldValue
			}
		}

		return [
			DeclSyntax(editableStructure)
		]
	}
}

// MARK: - FirebaseEditableMacro

private extension FirebaseEditableMacro {

	enum MistakeDiagnostic: String {
		case notAStruct
	}
}

// MARK: - Diagnostic.DiagnosticMessage

extension FirebaseEditableMacro.MistakeDiagnostic: DiagnosticMessage {

	var message: String {
		switch self {
		case .notAStruct:
			return  "'@FirebaseEditable' can only be applied to a 'struct'"
		}
	}

	var diagnosticID: MessageID {
		.init(domain: "PumpkinMacros", id: rawValue)
	}

	var severity: DiagnosticSeverity {

    	switch self {
    	case .notAStruct:
    		return .error
    	}
  	}
}

// MARK: - VariableDeclSyntax+Convenience

private extension VariableDeclSyntax {

	var byReplacingTypeToFieldValue: Self {
		var editable =  self
		let typesToReplace: Set = ["date"]
		
		// Заменяем типы typesToReplace на FieldValue
		let updatedBindings = editable.bindings.map { binding -> PatternBindingSyntax in

			var binding = binding

			guard var typeAnnotation = binding.typeAnnotation else {
				return binding
			}

			if shouldReplace(type: typeAnnotation.type, typesToReplace: typesToReplace) {
				
                typeAnnotation = .init(
					type: SimpleTypeIdentifierSyntax(name: "FieldValue")
				)
			}

			if typeAnnotation.type.is(OptionalTypeSyntax.self) == false {

				typeAnnotation = .init(
					type: OptionalTypeSyntax(
						wrappedType: typeAnnotation.type,
						questionMark: .postfixQuestionMarkToken()
					)
				)
			}

			binding.typeAnnotation = typeAnnotation

			return binding
		}

		editable.bindings = .init(updatedBindings)
		editable.bindingKeyword = "var"

		return editable
	}
	
	// MARK: - Private methods
  
	private  func  shouldReplace(type: TypeSyntax, typesToReplace: Set) ->  Bool {

		if  let simpleTypeIdentifier = type.as(SimpleTypeIdentifierSyntax.self) {
			return typesToReplace.contains(simpleTypeIdentifier.name.text.lowercased())
		
        } else  if type.is(ArrayTypeSyntax.self) {
			return true
		
        } else  if  let optionalType = type.as(OptionalTypeSyntax.self) {
			return shouldReplace(type: optionalType.wrappedType, typesToReplace: typesToReplace)
		
        } else {
			return false
		}
	}
}