@Observable macro breaks when property has attached macro with a // comment on the same line

[ZevEisenberg]

Description

The following code fails to compile:

@Observable
class BrokenViewModel {
  @MyEmptyMacro // TODO: make this the best macro ever
  var x = 1
}

Because the macro expansion adds @ObservationTracked directly after the comment, with no line break in between:

Reproduction

// ✅
@Observable
class WorkingViewModel {
  // TODO: make this the best macro ever
  @MyEmptyMacro
  var x = 1
}

// 🛑
@Observable
class BrokenViewModel {
  @MyEmptyMacro // TODO: make this the best macro ever
  var x = 1
}

You need an extra macro in the project to make it work, so here's a sample Swift package that reproduces the issue if you build it in Xcode:

BugReport.zip

Expected behavior

When expanding the macro, @ObservationTracked is added on a new line in order to preserve the comment without disabling the declaration of the underscored backing var. (Or the comment is omitted from the macro expansion, but that seems needlessly destructive.)

Environment

swift-driver version: 1.127.14.1 Apple Swift version 6.2 (swiftlang-6.2.0.19.9 clang-1700.3.19.1)
Target: arm64-apple-macosx15.0

Xcode Version 26.0 beta 7. Also reproduced with Xcode 16.4.

Additional information

See also: FB15168953: @Entry macro expansion breaks if there is a // comment after the delcaration [sic]. It was basically the same bug, and it was fixed in October 2024. If you have access to internal Apple things, maybe you can see how that was fixed.

Side note: I noticed that, in the non-broken @Observable class, where the comment is on the previous line, the comment ends up being duplicated in the macro expansion. Not a problem, per se, but I thought it was worth noting:

[ZevEisenberg]

I would be interested in fixing this if someone could point me in the right direction as to how I might go about building and running the appropriate tests on macOS.

[jamieQ]

@ZevEisenberg i'm no authority, but i tried adding the following code into test/stdlib/Observation/Observable.swift and it produced the issue you described. also i don't think it requires another macro – possibly any 'vertically stacked' keywords + comments end up breaking during the expansion?

@Observable
final class Bugz {
    @MainActor // Nice annotation you've got there
    var it = 0
}

utils/run-test --lit ../llvm-project/llvm/utils/lit/lit.py \
   ../build/Ninja-RelWithDebInfoAssert/swift-macosx-arm64/test-macosx-arm64 \
   --build=skip \
   --filter="Observable.swift"

549 | 
550 | @Observable
551 | final class Bugz {
    |             `- note: in declaration of 'Bugz'
552 |     @MainActor // Nice annotation you've got there
553 |     var it = 0
    +--- macro expansion @ObservationTracked ---------------------------
    |1 | @MainActor // Nice annotation you've got there @ObservationIgnored private  var _it  = 0
    |  |                                                                                         `- error: expected declaration
    +-------------------------------------------------------------------
554 | }
555 | 

[ZevEisenberg]

Ah, great call on using @MainActor! I was so caught up in macro-land (since I encountered this in a project where two macros were clashing) that I didn't think to use another type of annotation. And thanks for the tip on how to set up the test. I'll take a peek at what it would take to fix this.

[ZevEisenberg]

I've got things building via Terminal and I can print stuff in the macro expansions, but I'm not seeing the comment anywhere that's useful. A friend suggested that this may be a bug where one can't add a new line in a memberAttribute macro, in which case maybe this pivots to a fix for the macro system itself? I'm not sure 🤔

[ZevEisenberg]

I tried reproducing this in the swift-syntax repo on main, with a new test in MemberAttributeMacroTests.swift. It wasn't quite right (it moved the comment to the wrong line), but it didn't fail catastrophically. Is this a valid analog to the example I posted about above?

[jamieQ]

hmm yeah this is strange. i copied the source for the Observable macro into that test file and writing a unit test for the case that fails above then passes (the @ObservationTracked is on a separate line than the comment). but if you paste the example code right into the test source, then the tests fail to build for the same reason as earlier. this makes me suspect it's possibly something to do with the macro expansion plugin logic itself (no idea if it's related, but found this old PR about changing expansion to return a single string). cc @rintaro @bnbarham – do either of you have a sense of where the actual issue is here (or know who should be consulted)?

[bnbarham]

The issue here is just that the attribute being added does not have a newline added to its leading trivia. It might make sense to trim them as well, though keeping them as is with just the newline added to the new would likely result in a slightly nicer expansion (ie. it would match whatever the original variable had, which is presumably formatted as the developer expects).

For this particular issue that would be updating eg. lib/Macros/Sources/ObservationMacros/ObservableMacro.swift VariableDeclSyntax.privatePrefixed, but there might be other cases as well.

Also CC @phausler.

EDIT: And to answer some of the other questions here...

Is this a valid analog to the example I posted about above?

Not quite, the actual implementation here is a PeerMacro - it's adding a new declaration with the attributes of original, minus @ObservationTracked plus @ObservationIgnored. And as above, the issue is in the addition of @ObservationIgnored.

but if you paste the example code right into the test source, then the tests fail to build for the same reason as earlier.

Do you mean in swift tests or something else 🤔? The underlying expansion of macros in the swift-syntax unit tests isn't exactly the same as the compiler itself, but I wouldn't have expected any difference in the trivia being produced by the macro.

[jamieQ]

thanks for your insights @bnbarham! i'm still a bit confused re: the difference in behavior when trying to write a unit test to reproduce the issue.

but if you paste the example code right into the test source, then the tests fail to build for the same reason as earlier.

Do you mean in swift tests or something else 🤔?

so what i did was:

1. copy over the sources of ObservableMacro.swift, ObservationMacros/Availability.swift, and ObservationMacros/Extensions.swift
2. write a new unit test in swift-syntax tests for the failing example from above

here is a full reproduction of it (sans the expected macro expansion) if you wish to copy-paste & test it yourself:

ℹ️ Unit tests example code

import Observation

// uncomment this and build the tests: build fails

//@MainActor
//@Observable
//final class Bugz {
//  @MainActor // Nice annotation you've got there
//  var it = 0
//}

final class Tezt: XCTestCase {
  func test_obs() throws {
    assertMacroExpansion(
    """
    @MainActor
    @Observable
    final class Bugz {
        @MainActor // Nice annotation you've got there
        var it = 0
    }    
    """,
    expandedSource: """
    // copy in whatever it spits out to compare...
    """,
    macros: [
      // also tried removing some of tracked ones to see the effect
      "Observable": ObservableMacro.self,
      "ObservationTracked": ObservationTrackedMacro.self,
      "ObservationIgnored": ObservationIgnoredMacro.self,
    ],
    indentationWidth: .spaces(2)
    )
  }
}

// MARK: - ObservableMacro.swift

struct ObservableMacro {
  static let moduleName = "Observation"

  static let conformanceName = "Observable"
  static var qualifiedConformanceName: String {
    return "\(moduleName).\(conformanceName)"
  }

  static var observableConformanceType: TypeSyntax {
    "\(raw: qualifiedConformanceName)"
  }

  static let registrarTypeName = "ObservationRegistrar"
  static var qualifiedRegistrarTypeName: String {
    return "\(moduleName).\(registrarTypeName)"
  }

  static let trackedMacroName = "ObservationTracked"
  static let ignoredMacroName = "ObservationIgnored"

  static let registrarVariableName = "_$observationRegistrar"

  static func registrarVariable(_ observableType: TokenSyntax, context: some MacroExpansionContext) -> DeclSyntax {
    return
      """
      @\(raw: ignoredMacroName) private let \(raw: registrarVariableName) = \(raw: qualifiedRegistrarTypeName)()
      """
  }

  static func accessFunction(_ observableType: TokenSyntax, context: some MacroExpansionContext) -> DeclSyntax {
    let memberGeneric = context.makeUniqueName("Member")
    return
      """
      internal nonisolated func access<\(memberGeneric)>(
        keyPath: KeyPath<\(observableType), \(memberGeneric)>
      ) {
        \(raw: registrarVariableName).access(self, keyPath: keyPath)
      }
      """
  }

  static func withMutationFunction(_ observableType: TokenSyntax, context: some MacroExpansionContext) -> DeclSyntax {
    let memberGeneric = context.makeUniqueName("Member")
    let mutationGeneric = context.makeUniqueName("MutationResult")
    return
      """
      internal nonisolated func withMutation<\(memberGeneric), \(mutationGeneric)>(
        keyPath: KeyPath<\(observableType), \(memberGeneric)>,
        _ mutation: () throws -> \(mutationGeneric)
      ) rethrows -> \(mutationGeneric) {
        try \(raw: registrarVariableName).withMutation(of: self, keyPath: keyPath, mutation)
      }
      """
  }

  static func shouldNotifyObserversNonEquatableFunction(_ observableType: TokenSyntax, context: some MacroExpansionContext) -> DeclSyntax {
    let memberGeneric = context.makeUniqueName("Member")
    return
      """
       private nonisolated func shouldNotifyObservers<\(memberGeneric)>(_ lhs: \(memberGeneric), _ rhs: \(memberGeneric)) -> Bool { true }
      """
  }

  static func shouldNotifyObserversEquatableFunction(_ observableType: TokenSyntax, context: some MacroExpansionContext) -> DeclSyntax {
    let memberGeneric = context.makeUniqueName("Member")
    return
      """
      private nonisolated func shouldNotifyObservers<\(memberGeneric): Equatable>(_ lhs: \(memberGeneric), _ rhs: \(memberGeneric)) -> Bool { lhs != rhs }
      """
  }

  static func shouldNotifyObserversNonEquatableObjectFunction(_ observableType: TokenSyntax, context: some MacroExpansionContext) -> DeclSyntax {
    let memberGeneric = context.makeUniqueName("Member")
    return
      """
       private nonisolated func shouldNotifyObservers<\(memberGeneric): AnyObject>(_ lhs: \(memberGeneric), _ rhs: \(memberGeneric)) -> Bool { lhs !== rhs }
      """
  }

  static func shouldNotifyObserversEquatableObjectFunction(_ observableType: TokenSyntax, context: some MacroExpansionContext) -> DeclSyntax {
    let memberGeneric = context.makeUniqueName("Member")
    return
      """
      private nonisolated func shouldNotifyObservers<\(memberGeneric): Equatable & AnyObject>(_ lhs: \(memberGeneric), _ rhs: \(memberGeneric)) -> Bool { lhs != rhs }
      """
  }

  static var ignoredAttribute: AttributeSyntax {
    AttributeSyntax(
      leadingTrivia: .space,
      atSign: .atSignToken(),
      attributeName: IdentifierTypeSyntax(name: .identifier(ignoredMacroName)),
      trailingTrivia: .space
    )
  }

  static var trackedAttribute: AttributeSyntax {
    AttributeSyntax(
      leadingTrivia: .space,
      atSign: .atSignToken(),
      attributeName: IdentifierTypeSyntax(name: .identifier(trackedMacroName)),
      trailingTrivia: .space
    )
  }
}

struct ObservationDiagnostic: DiagnosticMessage {
  enum ID: String {
    case invalidApplication = "invalid type"
    case missingInitializer = "missing initializer"
  }

  var message: String
  var diagnosticID: MessageID
  var severity: DiagnosticSeverity

  init(message: String, diagnosticID: SwiftDiagnostics.MessageID, severity: SwiftDiagnostics.DiagnosticSeverity = .error) {
    self.message = message
    self.diagnosticID = diagnosticID
    self.severity = severity
  }

  init(message: String, domain: String, id: ID, severity: SwiftDiagnostics.DiagnosticSeverity = .error) {
    self.message = message
    self.diagnosticID = MessageID(domain: domain, id: id.rawValue)
    self.severity = severity
  }
}

extension DiagnosticsError {
  init<S: SyntaxProtocol>(syntax: S, message: String, domain: String = "Observation", id: ObservationDiagnostic.ID, severity: SwiftDiagnostics.DiagnosticSeverity = .error) {
    self.init(diagnostics: [
      Diagnostic(node: Syntax(syntax), message: ObservationDiagnostic(message: message, domain: domain, id: id, severity: severity))
    ])
  }
}


struct LocalMacroExpansionContext<Context: MacroExpansionContext> {
  var context: Context
}

extension DeclModifierListSyntax {
  func privatePrefixed(_ prefix: String, in context: LocalMacroExpansionContext<some MacroExpansionContext>) -> DeclModifierListSyntax {
    let modifier: DeclModifierSyntax = DeclModifierSyntax(name: "private", trailingTrivia: .space)
    return [modifier] + filter {
      switch $0.name.tokenKind {
      case .keyword(let keyword):
        switch keyword {
        case .fileprivate: fallthrough
        case .private: fallthrough
        case .internal: fallthrough
        case .package: fallthrough
        case .public:
          return false
        default:
          return true
        }
      default:
        return true
      }
    }
  }

  init(keyword: Keyword) {
    self.init([DeclModifierSyntax(name: .keyword(keyword))])
  }
}

extension TokenSyntax {
  func privatePrefixed(_ prefix: String, in context: LocalMacroExpansionContext<some MacroExpansionContext>) -> TokenSyntax {
    switch tokenKind {
    case .identifier(let identifier):
      return TokenSyntax(.identifier(prefix + identifier), leadingTrivia: leadingTrivia, trailingTrivia: trailingTrivia, presence: presence)
    default:
      return self
    }
  }
}

extension CodeBlockSyntax {
  func locationAnnotated(in context: LocalMacroExpansionContext<some MacroExpansionContext>) -> CodeBlockSyntax {
    guard let firstStatement = statements.first, let loc = context.context.location(of: firstStatement) else {
      return self
    }

    return CodeBlockSyntax(
      leadingTrivia: leadingTrivia,
      leftBrace: leftBrace,
      statements: CodeBlockItemListSyntax {
        "#sourceLocation(file: \(loc.file), line: \(loc.line))"
        statements
        "#sourceLocation()"
      },
      rightBrace: rightBrace,
      trailingTrivia: trailingTrivia
    )
  }
}


extension AccessorDeclSyntax {
  func locationAnnotated(in context: LocalMacroExpansionContext<some MacroExpansionContext>) -> AccessorDeclSyntax {
    return AccessorDeclSyntax(
      leadingTrivia: leadingTrivia,
      attributes: attributes,
      modifier: modifier,
      accessorSpecifier: accessorSpecifier,
      parameters: parameters,
      effectSpecifiers: effectSpecifiers,
      body: body?.locationAnnotated(in: context),
      trailingTrivia: trailingTrivia
    )
  }
}

extension AccessorBlockSyntax {
  func locationAnnotated(in context: LocalMacroExpansionContext<some MacroExpansionContext>) -> AccessorBlockSyntax {
    switch accessors {
    case .accessors(let accessorList):
      let remapped = AccessorDeclListSyntax {
        accessorList.map { $0.locationAnnotated(in: context) }
      }
      return AccessorBlockSyntax(accessors: .accessors(remapped))
    case .getter(let codeBlockList):
      return AccessorBlockSyntax(accessors: .getter(codeBlockList))
    }
  }
}

extension PatternBindingListSyntax {
  func privatePrefixed(_ prefix: String, in context: LocalMacroExpansionContext<some MacroExpansionContext>) -> PatternBindingListSyntax {
    var bindings = self.map { $0 }
    for index in 0..<bindings.count {
      let binding = bindings[index]
      if let identifier = binding.pattern.as(IdentifierPatternSyntax.self) {
        bindings[index] = PatternBindingSyntax(
          leadingTrivia: binding.leadingTrivia,
          pattern: IdentifierPatternSyntax(
            leadingTrivia: identifier.leadingTrivia,
            identifier: identifier.identifier.privatePrefixed(prefix, in: context),
            trailingTrivia: identifier.trailingTrivia
          ),
          typeAnnotation: binding.typeAnnotation,
          initializer: binding.initializer,
          accessorBlock: binding.accessorBlock?.locationAnnotated(in: context),
          trailingComma: binding.trailingComma,
          trailingTrivia: binding.trailingTrivia)

      }
    }

    return PatternBindingListSyntax(bindings)
  }
}

extension VariableDeclSyntax {
  func privatePrefixed(_ prefix: String, addingAttribute attribute: AttributeSyntax, removingAttribute toRemove: AttributeSyntax, in context: LocalMacroExpansionContext<some MacroExpansionContext>) -> VariableDeclSyntax {
    let newAttributes = attributes.filter { attribute in
      switch attribute {
      case .attribute(let attr):
        attr.attributeName.identifier != toRemove.attributeName.identifier
      default: true
      }
    } + [.attribute(attribute)]
    return VariableDeclSyntax(
      leadingTrivia: leadingTrivia,
      attributes: newAttributes,
      modifiers: modifiers.privatePrefixed(prefix, in: context),
      bindingSpecifier: TokenSyntax(bindingSpecifier.tokenKind, leadingTrivia: .space, trailingTrivia: .space, presence: .present),
      bindings: bindings.privatePrefixed(prefix, in: context),
      trailingTrivia: trailingTrivia
    )
  }

  var isValidForObservation: Bool {
    !isComputed && isInstance && !isImmutable && identifier != nil
  }
}

extension ObservableMacro: MemberMacro {
  public static func expansion<
    Declaration: DeclGroupSyntax,
    Context: MacroExpansionContext
  >(
    of node: AttributeSyntax,
    providingMembersOf declaration: Declaration,
    conformingTo protocols: [TypeSyntax],
    in context: Context
  ) throws -> [DeclSyntax] {
    guard let identified = declaration.asProtocol(NamedDeclSyntax.self) else {
      return []
    }

    let observableType = identified.name.trimmed

    if declaration.isEnum {
      // enumerations cannot store properties
      throw DiagnosticsError(syntax: node, message: "'@Observable' cannot be applied to enumeration type '\(observableType.text)'", id: .invalidApplication)
    }
    if declaration.isStruct {
      // structs are not yet supported; copying/mutation semantics tbd
      throw DiagnosticsError(syntax: node, message: "'@Observable' cannot be applied to struct type '\(observableType.text)'", id: .invalidApplication)
    }
    if declaration.isActor {
      // actors cannot yet be supported for their isolation
      throw DiagnosticsError(syntax: node, message: "'@Observable' cannot be applied to actor type '\(observableType.text)'", id: .invalidApplication)
    }

    var declarations = [DeclSyntax]()

    declaration.addIfNeeded(ObservableMacro.registrarVariable(observableType, context: context), to: &declarations)
    declaration.addIfNeeded(ObservableMacro.accessFunction(observableType, context: context), to: &declarations)
    declaration.addIfNeeded(ObservableMacro.withMutationFunction(observableType, context: context), to: &declarations)
    declaration.addIfNeeded(ObservableMacro.shouldNotifyObserversNonEquatableFunction(observableType, context: context), to: &declarations)
    declaration.addIfNeeded(ObservableMacro.shouldNotifyObserversEquatableFunction(observableType, context: context), to: &declarations)
    declaration.addIfNeeded(ObservableMacro.shouldNotifyObserversNonEquatableObjectFunction(observableType, context: context), to: &declarations)
    declaration.addIfNeeded(ObservableMacro.shouldNotifyObserversEquatableObjectFunction(observableType, context: context), to: &declarations)

    return declarations
  }
}

extension ObservableMacro: MemberAttributeMacro {
  public static func expansion<
    Declaration: DeclGroupSyntax,
    MemberDeclaration: DeclSyntaxProtocol,
    Context: MacroExpansionContext
  >(
    of node: AttributeSyntax,
    attachedTo declaration: Declaration,
    providingAttributesFor member: MemberDeclaration,
    in context: Context
  ) throws -> [AttributeSyntax] {
    guard let property = member.as(VariableDeclSyntax.self), property.isValidForObservation,
          property.identifier != nil else {
      return []
    }

    // dont apply to ignored properties or properties that are already flagged as tracked
    if property.hasMacroApplication(ObservableMacro.ignoredMacroName) ||
       property.hasMacroApplication(ObservableMacro.trackedMacroName) {
      return []
    }


    return [
      AttributeSyntax(attributeName: IdentifierTypeSyntax(name: .identifier(ObservableMacro.trackedMacroName)))
    ]
  }
}

extension ObservableMacro: ExtensionMacro {
  public static func expansion(
    of node: AttributeSyntax,
    attachedTo declaration: some DeclGroupSyntax,
    providingExtensionsOf type: some TypeSyntaxProtocol,
    conformingTo protocols: [TypeSyntax],
    in context: some MacroExpansionContext
  ) throws -> [ExtensionDeclSyntax] {
    // This method can be called twice - first with an empty `protocols` when
    // no conformance is needed, and second with a `MissingTypeSyntax` instance.
    if protocols.isEmpty {
      return []
    }

    let decl: DeclSyntax = """
        extension \(raw: type.trimmedDescription): nonisolated \(raw: qualifiedConformanceName) {}
        """
    let ext = decl.cast(ExtensionDeclSyntax.self)

    if let availability = declaration.attributes.availability {
      return [ext.with(\.attributes, availability)]
    } else {
      return [ext]
    }
  }
}

public struct ObservationTrackedMacro: AccessorMacro {
  public static func expansion<
    Context: MacroExpansionContext,
    Declaration: DeclSyntaxProtocol
  >(
    of node: AttributeSyntax,
    providingAccessorsOf declaration: Declaration,
    in context: Context
  ) throws -> [AccessorDeclSyntax] {
    guard let property = declaration.as(VariableDeclSyntax.self),
          property.isValidForObservation,
          let identifier = property.identifier?.trimmed else {
      return []
    }

    guard context.lexicalContext[0].as(ClassDeclSyntax.self) != nil else {
      return []
    }

    if property.hasMacroApplication(ObservableMacro.ignoredMacroName) {
      return []
    }

    let initAccessor: AccessorDeclSyntax =
      """
      @storageRestrictions(initializes: _\(identifier))
      init(initialValue) {
        _\(identifier) = initialValue
      }
      """
    let getAccessor: AccessorDeclSyntax =
      """
      get {
        access(keyPath: \\.\(identifier))
        return _\(identifier)
      }
      """

    // the guard else case must include the assignment else
    // cases that would notify then drop the side effects of `didSet` etc
    let setAccessor: AccessorDeclSyntax =
      """
      set {
        guard shouldNotifyObservers(_\(identifier), newValue) else {
          _\(identifier) = newValue
          return
        }
        withMutation(keyPath: \\.\(identifier)) {
          _\(identifier) = newValue
        }
      }
      """

    // Note: this accessor cannot test the equality since it would incur
    // additional CoW's on structural types. Most mutations in-place do
    // not leave the value equal so this is "fine"-ish.
    // Warning to future maintence: adding equality checks here can make
    // container mutation O(N) instead of O(1).
    // e.g. observable.array.append(element) should just emit a change
    // to the new array, and NOT cause a copy of each element of the
    // array to an entirely new array.
    let modifyAccessor: AccessorDeclSyntax =
      """
      _modify {
        access(keyPath: \\.\(identifier))
        \(raw: ObservableMacro.registrarVariableName).willSet(self, keyPath: \\.\(identifier))
        defer { \(raw: ObservableMacro.registrarVariableName).didSet(self, keyPath: \\.\(identifier)) }
        yield &_\(identifier)
      }
      """

    return [initAccessor, getAccessor, setAccessor, modifyAccessor]
  }
}

extension ObservationTrackedMacro: PeerMacro {
  public static func expansion<
    Context: MacroExpansionContext,
    Declaration: DeclSyntaxProtocol
  >(
    of node: SwiftSyntax.AttributeSyntax,
    providingPeersOf declaration: Declaration,
    in context: Context
  ) throws -> [DeclSyntax] {
    guard let property = declaration.as(VariableDeclSyntax.self),
          property.isValidForObservation,
          property.identifier?.trimmed != nil else {
      return []
    }

    guard context.lexicalContext[0].as(ClassDeclSyntax.self) != nil else {
      return []
    }

    if property.hasMacroApplication(ObservableMacro.ignoredMacroName) {
      return []
    }

    let localContext = LocalMacroExpansionContext(context: context)
    let storage = DeclSyntax(property.privatePrefixed("_", addingAttribute: ObservableMacro.ignoredAttribute, removingAttribute: ObservableMacro.trackedAttribute, in: localContext))
    return [storage]
  }
}

public struct ObservationIgnoredMacro: AccessorMacro {
  public static func expansion<
    Context: MacroExpansionContext,
    Declaration: DeclSyntaxProtocol
  >(
    of node: AttributeSyntax,
    providingAccessorsOf declaration: Declaration,
    in context: Context
  ) throws -> [AccessorDeclSyntax] {
    return []
  }
}

// MARK: - ObservationMacros/Extensions.swift

import SwiftSyntax
import SwiftSyntaxMacros
import SwiftDiagnostics
import SwiftSyntaxBuilder

extension Syntax {
  var isNonGeneric: Bool {
    if let classDecl = self.as(ClassDeclSyntax.self) {
      if classDecl.genericParameterClause == nil { return true }
    } else if let structDecl = self.as(StructDeclSyntax.self) {
      if structDecl.genericParameterClause == nil { return true }
    } else if let enumDecl = self.as(EnumDeclSyntax.self) {
      if enumDecl.genericParameterClause == nil { return true }
    } else if let actorDecl = self.as(ActorDeclSyntax.self) {
      if actorDecl.genericParameterClause == nil { return true }
    }
    return false
  }
}

extension VariableDeclSyntax {
  var identifierPattern: IdentifierPatternSyntax? {
    bindings.first?.pattern.as(IdentifierPatternSyntax.self)
  }

  var isInstance: Bool {
    for modifier in modifiers {
      for token in modifier.tokens(viewMode: .all) {
        if token.tokenKind == .keyword(.static) || token.tokenKind == .keyword(.class) {
          return false
        }
      }
    }
    return true
  }

  var identifier: TokenSyntax? {
    identifierPattern?.identifier
  }

  var type: TypeSyntax? {
    bindings.first?.typeAnnotation?.type
  }

  func accessorsMatching(_ predicate: (TokenKind) -> Bool) -> [AccessorDeclSyntax] {
    let accessors: [AccessorDeclListSyntax.Element] = bindings.compactMap { patternBinding in
      switch patternBinding.accessorBlock?.accessors {
      case .accessors(let accessors):
        return accessors
      default:
        return nil
      }
    }.flatMap { $0 }
    return accessors.compactMap { accessor in
      if predicate(accessor.accessorSpecifier.tokenKind) {
        return accessor
      } else {
        return nil
      }
    }
  }

  var willSetAccessors: [AccessorDeclSyntax] {
    accessorsMatching { $0 == .keyword(.willSet) }
  }
  var didSetAccessors: [AccessorDeclSyntax] {
    accessorsMatching { $0 == .keyword(.didSet) }
  }

  var isComputed: Bool {
    if accessorsMatching({ $0 == .keyword(.get) }).count > 0 {
      return true
    } else {
      return bindings.contains { binding in
        if case .getter = binding.accessorBlock?.accessors {
          return true
        } else {
          return false
        }
      }
    }
  }


  var isImmutable: Bool {
    return bindingSpecifier.tokenKind == .keyword(.let)
  }

  func isEquivalent(to other: VariableDeclSyntax) -> Bool {
    if isInstance != other.isInstance {
      return false
    }
    return identifier?.text == other.identifier?.text
  }

  var initializer: InitializerClauseSyntax? {
    bindings.first?.initializer
  }

  func hasMacroApplication(_ name: String) -> Bool {
    for attribute in attributes {
      switch attribute {
      case .attribute(let attr):
        if attr.attributeName.tokens(viewMode: .all).map({ $0.tokenKind }) == [.identifier(name)] {
          return true
        }
      default:
        break
      }
    }
    return false
  }
}

extension TypeSyntax {
  var identifier: String? {
    for token in tokens(viewMode: .all) {
      switch token.tokenKind {
      case .identifier(let identifier):
        return identifier
      default:
        break
      }
    }
    return nil
  }

  func genericSubstitution(_ parameters: GenericParameterListSyntax?) -> String? {
    var genericParameters = [String : TypeSyntax?]()
    if let parameters {
      for parameter in parameters {
        genericParameters[parameter.name.text] = parameter.inheritedType
      }
    }
    var iterator = self.asProtocol(TypeSyntaxProtocol.self).tokens(viewMode: .sourceAccurate).makeIterator()
    guard let base = iterator.next() else {
      return nil
    }

    if let genericBase = genericParameters[base.text] {
      if let text = genericBase?.identifier {
        return "some " + text
      } else {
        return nil
      }
    }
    var substituted = base.text

    while let token = iterator.next() {
      switch token.tokenKind {
      case .leftAngle:
        substituted += "<"
      case .rightAngle:
        substituted += ">"
      case .comma:
        substituted += ","
      case .identifier(let identifier):
        let type: TypeSyntax = "\(raw: identifier)"
        guard let substituedType = type.genericSubstitution(parameters) else {
          return nil
        }
        substituted += substituedType
        break
      default:
        // ignore?
        break
      }
    }

    return substituted
  }
}

extension FunctionDeclSyntax {
  var isInstance: Bool {
    for modifier in modifiers {
      for token in modifier.tokens(viewMode: .all) {
        if token.tokenKind == .keyword(.static) || token.tokenKind == .keyword(.class) {
          return false
        }
      }
    }
    return true
  }

  struct SignatureStandin: Equatable {
    var isInstance: Bool
    var identifier: String
    var parameters: [String]
    var returnType: String
  }

  var signatureStandin: SignatureStandin {
    var parameters = [String]()
    for parameter in signature.parameterClause.parameters {
      parameters.append(parameter.firstName.text + ":" + (parameter.type.genericSubstitution(genericParameterClause?.parameters) ?? "" ))
    }
    let returnType = signature.returnClause?.type.genericSubstitution(genericParameterClause?.parameters) ?? "Void"
    return SignatureStandin(isInstance: isInstance, identifier: name.text, parameters: parameters, returnType: returnType)
  }

  func isEquivalent(to other: FunctionDeclSyntax) -> Bool {
    return signatureStandin == other.signatureStandin
  }
}

extension DeclGroupSyntax {
  var memberFunctionStandins: [FunctionDeclSyntax.SignatureStandin] {
    var standins = [FunctionDeclSyntax.SignatureStandin]()
    for member in memberBlock.members {
      if let function = member.decl.as(FunctionDeclSyntax.self) {
        standins.append(function.signatureStandin)
      }
    }
    return standins
  }

  func hasMemberFunction(equvalentTo other: FunctionDeclSyntax) -> Bool {
    for member in memberBlock.members {
      if let function = member.decl.as(FunctionDeclSyntax.self) {
        if function.isEquivalent(to: other) {
          return true
        }
      }
    }
    return false
  }

  func hasMemberProperty(equivalentTo other: VariableDeclSyntax) -> Bool {
    for member in memberBlock.members {
      if let variable = member.decl.as(VariableDeclSyntax.self) {
        if variable.isEquivalent(to: other) {
          return true
        }
      }
    }
    return false
  }

  var definedVariables: [VariableDeclSyntax] {
    memberBlock.members.compactMap { member in
      if let variableDecl = member.decl.as(VariableDeclSyntax.self) {
        return variableDecl
      }
      return nil
    }
  }

  func addIfNeeded(_ decl: DeclSyntax?, to declarations: inout [DeclSyntax]) {
    guard let decl else { return }
    if let fn = decl.as(FunctionDeclSyntax.self) {
      if !hasMemberFunction(equvalentTo: fn) {
        declarations.append(decl)
      }
    } else if let property = decl.as(VariableDeclSyntax.self) {
      if !hasMemberProperty(equivalentTo: property) {
        declarations.append(decl)
      }
    }
  }

  var isClass: Bool {
    return self.is(ClassDeclSyntax.self)
  }

  var isActor: Bool {
    return self.is(ActorDeclSyntax.self)
  }

  var isEnum: Bool {
    return self.is(EnumDeclSyntax.self)
  }

  var isStruct: Bool {
    return self.is(StructDeclSyntax.self)
  }
}

// MARK: - ObservationMacros/Availability.swift

import SwiftSyntax
import SwiftSyntaxMacros
import SwiftDiagnostics
import SwiftSyntaxBuilder


extension AttributeSyntax {
  var availability: AttributeSyntax? {
    if attributeName.identifier == "available" {
      return self
    } else {
      return nil
    }
  }
}

extension IfConfigClauseSyntax.Elements {
  var availability: IfConfigClauseSyntax.Elements? {
    switch self {
    case .attributes(let attributes):
      if let availability = attributes.availability {
        return .attributes(availability)
      } else {
        return nil
      }
    default:
      return nil
    }
  }
}

extension IfConfigClauseSyntax {
  var availability: IfConfigClauseSyntax? {
    if let availability = elements?.availability {
      return with(\.elements, availability)
    } else {
      return nil
    }
  }

  var clonedAsIf: IfConfigClauseSyntax {
    detached.with(\.poundKeyword, .poundIfToken())
  }
}

extension IfConfigDeclSyntax {
  var availability: IfConfigDeclSyntax? {
    var elements = [IfConfigClauseListSyntax.Element]()
    for clause in clauses {
      if let availability = clause.availability {
        if elements.isEmpty {
          elements.append(availability.clonedAsIf)
        } else {
          elements.append(availability)
        }
      }
    }
    if elements.isEmpty {
      return nil
    } else {
      return with(\.clauses, IfConfigClauseListSyntax(elements))
    }

  }
}

extension AttributeListSyntax.Element {
  var availability: AttributeListSyntax.Element? {
    switch self {
    case .attribute(let attribute):
      if let availability = attribute.availability {
        return .attribute(availability)
      }
    case .ifConfigDecl(let ifConfig):
      if let availability = ifConfig.availability {
        return .ifConfigDecl(availability)
      }
    @unknown default:
      break
    }
    return nil
  }
}

extension AttributeListSyntax {
  var availability: AttributeListSyntax? {
    var elements = [AttributeListSyntax.Element]()
    for element in self {
      if let availability = element.availability {
        elements.append(availability)
      }
    }
    if elements.isEmpty {
      return nil
    }
    return AttributeListSyntax(elements)
  }
}

the expansion in the test seemed to handle the comment reasonably, or at least it didn't seem like it produced invalid source.

however, just pasting in this to the unit tests and trying to build & test causes them to fail to build:

@MainActor
@Observable
final class Bugz {
  @MainActor // Nice annotation you've got there
  var it = 0
}

The underlying expansion of macros in the swift-syntax unit tests isn't exactly the same as the compiler itself, but I wouldn't have expected any difference in the trivia being produced by the macro.

@bnbarham can you elaborate on the differences? does anything come to mind that would potentially explain the difference in the test expansion vs 'real' one?

[ZevEisenberg]

I'm not sure if this is useful or just a side quest, but I tried this out using Point-Free's @ObservableState, which is largely copy-pasted from Swift's @Observable macro, and it didn't reproduce the issue either.

[jamieQ]

yeah, i'm pretty confused about what the difference could be between the two behaviors. only thing i can think of is that Observable gets handled by the in-process plugin server (i think?) and ObservableState would not... anyway, as @bnbarham suggested, changing this line in the Observable macro implementation to use a newline instead of a space as leading trivia appears to resolve this particular problem.

[ZevEisenberg]

Well I'll be. @jamieQ thanks for spelling it out! I'm not very familiar with this code, so I had not realized @bnbarham's message contained specific instructions for fixing the bug 🤦🏻‍♂️

#84224

[bnbarham]

so I had not realized @bnbarham's message contained specific instructions for fixing the bug 🤦🏻‍♂️

Sorry, I should have been more clear there. Thanks for putting the PR up!

so what i did was:

I see, I didn't follow the full chain of macros through.

The fully expanded source that the unit tests compare to isn't something that actually exists within the compiler, which expands macros to their own buffers. In this particular case, the difference lies in how the peer macro @ObservableTracked is being expanded in the unit tests - it's passing the variable node with the member attribute added, where as it should be passing the original node. That then causes the removal logic in VariableDeclSyntax.privatePrefixed to kick in, which removes @ObservableTracked and its trivia (which includes the comment). That's definitely a bug in swift-syntax's MacroApplication.