Running into this bug as well.

Same, this bug is unfortunately preventing me from implementing a useful API that uses key paths. Would love to see a fix for it!

A slightly simpler example:

struct Foo {
  private var isInitialized: Bool = false

  var value: Int {
    get {
      guard isInitialized else {
        fatalError("property accessed before being initialized")
      }
      return 1
    }
    set {}
  }
}

do {
  var x = Foo()
  x[keyPath: \.value] = 0
}

This issue still happens and is also affecting an API that we were trying to build. Specifically, the getter runs an expensive operation to get the value so we want to avoid doing that unnecessarily.

struct Foo {
  var value: Int {
    get { fatalError("Should not call get") }
    set {}
  }
}

var foo = Foo()
foo[keyPath: \.value] = 0

Confusingly, this is exactly how SwiftUI environment works too. It uses key paths to set the value. I wonder if they're doing something different behind the scenes or are also having this issue as a small performance hit

Having the same problem!

@gabriellanata SwiftUI probably does not run into this problem because environment variables always have a value (the default value, if it has not been overwritten). So, they don't have to use fatalError in the getter.

I'm running into this issue as well... has anyone found a workaround?

Same issue with swift 6

struct Foo {
    
    var value: Int {
        get { fatalError("Should not call get") }
        set {  }
    }

    mutating func with<Value>(_ keyPath:  WritableKeyPath<Self, Value>, _ value: Value)  {
        self[keyPath: keyPath] = value
    }
    
}

var foo = Foo()
foo[keyPath: \.value] = 1 // work;s fine

foo.with(\.value, 2) // Error