feat(patch): generate correct implementation if type conforms to (#13)

Author: supersonicbyte

Package.resolved

@@ -15,7 +15,7 @@ let package = Package(
         )
     ],
     dependencies: [
-        .package(url: "https://github.com/swiftlang/swift-syntax.git", from: "601.0.1"),
+        .package(url: "https://github.com/swiftlang/swift-syntax.git", "600.0.0"..<"602.0.0"),
         .package(url: "https://github.com/pointfreeco/swift-macro-testing.git", from: "0.6.3")
     ],
     targets: [

Package.swift

@@ -139,6 +139,34 @@ struct ViewTakesClosure: View {
 In this example `ViewTakesClosure`'s closure captures the `enabled` value on callsite and since it's marked with `@EquatableIgnoredUnsafeClosure`
 it will not cause a re-render when the value of `enabled` changes. The closure will always print the initial value of `enabled` which is an incorrect behavior.
 
-## References
+## Hashable conformance
+
+If the type is marked as conforming to `Hashable` the compiler synthesized `Hashable` implementation will not be correct. That's why the `@Equatable` macro will also generate a `Hashable` implementation for the type that is aligned with the `Equatable` implementation.
+
+```swift
+import Equatable
+@Equatable
+struct User: Hashable {
+
+let id: Int
+
+@EquatableIgnored var name = ""
+}
+```
 
-This package is inspired by Cal Stephens' blog post [Understanding and Improving SwiftUI Performance](https://medium.com/airbnb-engineering/understanding-and-improving-swiftui-performance-37b77ac61896).
+Expanded:
+```swift
+extension User: Equatable {
+    nonisolated public static func == (lhs: User, rhs: User) -> Bool {
+        lhs.id == rhs.id
+    }
+}
+extension User {
+    nonisolated public func hash(into hasher: inout Hasher) {
+        hasher.combine(id)
+    }
+}
+```
+
+## References
+This package is inspired by Cal Stephen's & Miguel Jimenez's blog post [Understanding and Improving SwiftUI Performance](https://medium.com/airbnb-engineering/understanding-and-improving-swiftui-performance-37b77ac61896).

README.md

@@ -40,8 +40,34 @@
 ///         lhs.id == rhs.id && lhs.username == rhs.username
 ///     }
 /// }
+/// ```
+///
+/// If the type is marked as conforming to `Hashable` the compiler synthesized `Hashable` implementation will not be correct.
+/// That's why the `@Equatable` macro will also generate a `Hashable` implementation for the type that is aligned with the `Equatable` implementation.
+///
+/// ```swift
+/// import Equatable
+/// @Equatable
+/// struct User: Hashable {
+///     let id: Int
+///     @EquatableIgnored var name = ""
+/// }
+/// ```
 ///
-@attached(extension, conformances: Equatable, names: named(==))
+/// Expanded:
+/// ```swift
+/// extension User: Equatable {
+///     nonisolated public static func == (lhs: User, rhs: User) -> Bool {
+///         lhs.id == rhs.id
+///     }
+/// }
+/// extension User {
+///     nonisolated public func hash(into hasher: inout Hasher) {
+///         hasher.combine(id)
+///     }
+/// }
+/// ```
+@attached(extension, conformances: Equatable, Hashable, names: named(==), named(hash(into:)))
 public macro Equatable() = #externalMacro(module: "EquatableMacros", type: "EquatableMacro")
 
 /// A peer macro that marks properties to be ignored in `Equatable` conformance generation.

Sources/Equatable/Equatable.swift

@@ -121,4 +121,11 @@ struct ProfileView: View {
         }
     }
 }
+
+@Equatable
+struct User: Hashable {
+    let id: Int
+    @EquatableIgnored var name = ""
+}
+
 #endif

Sources/EquatableClient/main.swift

@@ -8,14 +8,15 @@ import SwiftSyntaxMacros
 /// A macro that automatically generates an `Equatable` conformance for structs.
 ///
 /// This macro creates a standard equality implementation by comparing all stored properties
-/// that aren't explicitly marked to be skipped with `@EquatableIgnored`. Properties with SwiftUI property wrappers
-/// (like `@State`, `@ObservedObject`, etc.)
+/// that aren't explicitly marked to be skipped with `@EquatableIgnored`.
+/// Properties with SwiftUI property wrappers (like `@State`, `@ObservedObject`, etc.)
 ///
 /// Structs with arbitary closures are not supported unless they are marked explicitly with `@EquatableIgnoredUnsafeClosure` -
 /// meaning that they are safe because they don't  influence rendering of the view's body.
 ///
 /// Usage:
 /// ```swift
+/// import Equatable
 /// import SwiftUI
 ///
 /// @Equatable
@@ -46,7 +47,33 @@ import SwiftSyntaxMacros
 ///         lhs.id == rhs.id && lhs.username == rhs.username
 ///     }
 /// }
+/// ```
+///
+/// If the type is marked as conforming to `Hashable` the compiler synthesized `Hashable` implementation will not be correct.
+/// That's why the `@Equatable` macro will also generate a `Hashable` implementation for the type that is aligned with the `Equatable` implementation.
+///
+/// ```swift
+/// import Equatable
+/// @Equatable
+/// struct User: Hashable {
+///     let id: Int
+///     @EquatableIgnored var name = ""
+/// }
+/// ```
 ///
+/// Expanded:
+/// ```swift
+/// extension User: Equatable {
+///     nonisolated public static func == (lhs: User, rhs: User) -> Bool {
+///         lhs.id == rhs.id
+///     }
+/// }
+/// extension User {
+///     nonisolated public func hash(into hasher: inout Hasher) {
+///         hasher.combine(id)
+///     }
+/// }
+/// ```
 public struct EquatableMacro: ExtensionMacro {
     private static let skippablePropertyWrappers: Set = [
         "State",
@@ -141,25 +168,28 @@ public struct EquatableMacro: ExtensionMacro {
             return []
         }
 
-        let comparisons = sortedProperties.map { property in
-            "lhs.\(property.name) == rhs.\(property.name)"
-        }.joined(separator: " && ")
-
-        let equalityImplementation = comparisons.isEmpty ? "true" : comparisons
+        guard let extensionSyntax = Self.generateEquatableExtensionSyntax(
+            sortedProperties: sortedProperties,
+            type: type
+        ) else {
+            return []
+        }
 
-        let extensionDecl: DeclSyntax = """
-        extension \(type): Equatable {
-            nonisolated public static func == (lhs: \(type), rhs: \(type)) -> Bool {
-                \(raw: equalityImplementation)
+        // Check if the type conforms to `Hashable`
+        if Self.isHashable(structDecl) {
+            // If the type conforms to `Hashable` we need to generate the `Hashable` conformance to match
+            // the properties used in `Equatable` implementation
+            guard let hashableExtensionSyntax = Self.generateHashableExtensionSyntax(
+                sortedProperties: sortedProperties,
+                type: type
+            ) else {
+                return [extensionSyntax]
             }
-        }
-        """
 
-        guard let extensionSyntax = extensionDecl.as(ExtensionDeclSyntax.self) else {
-            return []
+            return [extensionSyntax, hashableExtensionSyntax]
+        } else {
+            return [extensionSyntax]
         }
-
-        return [extensionSyntax]
     }
 
     // Skip properties with SwiftUI attributes (like @State, @Binding, etc.) or if they are marked with @EqutableIgnored
@@ -209,6 +239,13 @@ public struct EquatableMacro: ExtensionMacro {
         }
     }
 
+    private static func isHashable(_ structDecl: StructDeclSyntax) -> Bool {
+        let existingConformances = structDecl.inheritanceClause?.inheritedTypes
+            .compactMap { $0.type.as(IdentifierTypeSyntax.self)?.name.text }
+        ?? []
+        return existingConformances.contains("Hashable")
+    }
+
     private static func isMarkedWithEquatableIgnoredUnsafeClosure(_ varDecl: VariableDeclSyntax) -> Bool {
         varDecl.attributes.contains(where: { attribute in
             if let attributeName = attribute.as(AttributeSyntax.self)?.attributeName.as(IdentifierTypeSyntax.self)?.name.text {
@@ -288,7 +325,7 @@ public struct EquatableMacro: ExtensionMacro {
                     Consider marking the closure with\
                     @EquatableIgnoredUnsafeClosure if it doesn't effect the view's body output.
                     """,
-                    fixItID: .init(
+                    fixItID: MessageID(
                         domain: "",
                         id: "test"
                     )
@@ -300,104 +337,54 @@ public struct EquatableMacro: ExtensionMacro {
 
         return diagnostic
     }
-}
 
-@main
-struct EquatablePlugin: CompilerPlugin {
-    let providingMacros: [Macro.Type] = [
-        EquatableMacro.self,
-        EquatableIgnoredMacro.self,
-        EquatableIgnoredUnsafeClosureMacro.self
-    ]
-}
-
-struct SimpleFixItMessage: FixItMessage {
-    let message: String
-    let fixItID: MessageID
-}
-
-extension TypeSyntax {
-    var isSwift: Bool {
-        if self.as(IdentifierTypeSyntax.self)?.isSwift ?? false {
-            return true
-        }
-        return false
-    }
-}
+    private static func generateEquatableExtensionSyntax(
+        sortedProperties: [(name: String, type: TypeSyntax?)],
+        type: TypeSyntaxProtocol
+    ) -> ExtensionDeclSyntax? {
+        let comparisons = sortedProperties.map { property in
+            "lhs.\(property.name) == rhs.\(property.name)"
+        }.joined(separator: " && ")
 
-extension TypeSyntax {
-    var isArray: Bool {
-        if self.is(ArrayTypeSyntax.self) {
-            return true
-        }
-        if self.as(IdentifierTypeSyntax.self)?.isArray ?? false {
-            return true
-        }
-        if self.as(MemberTypeSyntax.self)?.isArray ?? false {
-            return true
-        }
-        return false
-    }
-}
+        let equalityImplementation = comparisons.isEmpty ? "true" : comparisons
 
-extension IdentifierTypeSyntax {
-    var isSwift: Bool {
-        if self.name.text == "Swift" {
-            return true
+        let extensionDecl: DeclSyntax = """
+        extension \(type): Equatable {
+            nonisolated public static func == (lhs: \(type), rhs: \(type)) -> Bool {
+                \(raw: equalityImplementation)
+            }
         }
-        return false
-    }
-}
+        """
 
-extension IdentifierTypeSyntax {
-    var isArray: Bool {
-        if self.name.text == "Array" {
-            return true
-        }
-        return false
+        return extensionDecl.as(ExtensionDeclSyntax.self)
     }
-}
 
-extension IdentifierTypeSyntax {
-    var isDictionary: Bool {
-        if self.name.text == "Dictionary" {
-            return true
+    private static func generateHashableExtensionSyntax(
+        sortedProperties: [(name: String, type: TypeSyntax?)],
+        type: TypeSyntaxProtocol
+    ) -> ExtensionDeclSyntax? {
+        let hashableImplementation = sortedProperties.map { property in
+            "hasher.combine(\(property.name))"
         }
-        return false
-    }
-}
+            .joined(separator: "\n")
 
-extension MemberTypeSyntax {
-    var isArray: Bool {
-        if self.baseType.isSwift,
-           self.name.text == "Array" {
-            return true
+        let hashableExtensionDecl: DeclSyntax = """
+        extension \(raw: type) {
+            nonisolated public func hash(into hasher: inout Hasher) {
+                \(raw: hashableImplementation)
+            }
         }
-        return false
-    }
-}
+        """
 
-extension MemberTypeSyntax {
-    var isDictionary: Bool {
-        if self.baseType.isSwift,
-           self.name.text == "Dictionary" {
-            return true
-        }
-        return false
+        return hashableExtensionDecl.as(ExtensionDeclSyntax.self)
     }
 }
 
-extension TypeSyntax {
-    var isDictionary: Bool {
-        if self.is(DictionaryTypeSyntax.self) {
-            return true
-        }
-        if self.as(IdentifierTypeSyntax.self)?.isDictionary ?? false {
-            return true
-        }
-        if self.as(MemberTypeSyntax.self)?.isDictionary ?? false {
-            return true
-        }
-        return false
-    }
+@main
+struct EquatablePlugin: CompilerPlugin {
+    let providingMacros: [Macro.Type] = [
+        EquatableMacro.self,
+        EquatableIgnoredMacro.self,
+        EquatableIgnoredUnsafeClosureMacro.self
+    ]
 }

Sources/EquatableMacros/EquatableMacro.swift

@@ -0,0 +1,24 @@
+import SwiftSyntax
+
+extension IdentifierTypeSyntax {
+    var isSwift: Bool {
+        if self.name.text == "Swift" {
+            return true
+        }
+        return false
+    }
+
+    var isArray: Bool {
+        if self.name.text == "Array" {
+            return true
+        }
+        return false
+    }
+
+    var isDictionary: Bool {
+        if self.name.text == "Dictionary" {
+            return true
+        }
+        return false
+    }
+}