Accessor macro executing wrong code

[stephencelis]

Description

We've implemented a macro similar to @ObservationTracked that swaps out a stored property for accessors that call down to some private storage. Much to my surprise, though, that private storage is not being called.

See attached for repro: MyMacro.zip

Reproduction

Macro plugin:

import SwiftCompilerPlugin
import SwiftSyntax
import SwiftSyntaxBuilder
import SwiftSyntaxMacros

public struct MyMacroMacro: AccessorMacro, PeerMacro {
  public static func expansion(
    of node: AttributeSyntax,
    providingAccessorsOf declaration: some DeclSyntaxProtocol,
    in context: some MacroExpansionContext
  ) throws -> [AccessorDeclSyntax] {
    guard
      let property = declaration.as(VariableDeclSyntax.self),
      let binding = property.bindings.first,
      let identifier = binding.pattern.as(IdentifierPatternSyntax.self)?.identifier.trimmed
    else {
      return []
    }
    return [
      """
      @storageRestrictions(initializes: _\(raw: identifier))
      init(initialValue) {
      _\(identifier) = initialValue
      }
      """,
      """
      get {
      _\(identifier)
      }
      """,
      """
      set {
      _\(identifier) = newValue
      }
      """,
    ]
  }

  public static func expansion(
    of node: AttributeSyntax,
    providingPeersOf declaration: some DeclSyntaxProtocol,
    in context: some MacroExpansionContext
  ) throws -> [DeclSyntax] {
    guard
      let property = declaration.as(VariableDeclSyntax.self),
      let binding = property.bindings.first,
      let identifier = binding.pattern.as(IdentifierPatternSyntax.self)?.identifier.trimmed
    else {
      return []
    }
    return [
      """
      private var _\(identifier): () -> Bool = { fatalError() }
      """
    ]
  }
}

@main
struct MyMacroPlugin: CompilerPlugin {
  let providingMacros: [Macro.Type] = [
    MyMacroMacro.self,
  ]
}

Library:

@attached(accessor, names: named(init), named(get), named(set))
@attached(peer, names: arbitrary)
public macro MyMacro() =
  #externalMacro(module: "MyMacroMacros", type: "MyMacroMacro")

Executable:

import MyMacro

struct Foo {
  @MyMacro
  var bar: () -> Bool = { false }
}

let foo = Foo()
print(foo.bar())

What the above should expand to:

Expected behavior

I expect foo.bar() to crash in the executable because @MyMacro has swapped var bar for a getter that invokes _bar, which is a member that defaults to calling fatalError().

Instead, I get false printed to the console, which shows that Swift is somehow invoking the original storage.

Environment

swift-driver version: 1.87.3 Apple Swift version 5.9.2 (swiftlang-5.9.2.2.56 clang-1500.1.0.2.5)
Target: arm64-apple-macosx14.0

Additional information

No response

[stephencelis]

@DougGregor I found this bug quite surprising.

[stephencelis]

Seems related to swiftlang/swift-syntax#2310

[stephencelis]

Is this on anyone's radar?

[stephencelis]

This is still a problem in Xcode 16 / Swift 6. /cc @hborla @rxwei

[hamishknight]

This is working as expected, the expansion in this case looks like this:

struct Foo {
  private var _bar: () -> Bool = { fatalError() }
  var bar: () -> Bool = { false } {
    @storageRestrictions(initializes: _bar)
    init(initialValue) {
      _bar = initialValue
    }
    get {
      _bar
    }
    set {
      _bar = newValue
    }
  }
}

let foo = Foo()
print(foo.bar()) // false

As stated in SE-0400, the implicit memberwise initializer for Foo only includes a parameter for bar, since it subsumes the initialization of _bar:

the memberwise initializer parameter list will include computed properties that have init accessors along with only those stored properties that have not been subsumed by an init accessor.

Furthermore, the default argument for the bar parameter of the memberwise initializer will use the initial value of bar if available:

A property with an init accessor can have an initial value [...] The synthesized memberwise initializer will use the initial value as a default argument

So _bar is initialized with { false } through the init accessor of bar. If you want to completely subsume the user-written initializer of bar you'll want to change your accessor macro to avoid adding the init accessor.