AST/Sema: Remove DeclAttr::isUnavailable().

tshortli · tshortli · commit 2358712870f1 · 2024-12-02T07:35:58.000-08:00
Update callers to use `Decl::isUnavailable()` instead.
diff --git a/include/swift/AST/Attr.h b/include/swift/AST/Attr.h
@@ -2931,10 +2931,6 @@ class DeclAttributes {
     return UnaryOperatorKind::None;
   }
 
-  bool isUnavailable(const ASTContext &ctx) const {
-    return getUnavailable(ctx) != nullptr;
-  }
-
   bool isDeprecated(const ASTContext &ctx) const {
     return getDeprecated(ctx) != nullptr;
   }
diff --git a/lib/AST/ASTPrinter.cpp b/lib/AST/ASTPrinter.cpp
@@ -2153,7 +2153,7 @@ bool isNonSendableExtension(const Decl *D) {
   ASTContext &ctx = D->getASTContext();
 
   const ExtensionDecl *ED = dyn_cast<ExtensionDecl>(D);
-  if (!ED || !ED->getAttrs().isUnavailable(ctx))
+  if (!ED || !ED->isUnavailable())
     return false;
 
   auto nonSendable =
@@ -2193,8 +2193,7 @@ bool ShouldPrintChecker::shouldPrint(const Decl *D,
         return false;
     }
 
-    if (Options.SkipUnavailable &&
-        D->getAttrs().isUnavailable(D->getASTContext()))
+    if (Options.SkipUnavailable && D->isUnavailable())
       return false;
   }
 
diff --git a/lib/AST/ASTVerifier.cpp b/lib/AST/ASTVerifier.cpp
@@ -2931,7 +2931,7 @@ class Verifier : public ASTWalker {
 
         if (auto req = dyn_cast<ValueDecl>(member)) {
           if (!normal->hasWitness(req)) {
-            if ((req->getAttrs().isUnavailable(Ctx) ||
+            if ((req->isUnavailable() ||
                  req->getAttrs().hasAttribute<OptionalAttr>()) &&
                 proto->isObjC()) {
               continue;
diff --git a/lib/AST/NameLookup.cpp b/lib/AST/NameLookup.cpp
@@ -364,8 +364,8 @@ enum class ConstructorComparison {
 static ConstructorComparison compareConstructors(ConstructorDecl *ctor1,
                                                  ConstructorDecl *ctor2,
                                                  const swift::ASTContext &ctx) {
-  bool available1 = !ctor1->getAttrs().isUnavailable(ctx);
-  bool available2 = !ctor2->getAttrs().isUnavailable(ctx);
+  bool available1 = !ctor1->isUnavailable();
+  bool available2 = !ctor2->isUnavailable();
 
   // An unavailable initializer is always worse than an available initializer.
   if (available1 < available2)
@@ -560,15 +560,14 @@ static void recordShadowedDeclsAfterTypeMatch(
 
       // If one declaration is available and the other is not, prefer the
       // available one.
-      if (firstDecl->getAttrs().isUnavailable(ctx) !=
-            secondDecl->getAttrs().isUnavailable(ctx)) {
-       if (firstDecl->getAttrs().isUnavailable(ctx)) {
-         shadowed.insert(firstDecl);
-         break;
-       } else {
-         shadowed.insert(secondDecl);
-         continue;
-       }
+      if (firstDecl->isUnavailable() != secondDecl->isUnavailable()) {
+        if (firstDecl->isUnavailable()) {
+          shadowed.insert(firstDecl);
+          break;
+        } else {
+          shadowed.insert(secondDecl);
+          continue;
+        }
       }
 
       // Don't apply module-shadowing rules to members of protocol types.
diff --git a/lib/AST/ProtocolConformance.cpp b/lib/AST/ProtocolConformance.cpp
@@ -731,12 +731,11 @@ void NormalProtocolConformance::setWitness(ValueDecl *requirement,
           //  funcs; there seems to be a problem that we mark completed, but
           //  afterwards will record the thunk witness;
           (dyn_cast<FuncDecl>(requirement)
-            ? (dyn_cast<FuncDecl>(requirement)->isDistributed() ||
-               dyn_cast<FuncDecl>(requirement)->isDistributedThunk())
-            : false) ||
+               ? (dyn_cast<FuncDecl>(requirement)->isDistributed() ||
+                  dyn_cast<FuncDecl>(requirement)->isDistributedThunk())
+               : false) ||
           requirement->getAttrs().hasAttribute<OptionalAttr>() ||
-          requirement->getAttrs().isUnavailable(
-                                        requirement->getASTContext())) &&
+          requirement->isUnavailable()) &&
          "Conformance already complete?");
   Mapping[requirement] = witness;
 }
diff --git a/lib/ClangImporter/ImportDecl.cpp b/lib/ClangImporter/ImportDecl.cpp
@@ -3219,7 +3219,7 @@ namespace {
       // Don't import unavailable fields that have no associated storage.
       // TODO: is there any way we could bail here before we allocate/construct
       // the VarDecl?
-      if (result->getAttrs().isUnavailable(Impl.SwiftContext))
+      if (result->isUnavailable())
         return nullptr;
 
       return result;
@@ -6296,7 +6296,7 @@ Decl *SwiftDeclConverter::importEnumCase(const clang::EnumConstantDecl *decl,
 
     // If the correct declaration was unavailable, don't map to it.
     // FIXME: This eliminates spurious errors, but affects QoI.
-    if (correctCase->getAttrs().isUnavailable(Impl.SwiftContext))
+    if (correctCase->isUnavailable())
       return nullptr;
 
     auto compatibilityCase =
@@ -6358,7 +6358,7 @@ SwiftDeclConverter::importOptionConstant(const clang::EnumConstantDecl *decl,
   // not operate as a set-like member.  Mark them unavailable with a message
   // that says that they should be used as [].
   if (decl->getInitVal() == 0 && !nameInfo.hasCustomName() &&
-      !CD->getAttrs().isUnavailable(Impl.SwiftContext)) {
+      !CD->isUnavailable()) {
     /// Create an AvailableAttr that indicates specific availability
     /// for all platforms.
     auto attr = AvailableAttr::createPlatformAgnostic(
@@ -6835,8 +6835,7 @@ bool SwiftDeclConverter::existingConstructorIsWorse(
 
   // If one constructor is unavailable in Swift and the other is
   // not, keep the available one.
-  bool existingIsUnavailable =
-      existingCtor->getAttrs().isUnavailable(Impl.SwiftContext);
+  bool existingIsUnavailable = existingCtor->isUnavailable();
   bool newIsUnavailable = Impl.isUnavailableInSwift(objcMethod);
   if (existingIsUnavailable != newIsUnavailable)
     return existingIsUnavailable;
@@ -6951,9 +6950,7 @@ ConstructorDecl *SwiftDeclConverter::importConstructor(
     ctors = found->second;
 
   for (auto ctor : ctors) {
-    if (ctor->isInvalid() ||
-        ctor->getAttrs().isUnavailable(Impl.SwiftContext) ||
-        !ctor->getClangDecl())
+    if (ctor->isInvalid() || ctor->isUnavailable() || !ctor->getClangDecl())
       continue;
 
     // If the types don't match, this is a different constructor with
@@ -7358,7 +7355,7 @@ SwiftDeclConverter::importSubscript(Decl *decl,
 
   // Local function to mark the setter unavailable.
   auto makeSetterUnavailable = [&] {
-    if (setter && !setter->getAttrs().isUnavailable(Impl.SwiftContext))
+    if (setter && !setter->isUnavailable())
       Impl.markUnavailable(setter, "use subscripting");
   };
 
@@ -7503,7 +7500,7 @@ SwiftDeclConverter::importSubscript(Decl *decl,
     Impl.Subscripts[{getter, nullptr}] = subscript;
 
   // Make the getter/setter methods unavailable.
-  if (!getter->getAttrs().isUnavailable(Impl.SwiftContext))
+  if (!getter->isUnavailable())
     Impl.markUnavailable(getter, "use subscripting");
   makeSetterUnavailable();
 
@@ -8571,7 +8568,7 @@ void ClangImporter::Implementation::importAttributes(
 
   // Scan through Clang attributes and map them onto Swift
   // equivalents.
-  bool AnyUnavailable = MappedDecl->getAttrs().isUnavailable(C);
+  bool AnyUnavailable = MappedDecl->isUnavailable();
   for (clang::NamedDecl::attr_iterator AI = ClangDecl->attr_begin(),
        AE = ClangDecl->attr_end(); AI != AE; ++AI) {
     //
diff --git a/lib/ClangImporter/ImportType.cpp b/lib/ClangImporter/ImportType.cpp
@@ -907,7 +907,7 @@ namespace {
 #endif
 
       // If the imported typealias is unavailable, return the underlying type.
-      if (decl->getAttrs().isUnavailable(Impl.SwiftContext))
+      if (decl->isUnavailable())
         return underlyingResult;
 
       return { mappedType, underlyingResult.Hint };
diff --git a/lib/Sema/CSDiagnostics.cpp b/lib/Sema/CSDiagnostics.cpp
@@ -4246,7 +4246,7 @@ findImportedCaseWithMatchingSuffix(Type instanceTy, DeclNameRef name) {
     ASTContext &ctx = a->getASTContext();
 
     // Is one more available than the other?
-    WORSE(->getAttrs().isUnavailable(ctx));
+    WORSE(->isUnavailable());
     WORSE(->getAttrs().isDeprecated(ctx));
 
     // Does one have a shorter name (so the non-matching prefix is shorter)?
diff --git a/lib/Sema/DerivedConformanceCodable.cpp b/lib/Sema/DerivedConformanceCodable.cpp
@@ -1110,7 +1110,7 @@ deriveBodyEncodable_enum_encode(AbstractFunctionDecl *encodeDecl, void *) {
           -> std::tuple<EnumElementDecl *, BraceStmt *> {
         SmallVector<ASTNode, 3> caseStatements;
 
-        if (elt->getAttrs().isUnavailable(C)) {
+        if (elt->isUnavailable()) {
           // This case is not encodable because it is unavailable and therefore
           // should not be instantiable at runtime. Skipping this case will
           // result in the SIL pipeline giving the switch a default case for
@@ -1713,7 +1713,7 @@ deriveBodyDecodable_enum_init(AbstractFunctionDecl *initDecl, void *) {
           if (!codingKeyCase)
             return std::make_tuple(nullptr, nullptr);
 
-          if (elt->getAttrs().isUnavailable(C)) {
+          if (elt->isUnavailable()) {
             // generate:
             //       throw DecodingError.dataCorrupted(
             //         DecodingError.Context(
diff --git a/lib/Sema/DerivedConformanceCodingKey.cpp b/lib/Sema/DerivedConformanceCodingKey.cpp
@@ -275,7 +275,7 @@ deriveBodyCodingKey_init_stringValue(AbstractFunctionDecl *initDecl, void *) {
   for (auto *elt : elements) {
     // Skip the cases that would return unavailable elements since those can't
     // be instantiated at runtime.
-    if (elt->getAttrs().isUnavailable(C))
+    if (elt->isUnavailable())
       continue;
 
     auto *litExpr = new (C) StringLiteralExpr(elt->getNameStr(), SourceRange(),
diff --git a/lib/Sema/TypeCheckDecl.cpp b/lib/Sema/TypeCheckDecl.cpp
@@ -2145,7 +2145,7 @@ ResultTypeRequest::evaluate(Evaluator &evaluator, ValueDecl *decl) const {
     // Mark the imported Swift function as unavailable.
     // That will ensure that the function will not be
     // usable from Swift, even though it is imported.
-    if (!decl->getAttrs().isUnavailable(ctx)) {
+    if (!decl->isUnavailable()) {
       StringRef unavailabilityMsgRef = "return type is unavailable in Swift";
       auto ua =
           AvailableAttr::createPlatformAgnostic(ctx, unavailabilityMsgRef);
diff --git a/lib/Sema/TypeCheckDeclObjC.cpp b/lib/Sema/TypeCheckDeclObjC.cpp
@@ -3318,12 +3318,11 @@ class ObjCImplementationChecker {
 
     // Also skip overrides, unless they override an unavailable decl, which
     // makes them not formally overrides anymore.
-    if (VD->getOverriddenDecl() &&
-          !VD->getOverriddenDecl()->getAttrs().isUnavailable(ctx))
+    if (VD->getOverriddenDecl() && !VD->getOverriddenDecl()->isUnavailable())
       return;
 
     // Skip alternate Swift names for other language modes.
-    if (VD->getAttrs().isUnavailable(ctx))
+    if (VD->isUnavailable())
       return;
 
     // Skip async versions of members. We'll match against the completion
diff --git a/lib/Sema/TypeCheckExprObjC.cpp b/lib/Sema/TypeCheckExprObjC.cpp
@@ -287,7 +287,7 @@ std::optional<Type> TypeChecker::checkObjCKeyPathExpr(DeclContext *dc,
     if (lookup.size() > 1) {
       lookup.filter([&](LookupResultEntry result, bool isOuter) -> bool {
           // Drop unavailable candidates.
-          if (result.getValueDecl()->getAttrs().isUnavailable(Context))
+          if (result.getValueDecl()->isUnavailable())
             return false;
 
           // Drop non-property, non-type candidates.
diff --git a/lib/Sema/TypeCheckProtocol.cpp b/lib/Sema/TypeCheckProtocol.cpp
@@ -1853,8 +1853,7 @@ RequirementCheck WitnessChecker::checkWitness(ValueDecl *requirement,
     return RequirementCheck(CheckKind::Availability, requiredAvailability);
   }
 
-  if (requirement->getAttrs().isUnavailable(ctx) &&
-      match.Witness->getDeclContext() == DC) {
+  if (requirement->isUnavailable() && match.Witness->getDeclContext() == DC) {
     return RequirementCheck(CheckKind::Unavailable);
   }
 
@@ -1876,11 +1875,10 @@ RequirementCheck WitnessChecker::checkWitness(ValueDecl *requirement,
     }
   }
 
-  if (match.Witness->getAttrs().isUnavailable(ctx) &&
-      !requirement->getAttrs().isUnavailable(ctx)) {
+  if (match.Witness->isUnavailable() && !requirement->isUnavailable()) {
     auto nominalOrExtensionIsUnavailable = [&]() {
       if (auto extension = dyn_cast<ExtensionDecl>(DC)) {
-        if (extension->getAttrs().isUnavailable(ctx))
+        if (extension->isUnavailable())
           return true;
       }
 
@@ -4014,14 +4012,12 @@ getAdopteeSelfSameTypeConstraint(ClassDecl *selfClass, ValueDecl *witness) {
 static bool allowOptionalWitness(ProtocolDecl *proto,
                                  NormalProtocolConformance *conformance,
                                  ValueDecl *requirement) {
-  auto Attrs = requirement->getAttrs();
-
   // An optional requirement is trivially satisfied with an empty requirement.
-  if (Attrs.hasAttribute<OptionalAttr>())
+  if (requirement->getAttrs().hasAttribute<OptionalAttr>())
     return true;
 
   // An 'unavailable' requirement is treated like an optional requirement.
-  if (Attrs.isUnavailable(proto->getASTContext()))
+  if (requirement->isUnavailable())
     return true;
 
   // A requirement with a satisfied Obj-C alternative requirement is effectively
@@ -4209,7 +4205,7 @@ ConformanceChecker::resolveWitnessViaLookup(ValueDecl *requirement) {
   bool ignoringNames = false;
   bool considerRenames =
       !canDerive && !requirement->getAttrs().hasAttribute<OptionalAttr>() &&
-      !requirement->getAttrs().isUnavailable(getASTContext());
+      !requirement->isUnavailable();
 
   if (findBestWitness(requirement,
                       considerRenames ? &ignoringNames : nullptr,
@@ -5158,7 +5154,7 @@ void ConformanceChecker::resolveValueWitnesses() {
       // Objective-C checking for @objc requirements.
       if (requirement->isObjC() &&
           requirement->getName() == witness->getName() &&
-          !requirement->getAttrs().isUnavailable(getASTContext())) {
+          !requirement->isUnavailable()) {
         // The witness must also be @objc.
         if (!witness->isObjC()) {
           bool isOptional =
@@ -6504,7 +6500,7 @@ void TypeChecker::checkConformancesInContext(IterableDeclContext *idc) {
         unsigned bestScore = UINT_MAX;
         for (auto req : unsatisfiedReqs) {
           // Skip unavailable requirements.
-          if (req->getAttrs().isUnavailable(Context)) continue;
+          if (req->isUnavailable()) continue;
 
           // Score this particular optional requirement.
           auto score = scorePotentiallyMatching(req, value, bestScore);
@@ -6569,7 +6565,7 @@ void TypeChecker::checkConformancesInContext(IterableDeclContext *idc) {
       if (!req->isObjC()) continue;
 
       // Skip unavailable requirements.
-      if (req->getAttrs().isUnavailable(Context)) continue;
+      if (req->isUnavailable()) continue;
 
       // Record this requirement.
       if (auto funcReq = dyn_cast<AbstractFunctionDecl>(req)) {
@@ -6641,7 +6637,7 @@ swift::findWitnessedObjCRequirements(const ValueDecl *witness,
       if (isa<TypeDecl>(req)) continue;
 
       // Skip unavailable requirements.
-      if (req->getAttrs().isUnavailable(ctx)) continue;
+      if (req->isUnavailable()) continue;
 
       // Dig out the conformance.
       if (!conformance.has_value()) {
diff --git a/lib/Serialization/Deserialization.cpp b/lib/Serialization/Deserialization.cpp
@@ -6813,8 +6813,7 @@ DESERIALIZE_TYPE(BUILTIN_ALIAS_TYPE)(
   }
 
   // Look through compatibility aliases that are now unavailable.
-  if (alias->getAttrs().isUnavailable(MF.getContext()) &&
-      alias->isCompatibilityAlias()) {
+  if (alias->isUnavailable() && alias->isCompatibilityAlias()) {
     return alias->getUnderlyingType();
   }
 
@@ -6909,8 +6908,7 @@ Expected<Type> DESERIALIZE_TYPE(NAME_ALIAS_TYPE)(
     return underlyingType;
 
   // Look through compatibility aliases that are now unavailable.
-  if (alias && alias->getAttrs().isUnavailable(MF.getContext()) &&
-      alias->isCompatibilityAlias()) {
+  if (alias && alias->isUnavailable() && alias->isCompatibilityAlias()) {
     return alias->getUnderlyingType().subst(subMapOrError.get());
   }
 
@@ -8692,7 +8690,7 @@ void ModuleFile::finishNormalConformance(NormalProtocolConformance *conformance,
 
     assert(allowCompilerErrors() || !req || isOpaque || witness ||
            req->getAttrs().hasAttribute<OptionalAttr>() ||
-           req->getAttrs().isUnavailable(getContext()));
+           req->isUnavailable());
     if (!witness && !isOpaque) {
       trySetWitness(Witness());
       continue;
diff --git a/tools/SourceKit/lib/SwiftLang/SwiftSourceDocInfo.cpp b/tools/SourceKit/lib/SwiftLang/SwiftSourceDocInfo.cpp
@@ -523,8 +523,6 @@ static void walkRelatedDecls(const ValueDecl *VD, const FnTy &Fn) {
   if (isa<ParamDecl>(VD))
     return; // Parameters don't have interesting related declarations.
 
-  auto &ctx = VD->getASTContext();
-
   llvm::SmallDenseMap<DeclName, unsigned, 16> NamesSeen;
   ++NamesSeen[VD->getName()];
 
@@ -553,7 +551,7 @@ static void walkRelatedDecls(const ValueDecl *VD, const FnTy &Fn) {
 
   SmallVector<ValueDecl *, 8> RelatedDecls;
   for (auto result : results) {
-    if (result->getAttrs().isUnavailable(ctx))
+    if (result->isUnavailable())
       continue;
 
     if (result != VD) {

Original file line number	Diff line number	Diff line change
`@@ -2931,10 +2931,6 @@ class DeclAttributes {`
`2931`	`2931`	`return UnaryOperatorKind::None;`
`2932`	`2932`	`}`
`2933`	`2933`
`2934`		`- bool isUnavailable(const ASTContext &ctx) const {`
`2935`		`- return getUnavailable(ctx) != nullptr;`
`2936`		`- }`
`2937`		`-`
`2938`	`2934`	`bool isDeprecated(const ASTContext &ctx) const {`
`2939`	`2935`	`return getDeprecated(ctx) != nullptr;`
`2940`	`2936`	`}`
Original file line number	Diff line number	Diff line change
`@@ -2153,7 +2153,7 @@ bool isNonSendableExtension(const Decl *D) {`
`2153`	`2153`	`ASTContext &ctx = D->getASTContext();`
`2154`	`2154`
`2155`	`2155`	`const ExtensionDecl *ED = dyn_cast<ExtensionDecl>(D);`
`2156`		`- if (!ED \|\| !ED->getAttrs().isUnavailable(ctx))`
	`2156`	`+ if (!ED \|\| !ED->isUnavailable())`
`2157`	`2157`	`return false;`
`2158`	`2158`
`2159`	`2159`	`auto nonSendable =`
`@@ -2193,8 +2193,7 @@ bool ShouldPrintChecker::shouldPrint(const Decl *D,`
`2193`	`2193`	`return false;`
`2194`	`2194`	`}`
`2195`	`2195`
`2196`		`- if (Options.SkipUnavailable &&`
`2197`		`- D->getAttrs().isUnavailable(D->getASTContext()))`
	`2196`	`+ if (Options.SkipUnavailable && D->isUnavailable())`
`2198`	`2197`	`return false;`
`2199`	`2198`	`}`
`2200`	`2199`