AST: Consolidate abstract/contrete syntax decl lookup functions.

Author: tshortli

include/swift/AST/AvailabilityInference.h

@@ -94,15 +94,6 @@ class AvailabilityInference {
       AvailabilityDomain &domain, llvm::VersionTuple &platformVer);
 };
 
-// FIXME: This should become a utility on Decl.
-
-/// Given a declaration upon which an availability attribute would appear in
-/// concrete syntax, return a declaration to which the parser
-/// actually attaches the attribute in the abstract syntax tree. We use this
-/// function to determine whether the concrete syntax already has an
-/// availability attribute.
-const Decl *abstractSyntaxDeclForAvailableAttribute(const Decl *D);
-
 } // end namespace swift
 
 #endif

include/swift/AST/Decl.h

@@ -1510,6 +1510,16 @@ class alignas(1 << DeclAlignInBits) Decl : public ASTAllocated<Decl>, public Swi
   /// Returns true if this declaration has any `@backDeployed` attributes.
   bool hasBackDeployedAttr() const;
 
+  /// Return the declaration upon which the attributes for this declaration
+  /// would appear in concrete syntax. This function is necessary because for
+  /// semantic analysis, the parser attaches attributes to declarations other
+  /// than those on which they, concretely, appear.
+  const Decl *getConcreteSyntaxDeclForAttributes() const;
+
+  /// Return the declaration to which the parser actually attaches attributes in
+  /// the abstract syntax tree (see `getConcreteSyntaxDeclForAttributes()`).
+  const Decl *getAbstractSyntaxDeclForAttributes() const;
+
   /// Apply the specified function to decls that should be placed _next_ to
   /// this decl when constructing AST.
   void forEachDeclToHoist(llvm::function_ref<void(Decl *)> callback) const;

lib/AST/Availability.cpp

@@ -383,7 +383,7 @@ static std::optional<SemanticAvailableAttr>
 getDeclAvailableAttrForPlatformIntroduction(const Decl *D) {
   std::optional<SemanticAvailableAttr> bestAvailAttr;
 
-  D = abstractSyntaxDeclForAvailableAttribute(D);
+  D = D->getAbstractSyntaxDeclForAttributes();
 
   for (auto attr : D->getSemanticAvailableAttrs(/*includingInactive=*/false)) {
     if (!attr.isPlatformSpecific() || !attr.getIntroduced())
@@ -1054,36 +1054,6 @@ bool ASTContext::supportsVersionedAvailability() const {
   return minimumAvailableOSVersionForTriple(LangOpts.Target).has_value();
 }
 
-// FIXME: Rename abstractSyntaxDeclForAvailableAttribute since it's useful
-// for more attributes than `@available`.
-const Decl *
-swift::abstractSyntaxDeclForAvailableAttribute(const Decl *ConcreteSyntaxDecl) {
-  // This function needs to be kept in sync with its counterpart,
-  // concreteSyntaxDeclForAvailableAttribute().
-
-  if (auto *PBD = dyn_cast<PatternBindingDecl>(ConcreteSyntaxDecl)) {
-    // Existing @available attributes in the AST are attached to VarDecls
-    // rather than PatternBindingDecls, so we return the first VarDecl for
-    // the pattern binding declaration.
-    // This is safe, even though there may be multiple VarDecls, because
-    // all parsed attribute that appear in the concrete syntax upon on the
-    // PatternBindingDecl are added to all of the VarDecls for the pattern
-    // binding.
-    for (auto index : range(PBD->getNumPatternEntries())) {
-      if (auto VD = PBD->getAnchoringVarDecl(index))
-        return VD;
-    }
-  } else if (auto *ECD = dyn_cast<EnumCaseDecl>(ConcreteSyntaxDecl)) {
-    // Similar to the PatternBindingDecl case above, we return the
-    // first EnumElementDecl.
-    if (auto *Elem = ECD->getFirstElement()) {
-      return Elem;
-    }
-  }
-
-  return ConcreteSyntaxDecl;
-}
-
 bool swift::isExported(const Decl *D) {
   if (auto *VD = dyn_cast<ValueDecl>(D)) {
     return isExported(VD);

lib/AST/AvailabilityConstraint.cpp

@@ -232,7 +232,7 @@ swift::getAvailabilityConstraintsForDecl(const Decl *decl,
   if (isa<GenericTypeParamDecl>(decl))
     return DeclAvailabilityConstraints();
 
-  decl = abstractSyntaxDeclForAvailableAttribute(decl);
+  decl = decl->getAbstractSyntaxDeclForAttributes();
 
   getAvailabilityConstraintsForDecl(constraints, decl, context);
 

lib/AST/AvailabilityScopeBuilder.cpp

@@ -34,7 +34,7 @@ using namespace swift;
 /// that is active.
 // FIXME: [availability] De-duplicate this with TypeCheckAvailability.cpp.
 static bool hasActiveAvailableAttribute(const Decl *decl, ASTContext &ctx) {
-  decl = abstractSyntaxDeclForAvailableAttribute(decl);
+  decl = decl->getAbstractSyntaxDeclForAttributes();
 
   for (auto attr : decl->getSemanticAvailableAttrs()) {
     if (attr.isActive(ctx))
@@ -50,36 +50,6 @@ static bool computeContainedByDeploymentTarget(AvailabilityScope *scope,
       AvailabilityRange::forDeploymentTarget(ctx));
 }
 
-/// Given a declaration that allows availability attributes in the abstract
-/// syntax tree, return the declaration upon which the declaration would
-/// appear in concrete syntax. This function is necessary because for semantic
-/// analysis, the parser attaches attributes to declarations other
-/// than those on which they, concretely, appear. For these declarations (enum
-/// cases and variable declarations) a Fix-It for an added availability
-/// attribute should be suggested for the appropriate concrete location.
-// FIXME: [availability] De-duplicate this with TypeCheckAvailability.cpp.
-static const Decl *
-concreteSyntaxDeclForAvailableAttribute(const Decl *abstractSyntaxDecl) {
-  // This function needs to be kept in sync with its counterpart,
-  // abstractSyntaxDeclForAvailableAttribute().
-
-  // The source range for VarDecls does not include 'var ' (and, in any
-  // event, multiple variables can be introduced with a single 'var'),
-  // so suggest adding an attribute to the PatterningBindingDecl instead.
-  if (auto *vd = dyn_cast<VarDecl>(abstractSyntaxDecl)) {
-    if (auto *pbd = vd->getParentPatternBinding())
-      return pbd;
-  }
-
-  // Similarly suggest applying the Fix-It to the parent enum case rather than
-  // the enum element.
-  if (auto *ee = dyn_cast<EnumElementDecl>(abstractSyntaxDecl)) {
-    return ee->getParentCase();
-  }
-
-  return abstractSyntaxDecl;
-}
-
 namespace {
 /// A class that walks the AST to build the availability scope tree.
 class AvailabilityScopeBuilder : private ASTWalker {
@@ -282,7 +252,7 @@ class AvailabilityScopeBuilder : private ASTWalker {
   bool shouldSkipDecl(Decl *decl) const {
     // Only visit a node that has a corresponding concrete syntax node if we are
     // already walking that concrete syntax node.
-    auto *concreteDecl = concreteSyntaxDeclForAvailableAttribute(decl);
+    auto *concreteDecl = decl->getConcreteSyntaxDeclForAttributes();
     if (concreteDecl != decl) {
       if (ConcreteDeclStack.empty() || ConcreteDeclStack.back() != concreteDecl)
         return true;
@@ -323,7 +293,7 @@ class AvailabilityScopeBuilder : private ASTWalker {
 
     // If this decl is the concrete syntax decl for some abstract syntax decl,
     // push it onto the stack so that the abstract syntax decls may be visited.
-    auto *abstractDecl = abstractSyntaxDeclForAvailableAttribute(decl);
+    auto *abstractDecl = decl->getAbstractSyntaxDeclForAttributes();
     if (abstractDecl != decl) {
       ConcreteDeclStack.push_back(decl);
     }
@@ -425,7 +395,7 @@ class AvailabilityScopeBuilder : private ASTWalker {
 
     // Don't introduce for abstract syntax nodes that have separate concrete
     // syntax nodes. The scope will be introduced for the concrete node instead.
-    if (concreteSyntaxDeclForAvailableAttribute(decl) != decl)
+    if (decl->getConcreteSyntaxDeclForAttributes() != decl)
       return nullptr;
 
     // Declarations with explicit availability attributes always get a scope.
@@ -456,7 +426,7 @@ class AvailabilityScopeBuilder : private ASTWalker {
     auto effectiveIntroduction = AvailabilityRange::alwaysAvailable();
 
     // Availability attributes are found abstract syntax decls.
-    decl = abstractSyntaxDeclForAvailableAttribute(decl);
+    decl = decl->getAbstractSyntaxDeclForAttributes();
 
     // As a special case, extension decls are treated as effectively as
     // available as the nominal type they extend, up to the deployment target.

lib/AST/Decl.cpp

@@ -634,6 +634,54 @@ bool Decl::hasBackDeployedAttr() const {
   return false;
 }
 
+const Decl *Decl::getConcreteSyntaxDeclForAttributes() const {
+  // This function needs to be kept in sync with its counterpart,
+  // getAbstractSyntaxDeclForAttributes().
+
+  // The source range for VarDecls does not include 'var ' (and, in any
+  // event, multiple variables can be introduced with a single 'var'),
+  // so suggest adding an attribute to the PatterningBindingDecl instead.
+  if (auto *vd = dyn_cast<VarDecl>(this)) {
+    if (auto *pbd = vd->getParentPatternBinding())
+      return pbd;
+  }
+
+  // Similarly suggest applying the Fix-It to the parent enum case rather than
+  // the enum element.
+  if (auto *ee = dyn_cast<EnumElementDecl>(this)) {
+    return ee->getParentCase();
+  }
+
+  return this;
+}
+
+const Decl *Decl::getAbstractSyntaxDeclForAttributes() const {
+  // This function needs to be kept in sync with its counterpart,
+  // getConcreteSyntaxDeclForAttributes().
+
+  if (auto *pbd = dyn_cast<PatternBindingDecl>(this)) {
+    // @available attributes in the AST are attached to VarDecls
+    // rather than PatternBindingDecls, so we return the first VarDecl for
+    // the pattern binding declaration.
+    // This is safe, even though there may be multiple VarDecls, because
+    // all parsed attribute that appear in the concrete syntax upon on the
+    // PatternBindingDecl are added to all of the VarDecls for the pattern
+    // binding.
+    for (auto index : range(pbd->getNumPatternEntries())) {
+      if (auto vd = pbd->getAnchoringVarDecl(index))
+        return vd;
+    }
+  } else if (auto *ecd = dyn_cast<EnumCaseDecl>(this)) {
+    // Similar to the PatternBindingDecl case above, we return the
+    // first EnumElementDecl.
+    if (auto *element = ecd->getFirstElement()) {
+      return element;
+    }
+  }
+
+  return this;
+}
+
 void Decl::forEachDeclToHoist(llvm::function_ref<void(Decl *)> callback) const {
   switch (getKind()) {
   case DeclKind::TopLevelCode: {

lib/AST/Module.cpp

@@ -21,7 +21,6 @@
 #include "swift/AST/ASTWalker.h"
 #include "swift/AST/AccessScope.h"
 #include "swift/AST/AttrKind.h"
-#include "swift/AST/AvailabilityInference.h"
 #include "swift/AST/Builtins.h"
 #include "swift/AST/ClangModuleLoader.h"
 #include "swift/AST/DiagnosticsSema.h"
@@ -3159,7 +3158,7 @@ bool Decl::isSPI() const {
 }
 
 ArrayRef<Identifier> Decl::getSPIGroups() const {
-  const Decl *D = abstractSyntaxDeclForAvailableAttribute(this);
+  const Decl *D = getAbstractSyntaxDeclForAttributes();
 
   if (!isa<ValueDecl>(D) &&
       !isa<ExtensionDecl>(D))

lib/Sema/TypeCheckAvailability.cpp

@@ -52,10 +52,6 @@
 #include "llvm/Support/SaveAndRestore.h"
 using namespace swift;
 
-// FIXME: [availability] De-duplicate this with AvailabilityScopeBuilder.cpp.
-static const Decl *
-concreteSyntaxDeclForAvailableAttribute(const Decl *AbstractSyntaxDecl);
-
 /// Emit a diagnostic for references to declarations that have been
 /// marked as unavailable, either through "unavailable" or "obsoleted:".
 static bool diagnoseExplicitUnavailability(
@@ -249,7 +245,7 @@ ExportContext::getExportabilityReason() const {
 /// that is active.
 // FIXME: [availability] De-duplicate this with AvailabilityScopeBuilder.cpp.
 static bool hasActiveAvailableAttribute(const Decl *D, ASTContext &ctx) {
-  D = abstractSyntaxDeclForAvailableAttribute(D);
+  D = D->getAbstractSyntaxDeclForAttributes();
 
   for (auto Attr : D->getSemanticAvailableAttrs()) {
     if (Attr.isActive(ctx))
@@ -545,35 +541,6 @@ static const Decl *findContainingDeclaration(SourceRange ReferenceRange,
   return nullptr;
 }
 
-/// Given a declaration that allows availability attributes in the abstract
-/// syntax tree, return the declaration upon which the declaration would
-/// appear in concrete syntax. This function is necessary because for semantic
-/// analysis, the parser attaches attributes to declarations other
-/// than those on which they, concretely, appear. For these declarations (enum
-/// cases and variable declarations) a Fix-It for an added availability
-/// attribute should be suggested for the appropriate concrete location.
-static const Decl *
-concreteSyntaxDeclForAvailableAttribute(const Decl *AbstractSyntaxDecl) {
-  // This function needs to be kept in sync with its counterpart,
-  // abstractSyntaxDeclForAvailableAttribute().
-
-  // The source range for VarDecls does not include 'var ' (and, in any
-  // event, multiple variables can be introduced with a single 'var'),
-  // so suggest adding an attribute to the PatterningBindingDecl instead.
-  if (auto *VD = dyn_cast<VarDecl>(AbstractSyntaxDecl)) {
-    if (auto *PBD = VD->getParentPatternBinding())
-      return PBD;
-  }
-
-  // Similarly suggest applying the Fix-It to the parent enum case rather than
-  // the enum element.
-  if (auto *EE = dyn_cast<EnumElementDecl>(AbstractSyntaxDecl)) {
-    return EE->getParentCase();
-  }
-
-  return AbstractSyntaxDecl;
-}
-
 /// Given a declaration, return a better related declaration for which
 /// to suggest an @available fixit, or the original declaration
 /// if no such related declaration exists.
@@ -584,7 +551,7 @@ static const Decl *relatedDeclForAvailabilityFixit(const Decl *D) {
     D = accessor->getStorage();
   }
 
-  return abstractSyntaxDeclForAvailableAttribute(D);
+  return D->getAbstractSyntaxDeclForAttributes();
 }
 
 /// Walk the DeclContext hierarchy starting from D to find a declaration
@@ -749,7 +716,7 @@ static void fixAvailabilityForDecl(
   // syntax to suggest the Fix-It may differ from the declaration to which
   // we attach availability attributes in the abstract syntax tree during
   // parsing.
-  const Decl *ConcDecl = concreteSyntaxDeclForAvailableAttribute(D);
+  const Decl *ConcDecl = D->getConcreteSyntaxDeclForAttributes();
 
   // To avoid exposing the pattern binding declaration to the user, get the
   // descriptive kind from one of the VarDecls.