Add FXIOS-14673 [Technical Debt] [Redux] Add CopyWithUpdates macro to more cleanly copy redux states with simple property changes (#31717)

* Add the CopyWithChangesMacro Swift package to the project hierarchy.

* Modified CopyWithChangesMacro code to suit our purposes, adding unit tests and renaming to CopyWithUpdatesMacro.

* Import the macro into Client via Project Build Settings > General > Frameworks, Libraries, and Embedded Content.

* Update swiftlint YAML to ignore all Package files instead of each Package.swift individually.

* Trivial example of cleaning up a simple Redux state (SearchEngineSelectionState) using the new copyWith macro.

* Update licenses to include CopyWithChanges acknowledgements.

Author: ih-codes

.swiftlint.yml

@@ -131,6 +131,7 @@ excluded: # paths to ignore during linting. Takes precedence over `included`.
   # Firefox specific
   - build/
   - .build/
+  - "**/.build"
   - firefox-ios/Client/Assets/Search/get_supported_locales.swift
   - firefox-ios/Client/Generated
   - firefox-ios/fastlane/
@@ -146,14 +147,10 @@ excluded: # paths to ignore during linting. Takes precedence over `included`.
   - firefox-ios/firefox-ios-tests/Tests/UITests/
   - l10n-screenshots-dd/
   - DerivedData/
-  # Package.swift files need a custom header for swift-tools-version
-  # so must be excluded due to file_header rule
-  - firefox-ios/Package.swift
-  - BrowserKit/Package.swift
+  # Package.swift files need a custom header for swift-tools-version so must be excluded due to file_header rule. Ignore at all levels.
+  - "**/Package.swift"
   - BrowserKit/Sources/Shared/Deferred/
   - BrowserKit/.build/
-  - firefox-ios/Client/ContentBlocker/ContentBlockerGenerator/Package.swift
-  - Package.swift
   - firefox-ios/Build/Intermediates.noindex/Client.build/Fennec-iphoneos/WidgetKitExtension.build/DerivedSources/IntentDefinitionGenerated/WidgetIntents/*
   # Focus specific
   - focus-ios/Blockzilla/Generated

CopyWithUpdatesMacro/CopyWithUpdates.xctestplan

@@ -0,0 +1,25 @@
+{
+  "configurations" : [
+    {
+      "id" : "40C422E3-9DA1-429B-AF8F-A94DD239F89A",
+      "name" : "Test Scheme Action",
+      "options" : {
+
+      }
+    }
+  ],
+  "defaultOptions" : {
+    "codeCoverage" : false,
+    "performanceAntipatternCheckerEnabled" : true
+  },
+  "testTargets" : [
+    {
+      "target" : {
+        "containerPath" : "container:",
+        "identifier" : "CopyWithUpdatesTests",
+        "name" : "CopyWithUpdatesTests"
+      }
+    }
+  ],
+  "version" : 1
+}

CopyWithUpdatesMacro/NOTICE

@@ -0,0 +1 @@
+Forked Jan 2026 from Antonio Pedro Marques (https://github.com/entonio/CopyWithChanges) and customized for Firefox for iOS.

CopyWithUpdatesMacro/Package.resolved

@@ -0,0 +1,41 @@
+// swift-tools-version: 6.2
+// The swift-tools-version declares the minimum version of Swift required to build this package.
+
+import PackageDescription
+import CompilerPluginSupport
+
+let package = Package(
+    name: "CopyWithUpdatesMacro",
+    platforms: [.macOS(.v10_15), .iOS(.v15), .tvOS(.v13), .watchOS(.v6), .macCatalyst(.v13)],
+    products: [
+        .library(
+            name: "CopyWithUpdates",
+            targets: ["CopyWithUpdates"]
+        ),
+        .executable(
+            name: "CopyWithUpdatesClient",
+            targets: ["CopyWithUpdatesClient"]
+        ),
+    ],
+    dependencies: [
+        .package(url: "https://github.com/apple/swift-syntax.git", from: "509.0.0"),
+    ],
+    targets: [
+        .macro(
+            name: "CopyWithUpdatesMacros",
+            dependencies: [
+                .product(name: "SwiftSyntaxMacros", package: "swift-syntax"),
+                .product(name: "SwiftCompilerPlugin", package: "swift-syntax")
+            ]
+        ),
+        .target(name: "CopyWithUpdates", dependencies: ["CopyWithUpdatesMacros"]),
+        .executableTarget(name: "CopyWithUpdatesClient", dependencies: ["CopyWithUpdates"]),
+        .testTarget(
+            name: "CopyWithUpdatesTests",
+            dependencies: [
+                "CopyWithUpdatesMacros",
+                .product(name: "SwiftSyntaxMacrosTestSupport", package: "swift-syntax"),
+            ]
+        ),
+    ]
+)

CopyWithUpdatesMacro/Package.swift

@@ -0,0 +1,92 @@
+# CopyWithUpdates
+
+Allows copying a Swift class or struct while changing arbitrary fields.
+
+## Overview
+
+The `@CopyWithUpdates` macro can be applied to a struct or a class to generate a function that takes facultative arguments, one for each of the target's fields, and returns a new instance that is a copy of the original, except for the provided arguments. It supports optionals.
+
+## Rationale
+
+Every so often, there is a need for a copy of a struct, but with differences in one or more fields. The correct way to do it is to invoke `init` with the intended values for each field, but that's unwieldy. What often happens is that the fields that have to be changed are made mutable, an assignment copy is made, and the change is made after the copy:
+
+```swift
+// original
+let s1 = LargeStruct(a: 5, b: 2, c: 3, d: 7, e: 4, f: 1, g: 6)
+
+// cumbersome copy changing b to 2
+let s2 = LargeStruct(a: s1.a, b: 2, c: s1.c, d: s1.d, e: s1.e, f: s1.f, g: s1.g)
+
+// reasonably simple copy + change, but requires that s3 AND b be mutable even if neither is changed outside this context
+var s3 = s1
+s3.b = 2
+```
+
+Making the instance mutable is a small trade-off, that can even be solved by using some variant of an initialization block. However, making the **fields** mutable just for the sake of convenient initialization can be seen as a big anti-pattern.
+
+To avoid this need to make the fields mutable, `@CopyWithUpdates` provides the boilerplate needed in the form of `func with(...)`, that handles the boilerplate of calling `init` with both the changed and the kept values:
+
+```swift
+// the solution proposed here
+let s4 = s1.copyWithUpdates(b: 2)
+
+// the same, but changing two fields
+let s5 = s1.copyWithUpdates(c: 4, g: 7)
+
+// will change f to nil (if field f is defined as Optional)
+let s6 = s1.copyWithUpdates(f: nil)
+```
+
+The complete behavior is:
+- providing a value for any field will use that value for the field;
+- providing `nil` for a field that is non-optional is the same as not including that field in the call, i.e. the value from the original struct will be used;
+- providing `nil` for an optional field will make that field `nil`;
+- providing `.some(nil)` for an optional field is the same as not including that field in the call, i.e. the value from the original struct will be used.
+
+The macro can also apply to classes. In either classes or structs, there will have to be a memberwise `init`. In structs this is automatically synthesized by the compiler unless a custom init is defined in the struct declaration. It can also be generated via Xcode's autocompletion features.
+
+## Usage
+
+Annotate the target type with the `@CopyWithUpdates` macro to generate `func with(...) -> Self`:
+
+```swift
+import CopyWithUpdates
+
+@CopyWithUpdates
+struct Report {
+    let venue: String
+    let sponsor: String?
+    let drinks: [String]
+    let complexStructure: [Date: [(String, Int)]]
+    let characters: [String]?
+    let budget: Double
+}
+```
+
+The code after expansion:
+
+```swift
+struct Report {
+    let venue: String
+    let sponsor: String?
+    let drinks: [String]
+    let complexStructure: [Date: [(String, Int)]]
+    let characters: [String]?
+    let budget: Double
+
+    public func copyWithUpdates(venue: String? = nil, sponsor: String?? = .some(nil), drinks: [String]? = nil, complexStructure: [Date: [(String, Int)]]? = nil, characters: [String]?? = .some(nil), budget: Double? = nil) -> Self {
+        Self (
+            venue: venue ?? self.venue,
+            sponsor: sponsor == .none ? nil : self.sponsor,
+            drinks: drinks ?? self.drinks,
+            complexStructure: complexStructure ?? self.complexStructure,
+            characters: characters == .none ? nil : self.characters,
+            budget: budget ?? self.budget
+        )
+    }
+}
+```
+
+## License
+
+All the files in this package are copyright of the package contributors mentioned in the [NOTICE](NOTICE) file and licensed under the [Apache 2.0 License](http://www.apache.org/licenses/LICENSE-2.0), which is permissive for business use.

CopyWithUpdatesMacro/README.md

@@ -0,0 +1,6 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/
+
+@attached(member, names: named(copyWithUpdates))
+public macro CopyWithUpdates() = #externalMacro(module: "CopyWithUpdatesMacros", type: "CopyWithUpdatesMacro")

CopyWithUpdatesMacro/Sources/CopyWithUpdates/CopyWithUpdates.swift

@@ -0,0 +1,36 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/
+
+import Foundation
+import CopyWithUpdates
+
+// This file contains a simple executable demo of the CopyWithUpdates macro.
+@CopyWithUpdates
+struct Report {
+    let venue: String
+    let sponsor: String?
+    let drinks: [String]
+    let complexStructure: [Date: [(String, Int)]]
+    let characters: [String]?
+    let budget: Double
+}
+
+let r1 = Report(
+    venue: "Grapefruit",
+    sponsor: "Oumaouma",
+    drinks: ["soda", "tea"],
+    complexStructure: [Date(): [("Blunt!", 200)]],
+    characters: [],
+    budget: 12_345_678.9
+)
+
+let r2 = r1.copyWithUpdates(
+    characters: ["Jane Doe"]
+)
+
+let r3 = r1.copyWithUpdates(
+    sponsor: nil,
+    complexStructure: [:],
+    budget: 0
+)

CopyWithUpdatesMacro/Sources/CopyWithUpdatesClient/main.swift

@@ -0,0 +1,117 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/
+
+import SwiftCompilerPlugin
+import SwiftSyntax
+import SwiftSyntaxBuilder
+import SwiftSyntaxMacros
+import SwiftDiagnostics
+
+/// Implementation of the `CopyWithUpdates` macro.
+public struct CopyWithUpdatesMacro: MemberMacro {
+    public static func expansion(
+        of attribute: AttributeSyntax,
+        providingMembersOf declaration: some DeclGroupSyntax,
+        in context: some MacroExpansionContext
+    ) throws -> [DeclSyntax] {
+        guard let members = (declaration.as(StructDeclSyntax.self)?.memberBlock.members
+                             ?? declaration.as(ClassDeclSyntax.self)?.memberBlock.members) else {
+            context.diagnose(Diagnostic(
+                node: attribute,
+                message: CopyWithUpdatesDiagnostic.unsupportedTarget
+            ))
+
+            return []
+        }
+
+        let variableDecls = members.compactMap { member -> VariableDeclSyntax? in
+            guard let variableDecl = member.decl.as(VariableDeclSyntax.self) else {
+                return nil
+            }
+
+            // Check if the 'static' modifier is present; we don't want these properties copied into the generated copyWith
+            // method.
+            let isStatic = variableDecl.modifiers.contains { modifier in
+                modifier.name.tokenKind == .keyword(.static)
+            }
+
+            return isStatic ? nil : variableDecl
+        }
+
+        let bindings = variableDecls.flatMap { $0.bindings }
+
+        // Based on the each property's name and type, construct the copyWith function arguments and internal assignments
+        var arguments: [String] = []
+        var assignments: [String] = []
+
+        for binding in bindings {
+            guard let propertyName = binding.pattern.as(IdentifierPatternSyntax.self)?.identifier.text,
+                  let propertyType = binding.typeAnnotation?.as(TypeAnnotationSyntax.self)?.type else {
+                context.diagnose(Diagnostic(
+                    node: attribute,
+                    message: CopyWithUpdatesDiagnostic.unsupportedBinding(binding)
+                ))
+
+                continue
+            }
+
+            if propertyType.is(OptionalTypeSyntax.self) {
+                /// Optionals are treated as double optionals (`??`)
+                arguments.append("\(propertyName): \(propertyType)? = .some(nil)")
+
+                /// We treat a top-level `nil` argument semantically as setting the property to `nil`, instead of passing
+                /// `.some(nil)`, which would feel odd at call sites.
+                assignments.append("\(propertyName): \(propertyName).map { $0 ?? self.\(propertyName) } ?? nil")
+            } else {
+                arguments.append("\(propertyName): \(propertyType)? = nil")
+                assignments.append("\(propertyName): \(propertyName) ?? self.\(propertyName)")
+            }
+        }
+
+        // Construct the return statement with proper syntax
+        let copyWithFunction = try FunctionDeclSyntax("public func copyWithUpdates(\(raw: arguments.joined(separator: ", "))) -> Self") {
+            return """
+                return Self(
+                \(raw: assignments.joined(separator: ",\n"))
+                )
+            """
+        }
+
+        return [
+            DeclSyntax(copyWithFunction),
+        ]
+    }
+
+    enum CopyWithUpdatesDiagnostic: DiagnosticMessage {
+        case unsupportedTarget
+        case unsupportedBinding(PatternBindingSyntax)
+
+        var severity: DiagnosticSeverity {
+            switch self {
+            case .unsupportedTarget:  .error
+            case .unsupportedBinding: .warning
+            }
+        }
+
+        var message: String {
+            switch self {
+            case .unsupportedTarget:
+                "'@CopyWithUpdates' can only be applied to a struct or a class"
+            case .unsupportedBinding(let binding):
+                "'@CopyWithUpdates' cannot copy field '\(binding)'"
+            }
+        }
+
+        var diagnosticID: MessageID {
+            MessageID(domain: "CopyWithUpdatesMacros", id: String(describing: self))
+        }
+    }
+}
+
+@main
+struct CopyWithUpdatesPlugin: CompilerPlugin {
+    let providingMacros: [Macro.Type] = [
+        CopyWithUpdatesMacro.self,
+    ]
+}