Not completely sure this is a bug report or a feature request. Don't think there is a spec for this case.
Motivation
Imagine attaching a dummy @attached(member) macro Dummy() = #externalMacro(...) macro to a type. A macro does literally nothing, aka here's it's implementation:
public struct DummyMacro: MemberMacro {
public static func expansion(
of node: AttributeSyntax,
providingMembersOf declaration: some DeclGroupSyntax,
conformingTo protocols: [TypeSyntax],
in context: some MacroExpansionContext
) throws -> [DeclSyntax] {
[]
}
}
Attaching a macro messes up the ability to declare conformance to Equatable to the types where Equatable conformance cannot be synthesised automatically (like for e.g. tuples, which still cannot conform to protocols):
// This behaves as expected
struct Foo: Equatable {
var bar: (Int, Int)
static func == (lhs: Self, rhs: Self) -> Bool { lhs.bar == rhs.bar }
}
@Dummy()
struct FooToo: Equatable { // Type 'FooToo' does not conform to protocol 'Equatable'
var bar: (Int, Int)
static func == (lhs: Self, rhs: Self) -> Bool { lhs.bar == rhs.bar }
}
Of course one can declare Equatable conformance as an extension on FooToo, but this is not an ergonomic solution for my case.
Since tuples don't conform to Equatable, I'd like to synthesize an implementation, only for the cases where user declared that they desire the conformance (and presumably have proved that the inner type is Equatable as well):
@StaticArray<UInt8>(count: 4)
struct IPv4: Equatable { }
// ^ Synthesize `static func ==(lhs:, rhs:)` as a part of macro expansion
As stated above, compiler ignores any manual conformance to the Equatable inside of the struct's body.
Proposed solution
Allow manual Equatable/Comparable/Hashable conformance inside of the type's definition, when attaching macros.
Not completely sure this is a bug report or a feature request. Don't think there is a spec for this case.
Motivation
Imagine attaching a dummy
@attached(member) macro Dummy() = #externalMacro(...)
macro to a type. A macro does literally nothing, aka here's it's implementation:Attaching a macro messes up the ability to declare conformance to
Equatable
to the types whereEquatable
conformance cannot be synthesised automatically (like for e.g. tuples, which still cannot conform to protocols):Of course one can declare
Equatable
conformance as an extension onFooToo
, but this is not an ergonomic solution for my case.I am implementing a StaticArray macro, to generate C-like fixed sized array, while there are still uncertainties in fixed-size arrays being introduced to the swift language.
Since tuples don't conform to
Equatable
, I'd like to synthesize an implementation, only for the cases where user declared that they desire the conformance (and presumably have proved that the inner type isEquatable
as well):As stated above, compiler ignores any manual conformance to the
Equatable
inside of the struct's body.Proposed solution
Allow manual
Equatable
/Comparable
/Hashable
conformance inside of the type's definition, when attaching macros....or make tuples conform to
Equatable
/Comparable
/Hashable
...or make tuples to conform to any protocol
...or implement fixed-size arrays into the language, rendering my efforts of backporting the feature redundant
Alternatives considered
No response
Additional information
No response