[SR-12202] Property wrappers initialization is somehow artificially restricted for `State`

[DevAndArtist]

Previous ID	SR-12202
Radar	rdar://problem/52280477
Original Reporter	@DevAndArtist
Type	Bug
Status	Resolved
Resolution	Done

Environment

Apple Swift version 5.1.3 (swiftlang-1100.0.282.1 clang-1100.0.33.15)

Additional Detail from JIRA

Votes	2
Component/s	Compiler
Labels	Bug, PropertyWrappers
Assignee	@DevAndArtist
Priority	Medium

md5: 8aaf5e4f262a6c145f3c7cad19fdf8c6

Issue Description:

This general property wrapper works as expected:

@propertyWrapper
struct W<T> { var wrappedValue: T }
struct S {
  @W var value: Int
  init(value: Int) {
    // this works because, what the compiler will substitute
    // the next line with `self._value = _W(wrappedValue: value)`
    self.value = value
  }
}

This one from SwiftUI doesn't for some reason:

import SwiftUI

struct V: View {
  @State var value: Int

  init(value: Int) {
    // error: 'self' used before all stored properties are initialized
    // error: Return from initializer without initializing all stored properties
    self.value = value
  }

  var body: Never {
    fatalError()
  }
}

Expected behavior is that the compiler substitute the above line like with every other property wrapper, which would be `self._value = State(wrappedValue: value)`.

[theblixguy]

Weird, looking at the generated SILGen'd output it seems like the backing property's initializer is not being called, before the setter is called.

[theblixguy]

Okay, after digging a bit, it seems like this isn't a bug. It's because the wrappedValue's setter is non-mutating (and State is a value type), and so we don't rewrite the assignment into an initialization.

It's also not tied to State, for example:

@propertyWrapper
struct Foo<T> {
  private var _value: T

  init(wrappedValue value: T) {
    _value = value
  }

  var wrappedValue: T {
    get { return _value }
    nonmutating set { fatalError("unimplemented") }
  }
}

struct Bar {
  @Foo var value: Int

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

although I suppose the diagnostics could be a bit better.

[DevAndArtist]

Isn‘t this the other way around then? How is the setter even related to this as we still need to initialize the property wrapper first and therefore substitute the whole line. The initialization isn‘t really going through the computed property.

[DevAndArtist]

I mean, this rule says nothing about the setter kind. https://forums.swift.org/t/why-does-this-property-wrapper-code-compile/31931/6

[DevAndArtist]

Okay it also seems to happen if `wrappedValue` is get-only, but this rule isn‘t about that but rather about initialization similar to like out of line initialization but from within the init context.

[beccadax]

@swift-ci create

[hborla]

This is due to an artificial limitation in the compiler's implementation of property wrappers. The workaround is to initialize the backing storage directly via _value in V.init:

  init(value: Int) {
    self._value = State(wrappedValue: value)
  }

[hborla]

This should be fixed by #35218

[hborla]

This is fixed. Could you please verify using the latest main development snapshot from https://swift.org/download/#snapshots ? Thank you!