[Macros] Allow custom attributes to resolve to attached macro declarations.

Introduce appropriate name lookup for custom attributes to find macros
at module scope, and prefer those to types of the same name. We don't
do anything with the macros we found other than ignore them, for the
moment.

Author: DougGregor

include/swift/AST/DiagnosticsCommon.def

@@ -221,6 +221,8 @@ NOTE(in_macro_expansion,none,
      "in expansion of macro %0 here", (DeclName))
 ERROR(macro_experimental,none,
       "macros are an experimental feature that is not enabled", ())
+ERROR(ambiguous_macro_reference,none,
+      "ambiguous reference to macro %0", (DeclName))
 
 //------------------------------------------------------------------------------
 // MARK: bridged diagnostics

include/swift/AST/MacroDeclaration.h

@@ -30,7 +30,7 @@ enum class MacroContext: uint8_t {
   /// A freestanding declaration macro.
   FreestandingDeclaration = 0x02,
   /// An attached declaration macro.
-  AttachedDeclaration = 0x03,
+  AttachedDeclaration = 0x04,
 };
 
 /// The contexts in which a particular macro declaration can be used.

lib/AST/NameLookup.cpp

@@ -3040,9 +3040,57 @@ GenericParamListRequest::evaluate(Evaluator &evaluator, GenericContext *value) c
       parsedGenericParams->getRAngleLoc());
 }
 
+/// Perform lookup to determine whether the given custom attribute refers to
+/// a macro declaration, and return that macro declaration.
+static MacroDecl *findMacroForCustomAttr(CustomAttr *attr, DeclContext *dc) {
+  auto *identTypeRepr = dyn_cast_or_null<IdentTypeRepr>(attr->getTypeRepr());
+  if (!identTypeRepr)
+    return nullptr;
+
+  // Look for macros at module scope. They can only occur at module scope, and
+  // we need to be sure not to trigger name lookup into type contexts along
+  // the way.
+  llvm::TinyPtrVector<MacroDecl *> macros;
+  auto moduleScopeDC = dc->getModuleScopeContext();
+  ASTContext &ctx = moduleScopeDC->getASTContext();
+  UnqualifiedLookupDescriptor descriptor(
+      identTypeRepr->getNameRef(), moduleScopeDC
+  );
+  auto lookup = evaluateOrDefault(
+      ctx.evaluator, UnqualifiedLookupRequest{descriptor}, {});
+  for (const auto &result : lookup.allResults()) {
+    // Only keep attached macros, which can be spelled as custom attributes.
+    if (auto macro = dyn_cast<MacroDecl>(result.getValueDecl()))
+      if (macro->getMacroContexts().contains(MacroContext::AttachedDeclaration))
+        macros.push_back(macro);
+  }
+
+  if (macros.empty())
+    return nullptr;
+
+  if (macros.size() > 1) {
+    ctx.Diags.diagnose(attr->getLocation(), diag::ambiguous_macro_reference,
+                       identTypeRepr->getNameRef().getFullName());
+
+    for (auto macro : macros) {
+      macro->diagnose(
+          diag::kind_declname_declared_here, macro->getDescriptiveKind(),
+          macro->getName());
+    }
+  }
+
+  return macros.front();
+}
+
 MacroOrNominalTypeDecl
 CustomAttrDeclRequest::evaluate(Evaluator &evaluator,
-                                   CustomAttr *attr, DeclContext *dc) const {
+                                CustomAttr *attr, DeclContext *dc) const {
+  // Look for names at module scope, so we don't trigger name lookup for
+  // nested scopes. At this point, we're looking to see whether there are
+  // any suitable macros.
+  if (auto macro = findMacroForCustomAttr(attr, dc))
+    return macro;
+
   // Find the types referenced by the custom attribute.
   auto &ctx = dc->getASTContext();
   DirectlyReferencedTypeDecls decls;

lib/Sema/TypeCheckAttr.cpp

@@ -3558,8 +3558,14 @@ void AttributeChecker::visitCustomAttr(CustomAttr *attr) {
 
   // FIXME: deal with macros.
   NominalTypeDecl *nominal = nullptr;
-  if (found)
+  if (found) {
+    // FIXME: Do full checking of the macro arguments here by turning it into
+    // a macro expansion expression (?).
+    if (found.is<MacroDecl *>())
+      return;
+
     nominal = found.dyn_cast<NominalTypeDecl *>();
+  }
 
   // Diagnose errors.
   if (!found) {

test/Macros/attached_macros_diags.swift

@@ -0,0 +1,30 @@
+// RUN: %target-typecheck-verify-swift -enable-experimental-feature Macros -module-name MacrosTest
+
+@declaration(attached) macro m1: Void = #externalMacro(module: "MyMacros", type: "Macro1")
+// expected-warning@-1{{external macro implementation type 'MyMacros.Macro1' could not be found for macro 'm1'}}
+
+@declaration(attached) macro m2(_: Int) -> Void = #externalMacro(module: "MyMacros", type: "Macro2")
+// expected-warning@-1{{external macro implementation type 'MyMacros.Macro2' could not be found for macro 'm2'}}
+// expected-note@-2 2{{macro 'm2' declared here}}
+
+@declaration(attached) macro m2(_: Double) -> Void = #externalMacro(module: "MyMacros", type: "Macro2")
+// expected-warning@-1{{external macro implementation type 'MyMacros.Macro2' could not be found for macro 'm2'}}
+// expected-note@-2 2{{macro 'm2' declared here}}
+
+@m1 struct X1 { }
+
+// FIXME: Redundant diagnostic
+@m2 struct X2 { } // expected-error 2{{ambiguous reference to macro 'm2'}}
+
+// Check for nesting rules.
+struct SkipNestedType {
+  @propertyWrapper
+  struct m1<T> {
+    init() { }
+
+    var wrappedValue: T
+  }
+
+  // We select the macro, not the property wrapper.
+  @m1 var x: Int = 0
+}