SE-0539: Enable Macros to Grant `self` Access for Property Initializers

[vanvoorden (Rick van Voorden)]

Side Discussion about SwiftUI Example

@dohle

Concrete Example

We work on a document-based SwiftUI app. The user can open multiple documents. We propagate a representation of the open document as an Environment value. We use a SwiftData ModelContext for this example, but it could be any object needed by a view branch; for example, an object representing a repository, a file, or a database.

Environment injection is an elegant approach because it allows different branches of the view tree to work with different modelContexts. It's great if we use @Query directly in our views, but sometimes our business logic is too involved, so we move it into a ViewModel. We extract the context from the environment and inject it into the view model. Since @State will be a lazy macro in the upcoming releases, this should be easy:

@Observable
final class ViewModel {
    let modelContext: ModelContext
    
    init(modelContext: ModelContext) { ... }
}

struct MyView: View {
    @Environment(\.modelContext) var modelContext
    
    // `@State` will be a lazy macro in the '27 releases
    // However, this init expression does not work because we need `self` access.
    @State var viewModel = ViewModel(modelContext: modelContext)
    //                     ˆ ❌ cannot use instance member 'modelContext' within property initializer; property initializers run before 'self' is available
    
    var body: some View { ... }
}

So I do think this pitch proposal has some good ideas overall worth discussing. But for this specific SwiftUI example I am not sure that trying to read from Environment before computing a view component body is ever officially supported. If the assumption is this "lazy" variable is only read at the time a view component body is computed then maybe it looks safe… but still feels a little "brittle" to me.

I would offer another solution built on DynamicProperty and update which is explicitly documented to run before our view component body is computed:

@Observable
final class Storage {
  private var modelContext: ModelContext? = nil
  
  init() {
    
  }
  
  func update(modelContext: ModelContext) {
    if self.modelContext !== modelContext {
      self.modelContext = modelContext
      ...
    }
  }
}

struct ViewModel: DynamicProperty {
  @Environment(\.modelContext) private var modelContext
  
  @State private var storage = Storage()
  
  func update() {
    self.storage.update(modelContext: self.modelContext)
  }
}