Inconsistent memberwise initializer generation when property wrapper provides an initializer with no parameters

[jgongo (José)]

Rather than explaining the problem I'm going to paste a piece of code exposing it:

@propertyWrapper
struct IdentityWrapper {
    var wrappedValue: Int

    init() {
        self.wrappedValue = 0
    }

    init(wrappedValue: Int) {
        self.wrappedValue = wrappedValue
    }
}

struct Data {
    @IdentityWrapper var id: Int
}
let d1 = Data(id: IdentityWrapper(wrappedValue: 10))

struct Data2 {
    @IdentityWrapper var id: Int = 0
}
let d2 = Data2(id: 10)

As you can see in the case of Data the synthesized initializer has a parameter of the type of the property wrapper, and in the case of Data2 the sysnthesized initializer has a paratemer of the type of the wrapped value.

I've searched the forums and I've reached this Swift evolution proposal specifying when this would happen, and it clearly states that when the property wrapper has an initializer with a wrappedValue parameter, the synthesized intitializer should use the type of the wrapped value. This is not the case if you have an initializer with no parameters in the property wrapper (either explicit or synthesized). Is this a bug?

(BTW, I've found several related discussions with no clear answer, at least that I've been able to find)

Property wrapper, default values and memberwise initializer weirdness

I'm noticing a weird issue with a property wrapper where the designated initializer of a type using the property wrapper changes depending on how an optional value is initialised. For example, given the following property wrapper: @propertyWrapper struct ExampleProperty<T> { var wrappedValue: T? } And this type using it: struct SomeType { @ExampleProperty var foo: Int? = nil } The generated memberwise initializer for SomeType is init(foo: Int?). That's fine, but if I don't explicitl…

Empty propertyWrapper initializer changes memberwise initializer type

I've encountered some strange (to me) behavior in dealing with a struct that contains a wrapped property with a default initializer. A contrived main.swift example is below: protocol DefaultConstructible { init() } extension String: DefaultConstructible {} @propertyWrapper struct Wrapper<Value: DefaultConstructible> { private var value: Value public var wrappedValue: Value { return value } public init(wrappedValue: Value) { self.value = wrappedValue } //public init() { value = …

[jgongo (José)]

In fact, reading the proposal documentation, the conditions for using the property wrapper type vs the original type seem to be redundant. Unless I am missing something, there is no way to assign an initial value to a wrapped property unless the property wrapper type has an init(wrappedValue:), is there? So the decision to use the original type would be reduced to finding out if the property wrapper has that initializer.