[Macros] Separate determining whether a custom attribute is a macro and

type checking macro attribute arguments into two different requests.

Author: hborla

include/swift/AST/MacroDeclaration.h

@@ -66,17 +66,13 @@ bool macroIntroducedNameRequiresArgument(MacroIntroducedDeclNameKind kind);
 StringRef getMacroIntroducedDeclNameString(
     MacroIntroducedDeclNameKind kind);
 
-class MacroDecl;
 class CustomAttr;
 
 /// Perform lookup to determine whether the given custom attribute refers to
-/// a macro declaration, and return that macro declaration.
-///
-/// \Returns \c None if the custom attribute name does not match any macro
-/// declarations, \c nullptr if the macro reference has errors in the argument
-/// list, or a resolved macro declaration for a valid macro attribute.
-Optional<MacroDecl *>
-findMacroForCustomAttr(CustomAttr *attr, DeclContext *dc);
+/// a macro declaration, and populate the \c macros vector with the lookup
+/// results that are attached macros.
+void findMacroForCustomAttr(CustomAttr *attr, DeclContext *dc,
+                            llvm::TinyPtrVector<ValueDecl *> &macros);
 
 class MacroIntroducedDeclName {
 public:

include/swift/AST/TypeCheckRequests.h

@@ -3128,6 +3128,24 @@ class CheckRedeclarationRequest
                            evaluator::SideEffect) const;
 };
 
+/// Resolve a given custom attribute to an attached macro declaration.
+class ResolveAttachedMacroRequest
+    : public SimpleRequest<ResolveAttachedMacroRequest,
+                           MacroDecl *(CustomAttr *, DeclContext *),
+                           RequestFlags::Cached> {
+public:
+  using SimpleRequest::SimpleRequest;
+
+private:
+  friend SimpleRequest;
+
+  MacroDecl *
+  evaluate(Evaluator &evaluator, CustomAttr *attr, DeclContext *dc) const;
+
+public:
+  bool isCached() const { return true; }
+};
+
 class ResolveTypeEraserTypeRequest
     : public SimpleRequest<ResolveTypeEraserTypeRequest,
                            Type (ProtocolDecl *, TypeEraserAttr *),

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -340,6 +340,9 @@ SWIFT_REQUEST(TypeChecker, PreCheckResultBuilderRequest,
 SWIFT_REQUEST(TypeChecker, ResolveImplicitMemberRequest,
               evaluator::SideEffect(NominalTypeDecl *, ImplicitMemberAction),
               Uncached, NoLocationInfo)
+SWIFT_REQUEST(TypeChecker, ResolveAttachedMacroRequest,
+              MacroDecl *(CustomAttr *, DeclContext *),
+              Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, ResolveTypeEraserTypeRequest,
               Type(ProtocolDecl *, TypeEraserAttr *),
               SeparatelyCached, NoLocationInfo)

lib/AST/Attr.cpp

@@ -2342,15 +2342,12 @@ bool CustomAttr::isAttachedMacro(const Decl *decl) const {
   auto &ctx = decl->getASTContext();
   auto *dc = decl->getInnermostDeclContext();
 
-  auto attrDecl = evaluateOrDefault(
+  auto *macroDecl = evaluateOrDefault(
       ctx.evaluator,
-      CustomAttrDeclRequest{const_cast<CustomAttr *>(this), dc},
+      ResolveAttachedMacroRequest{const_cast<CustomAttr *>(this), dc},
       nullptr);
 
-  if (!attrDecl)
-    return false;
-
-  return attrDecl.dyn_cast<MacroDecl *>();
+  return macroDecl != nullptr;
 }
 
 DeclarationAttr::DeclarationAttr(SourceLoc atLoc, SourceRange range,

lib/AST/NameLookup.cpp

@@ -3041,14 +3041,40 @@ GenericParamListRequest::evaluate(Evaluator &evaluator, GenericContext *value) c
       parsedGenericParams->getRAngleLoc());
 }
 
+void swift::findMacroForCustomAttr(CustomAttr *attr, DeclContext *dc,
+                                   llvm::TinyPtrVector<ValueDecl *> &macros) {
+  auto *identTypeRepr = dyn_cast_or_null<IdentTypeRepr>(attr->getTypeRepr());
+  if (!identTypeRepr)
+    return;
+
+  // 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.
+  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 (isAttachedMacro(macro->getMacroRoles()))
+        macros.push_back(macro);
+  }
+}
+
 MacroOrNominalTypeDecl
 CustomAttrDeclRequest::evaluate(Evaluator &evaluator,
                                 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.getValue();
+  llvm::TinyPtrVector<ValueDecl *> macros;
+  findMacroForCustomAttr(attr, dc, macros);
+  if (!macros.empty())
+    return nullptr;
 
   // Find the types referenced by the custom attribute.
   auto &ctx = dc->getASTContext();

lib/Sema/TypeCheckAttr.cpp

@@ -3558,19 +3558,20 @@ void AttributeChecker::visitCustomAttr(CustomAttr *attr) {
   auto found = evaluateOrDefault(
     Ctx.evaluator, CustomAttrDeclRequest{attr, dc}, nullptr);
 
-  // FIXME: deal with macros.
   NominalTypeDecl *nominal = nullptr;
   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) {
+    // Try resolving an attached macro attribute.
+    auto *macro = evaluateOrDefault(
+        Ctx.evaluator, ResolveAttachedMacroRequest{attr, dc}, nullptr);
+    if (macro || !attr->isValid())
+      return;
+
+    // Diagnose errors.
+
     auto typeRepr = attr->getTypeRepr();
 
     auto type = TypeResolution::forInterface(dc, TypeResolverContext::CustomAttr,

lib/Sema/TypeCheckMacros.cpp

@@ -318,18 +318,14 @@ bool ExpandMemberAttributeMacros::evaluate(Evaluator &evaluator,
   auto parentAttrs = parentDecl->getSemanticAttrs();
   for (auto customAttrConst: parentAttrs.getAttributes<CustomAttr>()) {
     auto customAttr = const_cast<CustomAttr *>(customAttrConst);
-    auto customAttrDecl = evaluateOrDefault(
+    auto *macroDecl = evaluateOrDefault(
         evaluator,
-        CustomAttrDeclRequest{
+          ResolveAttachedMacroRequest{
           customAttr,
           parentDecl->getInnermostDeclContext()
         },
         nullptr);
 
-    if (!customAttrDecl)
-      continue;
-
-    auto macroDecl = customAttrDecl.dyn_cast<MacroDecl *>();
     if (!macroDecl)
       continue;
 
@@ -364,10 +360,9 @@ static bool isFromExpansionOfMacro(SourceFile *sourceFile, MacroDecl *macro) {
     } else if (auto *macroAttr = sourceFile->getAttachedMacroAttribute()) {
       auto *decl = expansion.dyn_cast<Decl *>();
       auto &ctx = decl->getASTContext();
-      auto attrDecl = evaluateOrDefault(ctx.evaluator,
-          CustomAttrDeclRequest{macroAttr, decl->getDeclContext()},
+      auto *macroDecl = evaluateOrDefault(ctx.evaluator,
+          ResolveAttachedMacroRequest{macroAttr, decl->getDeclContext()},
           nullptr);
-      auto *macroDecl = attrDecl.dyn_cast<MacroDecl *>();
       if (!macroDecl)
         return false;
 
@@ -1083,32 +1078,16 @@ bool swift::expandAttributes(CustomAttr *attr, MacroDecl *macro, Decl *member) {
   return addedAttributes;
 }
 
-Optional<MacroDecl *>
-swift::findMacroForCustomAttr(CustomAttr *attr, DeclContext *dc) {
-  auto *identTypeRepr = dyn_cast_or_null<IdentTypeRepr>(attr->getTypeRepr());
-  if (!identTypeRepr)
-    return None;
-
-  // 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.
+MacroDecl *
+ResolveAttachedMacroRequest::evaluate(Evaluator &evaluator,
+                                      CustomAttr *attr,
+                                      DeclContext *dc) const {
+  auto &ctx = dc->getASTContext();
   llvm::TinyPtrVector<ValueDecl *> 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 (isAttachedMacro(macro->getMacroRoles()))
-        macros.push_back(macro);
-  }
+  findMacroForCustomAttr(attr, dc, macros);
 
   if (macros.empty())
-    return None;
+    return nullptr;
 
   // Extract macro arguments from the attribute, or create an empty list.
   ArgumentList *attrArgs;
@@ -1121,6 +1100,7 @@ swift::findMacroForCustomAttr(CustomAttr *attr, DeclContext *dc) {
   // Form an `OverloadedDeclRefExpr` with the filtered lookup result above
   // to ensure @freestanding macros are not considered in overload resolution.
   FunctionRefKind functionRefKind = FunctionRefKind::SingleApply;
+  auto *identTypeRepr = dyn_cast<IdentTypeRepr>(attr->getTypeRepr());
   auto macroRefExpr = new (ctx) OverloadedDeclRefExpr(
       macros, identTypeRepr->getNameLoc(), functionRefKind,
       /*implicit*/true);

lib/Sema/TypeCheckStorage.cpp

@@ -3443,17 +3443,14 @@ StorageImplInfoRequest::evaluate(Evaluator &evaluator,
   // Check for an accessor macro.
   for (auto customAttrConst : storage->getSemanticAttrs().getAttributes<CustomAttr>()) {
     auto customAttr = const_cast<CustomAttr *>(customAttrConst);
-    auto decl = evaluateOrDefault(
+    auto *macro = evaluateOrDefault(
         evaluator,
-        CustomAttrDeclRequest{
+        ResolveAttachedMacroRequest{
           customAttr,
           storage->getInnermostDeclContext()
         },
         nullptr);
-    if (!decl)
-      continue;
 
-    auto macro = decl.dyn_cast<MacroDecl *>();
     if (!macro)
       continue;