[Macros] Make sure to avoid full macro resolution in name lookup.

When populating the name lookup tables with macro-expanded declarations,
we were careful to avoid full macro resolution for attached macros, but
freestanding macros were will doing full resolution. Switch
freestanding macros over to the same partial resolution mechanism to
avoid reference cycles.

Author: DougGregor

lib/AST/NameLookup.cpp

@@ -1639,13 +1639,9 @@ populateLookupTableEntryFromMacroExpansions(ASTContext &ctx,
     // that weren't introduced by the macro.
     MacroIntroducedNameTracker nameTracker;
     if (auto *med = dyn_cast<MacroExpansionDecl>(member)) {
-      auto declRef = evaluateOrDefault(
-          ctx.evaluator, ResolveMacroRequest{med, dc},
-          nullptr);
-      if (!declRef)
-        continue;
-      auto *macro = dyn_cast<MacroDecl>(declRef.getDecl());
-      nameTracker(macro, macro->getMacroRoleAttr(MacroRole::Declaration));
+      forEachPotentialResolvedMacro(
+          member->getModuleContext(), med->getMacroName(),
+          MacroRole::Declaration, nameTracker);
     } else if (auto *vd = dyn_cast<ValueDecl>(member)) {
       nameTracker.attachedTo = dyn_cast<ValueDecl>(member);
       forEachPotentialAttachedMacro(member, MacroRole::Peer, nameTracker);

test/Macros/macro_expand.swift

@@ -335,6 +335,12 @@ func testFreestandingMacroExpansion() {
 }
 testFreestandingMacroExpansion()
 
+// Explicit structs to force macros to be parsed as decl.
+struct ContainerOfNumberedStructs {
+  #bitwidthNumberedStructs("MyIntOne")
+  #bitwidthNumberedStructs("MyIntTwo")
+}
+
 // Avoid re-type-checking declaration macro arguments.
 @freestanding(declaration)
 macro freestandingWithClosure<T>(_ value: T, body: (T) -> T) = #externalMacro(module: "MacroDefinition", type: "EmptyDeclarationMacro")

test/Macros/top_level_freestanding.swift

@@ -46,3 +46,8 @@ macro freestandingWithClosure<T>(_ value: T, body: (T) -> T) = #externalMacro(mo
   let x = $0
   return x
 }
+
+struct HasInnerClosure {
+  #freestandingWithClosure(0) { x in x }
+  #freestandingWithClosure(1) { x in x }
+}