Allow expansion of member macros on extensions and make those names visible.

Ensure that name lookup triggers the expansion of member macros on
extensions, so we can find those names. And fix a bug that caused
expansion of member macros to crash.

Author: DougGregor

lib/AST/NameLookup.cpp

@@ -2145,6 +2145,11 @@ QualifiedLookupRequest::evaluate(Evaluator &eval, const DeclContext *DC,
     (void)evaluateOrDefault(ctx.evaluator,
                             ExpandSynthesizedMemberMacroRequest{current},
                             false);
+    for (auto ext : current->getExtensions()) {
+      (void)evaluateOrDefault(ctx.evaluator,
+                              ExpandSynthesizedMemberMacroRequest{ext},
+                              false);
+    }
 
     // Look for results within the current nominal type and its extensions.
     bool currentIsProtocol = isa<ProtocolDecl>(current);

lib/Sema/TypeCheckMacros.cpp

@@ -1258,7 +1258,7 @@ evaluateAttachedMacro(MacroDecl *macro, Decl *attachedTo, CustomAttr *attr,
     if (auto nominal = dyn_cast<NominalTypeDecl>(attachedTo)) {
       rightBraceLoc = nominal->getBraces().End;
     } else {
-      auto ext = cast<ExtensionDecl>(parentDecl);
+      auto ext = cast<ExtensionDecl>(attachedTo);
       rightBraceLoc = ext->getBraces().End;
     }
 

test/Macros/Inputs/syntax_macro_definitions.swift

@@ -554,6 +554,37 @@ public struct AddMembers: MemberMacro {
   }
 }
 
+public struct AddExtMembers: MemberMacro {
+  public static func expansion(
+    of node: AttributeSyntax,
+    providingMembersOf decl: some DeclGroupSyntax,
+    in context: some MacroExpansionContext
+  ) throws -> [DeclSyntax] {
+    let uniqueClassName = context.createUniqueName("uniqueClass")
+
+    let instanceMethod: DeclSyntax =
+      """
+      func extInstanceMethod() {}
+      """
+
+    let staticMethod: DeclSyntax =
+      """
+      static func extStaticMethod() {}
+      """
+
+    let classDecl: DeclSyntax =
+      """
+      class \(uniqueClassName) { }
+      """
+
+    return [
+      instanceMethod,
+      staticMethod,
+      classDecl,
+    ]
+  }
+}
+
 public struct AddArbitraryMembers: MemberMacro {
   public static func expansion(
     of node: AttributeSyntax,

test/Macros/macro_expand_synthesized_members.swift

@@ -23,12 +23,25 @@ struct S {
   }
 }
 
+@attached(
+  member,
+  names: named(extInstanceMethod), named(extStaticMethod)
+)
+macro addExtMembers() = #externalMacro(module: "MacroDefinition", type: "AddExtMembers")
+
+@addExtMembers
+extension S { }
+
 let s = S()
 
 // CHECK: synthesized method
 // CHECK: Storage
 s.useSynthesized()
 
+// Members added via extension.
+s.extInstanceMethod()
+S.extStaticMethod()
+
 @attached(member, names: arbitrary)
 macro addArbitraryMembers() = #externalMacro(module: "MacroDefinition", type: "AddArbitraryMembers")