Merge pull request #63154 from hborla/type-check-attached-macro-args

Author: hborla

include/swift/AST/MacroDeclaration.h

@@ -66,6 +66,14 @@ bool macroIntroducedNameRequiresArgument(MacroIntroducedDeclNameKind kind);
 StringRef getMacroIntroducedDeclNameString(
     MacroIntroducedDeclNameKind kind);
 
+class CustomAttr;
+
+/// Perform lookup to determine whether the given custom attribute refers to
+/// 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:
   using Kind = MacroIntroducedDeclNameKind;

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

@@ -2351,15 +2351,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

@@ -26,6 +26,7 @@
 #include "swift/AST/ImportCache.h"
 #include "swift/AST/Initializer.h"
 #include "swift/AST/LazyResolver.h"
+#include "swift/AST/MacroDeclaration.h"
 #include "swift/AST/ModuleNameLookup.h"
 #include "swift/AST/NameLookupRequests.h"
 #include "swift/AST/ParameterList.h"
@@ -3040,17 +3041,15 @@ 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) {
+void swift::findMacroForCustomAttr(CustomAttr *attr, DeclContext *dc,
+                                   llvm::TinyPtrVector<ValueDecl *> &macros) {
   auto *identTypeRepr = dyn_cast_or_null<IdentTypeRepr>(attr->getTypeRepr());
   if (!identTypeRepr)
-    return nullptr;
+    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.
-  llvm::TinyPtrVector<MacroDecl *> macros;
   auto moduleScopeDC = dc->getModuleScopeContext();
   ASTContext &ctx = moduleScopeDC->getASTContext();
   UnqualifiedLookupDescriptor descriptor(
@@ -3064,22 +3063,6 @@ static MacroDecl *findMacroForCustomAttr(CustomAttr *attr, DeclContext *dc) {
       if (isAttachedMacro(macro->getMacroRoles()))
         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
@@ -3088,8 +3071,10 @@ CustomAttrDeclRequest::evaluate(Evaluator &evaluator,
   // 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;
+  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/ConstraintSystem.cpp

@@ -3590,7 +3590,7 @@ void ConstraintSystem::resolveOverload(ConstraintLocator *locator,
     if (auto macro = dyn_cast<MacroDecl>(decl)) {
       // Macro can only be used in an expansion. If we end up here, it's
       // because we found a macro but are missing the leading '#'.
-      if (!locator->isForMacroExpansion()) {
+      if (!(locator->isForMacroExpansion() || locator->getAnchor().isImplicit())) {
         // Record a fix here
         (void)recordFix(MacroMissingPound::create(*this, macro, locator));
       }

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;
 
@@ -1086,3 +1081,43 @@ bool swift::expandAttributes(CustomAttr *attr, MacroDecl *macro, Decl *member) {
 
   return addedAttributes;
 }
+
+MacroDecl *
+ResolveAttachedMacroRequest::evaluate(Evaluator &evaluator,
+                                      CustomAttr *attr,
+                                      DeclContext *dc) const {
+  auto &ctx = dc->getASTContext();
+  llvm::TinyPtrVector<ValueDecl *> macros;
+  findMacroForCustomAttr(attr, dc, macros);
+
+  if (macros.empty())
+    return nullptr;
+
+  // Extract macro arguments from the attribute, or create an empty list.
+  ArgumentList *attrArgs;
+  if (attr->hasArgs()) {
+    attrArgs = attr->getArgs();
+  } else {
+    attrArgs = ArgumentList::createImplicit(ctx, {});
+  }
+
+  // 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);
+  auto *call = CallExpr::createImplicit(ctx, macroRefExpr, attrArgs);
+
+  Expr *result = call;
+  TypeChecker::typeCheckExpression(result, dc);
+
+  if (auto *fn = dyn_cast<DeclRefExpr>(call->getFn()))
+    if (auto *macro = dyn_cast<MacroDecl>(fn->getDecl()))
+      return macro;
+
+  // If we couldn't resolve a macro decl, the attribute is invalid.
+  attr->setInvalid();
+  return nullptr;
+}

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;
 

lib/Sema/TypeCheckTypeWrapper.cpp

@@ -124,7 +124,9 @@ static void getTypeWrappers(NominalTypeDecl *decl,
   for (auto *attr : decl->getAttrs().getAttributes<CustomAttr>()) {
     auto *mutableAttr = const_cast<CustomAttr *>(attr);
     auto found = evaluateOrDefault(
-        ctx.evaluator, CustomAttrDeclRequest{mutableAttr, decl}, nullptr);
+        ctx.evaluator,
+        CustomAttrDeclRequest{mutableAttr, decl->getDeclContext()},
+        nullptr);
 
     if (!found)
       continue;