[Macros] Invoke member macro expansion during qualified lookup.

Otherwise, members that are added via macro expansion will not be visible
in other source files.

Author: hborla

lib/AST/NameLookup.cpp

@@ -2004,6 +2004,12 @@ QualifiedLookupRequest::evaluate(Evaluator &eval, const DeclContext *DC,
     // Make sure we've resolved property wrappers, if we need them.
     installPropertyWrapperMembersIfNeeded(current, member);
 
+    // Expand synthesized member macros.
+    auto &ctx = current->getASTContext();
+    evaluateOrDefault(ctx.evaluator,
+                      ExpandSynthesizedMemberMacroRequest{current},
+                      false);
+
     // Look for results within the current nominal type and its extensions.
     bool currentIsProtocol = isa<ProtocolDecl>(current);
     auto flags = OptionSet<NominalTypeDecl::LookupDirectFlags>();

lib/Sema/LookupVisibleDecls.cpp

@@ -605,6 +605,12 @@ static void synthesizeMemberDeclsForLookup(NominalTypeDecl *NTD,
                                            /*useResolver=*/true);
   }
 
+  // Expand synthesized member macros.
+  auto &ctx = NTD->getASTContext();
+  evaluateOrDefault(ctx.evaluator,
+                    ExpandSynthesizedMemberMacroRequest{NTD},
+                    false);
+
   synthesizePropertyWrapperVariables(NTD);
 }
 

test/Macros/Inputs/macro_expand_other.swift

@@ -0,0 +1,12 @@
+
+struct DogObserver: Observer {
+  typealias Subject = Dog
+}
+
+func observeDog() {
+  let dog = Dog()
+  dog.name = "George"
+  dog.treat = Treat()
+  dog.bark()
+  dog.addObserver(DogObserver())
+}

test/Macros/Inputs/macro_library.swift

@@ -0,0 +1,31 @@
+
+public protocol Observable {}
+
+public protocol Observer<Subject> {
+  associatedtype Subject: Observable
+}
+
+public struct ObservationRegistrar<Subject: Observable> {
+  public init() {}
+
+  public func addObserver(_ observer: some Observer<Subject>) {}
+
+  public func removeObserver(_ observer: some Observer<Subject>) {}
+
+  public func beginAccess<Value>(_ keyPath: KeyPath<Subject, Value>) {}
+
+  public func beginAccess() {}
+
+  public func endAccess() {}
+
+  public func register<Value>(observable: Subject, willSet: KeyPath<Subject, Value>, to: Value) {}
+
+  public func register<Value>(observable: Subject, didSet: KeyPath<Subject, Value>) {}
+}
+
+@attached(member)
+@attached(memberAttribute)
+public macro Observable() = #externalMacro(module: "MacroDefinition", type: "ObservableMacro")
+
+@attached(accessor)
+public macro ObservableProperty() = #externalMacro(module: "MacroDefinition", type: "ObservablePropertyMacro")

test/Macros/Inputs/syntax_macro_definitions.swift

@@ -569,3 +569,151 @@ public enum LeftHandOperandFinderMacro: ExpressionMacro {
     return node.argumentList.first!.expression
   }
 }
+
+private extension DeclSyntaxProtocol {
+  var isObservableStoredProperty: Bool {
+    if let property = self.as(VariableDeclSyntax.self),
+          let binding = property.bindings.first,
+          let identifier = binding.pattern.as(IdentifierPatternSyntax.self)?.identifier,
+          identifier.text != "_registrar", identifier.text != "_storage",
+          binding.accessor == nil {
+      return true
+    }
+
+    return false
+  }
+}
+
+public struct ObservableMacro: MemberMacro, MemberAttributeMacro {
+
+  // MARK: - MemberMacro
+
+  public static func expansion(
+    of node: AttributeSyntax,
+    providingMembersOf declaration: some DeclGroupSyntax,
+    in context: some MacroExpansionContext
+  ) throws -> [DeclSyntax] {
+    guard let identified = declaration.asProtocol(IdentifiedDeclSyntax.self) else {
+      return []
+    }
+
+    let parentName = identified.identifier
+
+    let registrar: DeclSyntax =
+      """
+      let _registrar = ObservationRegistrar<\(parentName)>()
+      """
+
+    let addObserver: DeclSyntax =
+      """
+      public nonisolated func addObserver(_ observer: some Observer<\(parentName)>) {
+        _registrar.addObserver(observer)
+      }
+      """
+
+    let removeObserver: DeclSyntax =
+      """
+      public nonisolated func removeObserver(_ observer: some Observer<\(parentName)>) {
+        _registrar.removeObserver(observer)
+      }
+      """
+
+    let withTransaction: DeclSyntax =
+      """
+      private func withTransaction<T>(_ apply: () throws -> T) rethrows -> T {
+        _registrar.beginAccess()
+        defer { _registrar.endAccess() }
+        return try apply()
+      }
+      """
+
+    let memberList = MemberDeclListSyntax(
+      declaration.members.members.filter {
+        $0.decl.isObservableStoredProperty
+      }
+    )
+
+    let storageStruct: DeclSyntax =
+      """
+      private struct Storage {
+      \(memberList)
+      }
+      """
+
+    let storage: DeclSyntax =
+      """
+      private var _storage = Storage()
+      """
+
+    return [
+      registrar,
+      addObserver,
+      removeObserver,
+      withTransaction,
+      storageStruct,
+      storage,
+    ]
+  }
+
+  // MARK: - MemberAttributeMacro
+
+  public static func expansion(
+    of node: AttributeSyntax,
+    attachedTo declaration: some DeclGroupSyntax,
+    providingAttributesFor member: DeclSyntax,
+    in context: some MacroExpansionContext
+  ) throws -> [SwiftSyntax.AttributeSyntax] {
+    guard member.isObservableStoredProperty else {
+      return []
+    }
+
+    return [
+      AttributeSyntax(
+        attributeName: SimpleTypeIdentifierSyntax(
+          name: .identifier("ObservableProperty")
+        )
+      )
+    ]
+  }
+
+}
+
+public struct ObservablePropertyMacro: AccessorMacro {
+  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,
+      binding.accessor == nil
+    else {
+      return []
+    }
+
+    let getAccessor: AccessorDeclSyntax =
+      """
+      get {
+        _registrar.beginAccess(\\.\(identifier))
+        defer { _registrar.endAccess() }
+        return _storage.\(identifier)
+      }
+      """
+
+    let setAccessor: AccessorDeclSyntax =
+      """
+      set {
+        _registrar.beginAccess(\\.\(identifier))
+        _registrar.register(observable: self, willSet: \\.\(identifier), to: newValue)
+        defer {
+          _registrar.register(observable: self, didSet: \\.\(identifier))
+          _registrar.endAccess()
+        }
+        _storage.\(identifier) = newValue
+      }
+      """
+
+    return [getAccessor, setAccessor]
+  }
+}

test/Macros/macro_expand_primary.swift

@@ -0,0 +1,30 @@
+// RUN: %empty-directory(%t)
+// RUN: %empty-directory(%t-scratch)
+// RUN: %target-build-swift -I %swift-host-lib-dir -L %swift-host-lib-dir -emit-library -o %t/%target-library-name(MacroDefinition) -module-name=MacroDefinition %S/Inputs/syntax_macro_definitions.swift -g -no-toolchain-stdlib-rpath
+// RUN: %target-swift-frontend -emit-module -o %t/macro_library.swiftmodule %S/Inputs/macro_library.swift -module-name macro_library -enable-experimental-feature Macros -load-plugin-library %t/%target-library-name(MacroDefinition) -I %swift-host-lib-dir
+// RUN: %target-swift-frontend -typecheck -I%t -verify -primary-file %s %S/Inputs/macro_expand_other.swift -verify-ignore-unknown  -enable-experimental-feature Macros -load-plugin-library %t/%target-library-name(MacroDefinition) -I %swift-host-lib-dir
+
+// REQUIRES: asserts
+// REQUIRES: OS=macosx
+
+import macro_library
+
+struct Treat {}
+
+@Observable
+final class Dog: Observable {
+  var name: String?
+  var treat: Treat?
+
+  var isHappy: Bool = true
+
+  init() {}
+
+  func bark() {
+    print("bork bork")
+  }
+}
+
+func test() {
+  observeDog()
+}