[NFC] Refactor diagnoseDeclAvailability() flags

The function took three random boolean parameters; there’s about to be a fourth. This wasn’t going to scale.

Author: beccadax

lib/Sema/TypeCheckAvailability.cpp

@@ -2368,9 +2368,7 @@ class AvailabilityWalker : public ASTWalker {
 
   bool diagAvailability(const ValueDecl *D, SourceRange R,
                         const ApplyExpr *call = nullptr,
-                        bool AllowPotentiallyUnavailableProtocol = false,
-                        bool SignalOnPotentialUnavailability = true,
-                        bool ForInout = false);
+                        DeclAvailabilityFlags flags = None);
 
 private:
   bool diagnoseIncDecRemoval(const ValueDecl *D, SourceRange R,
@@ -2504,46 +2502,45 @@ class AvailabilityWalker : public ASTWalker {
     switch (AccessContext) {
     case MemberAccessContext::Getter:
       diagAccessorAvailability(D->getGetter(), ReferenceRange, ReferenceDC,
-                               /*ForInout=*/false);
+                               None);
       break;
 
     case MemberAccessContext::Setter:
       diagAccessorAvailability(D->getSetter(), ReferenceRange, ReferenceDC,
-                               /*ForInout=*/false);
+                               None);
       break;
 
     case MemberAccessContext::InOut:
       diagAccessorAvailability(D->getGetter(), ReferenceRange, ReferenceDC,
-                               /*ForInout=*/true);
+                               DeclAvailabilityFlag::ForInout);
 
       diagAccessorAvailability(D->getSetter(), ReferenceRange, ReferenceDC,
-                               /*ForInout=*/true);
+                               DeclAvailabilityFlag::ForInout);
       break;
     }
   }
 
   /// Emit a diagnostic, if necessary for a potentially unavailable accessor.
   void diagAccessorAvailability(AccessorDecl *D, SourceRange ReferenceRange,
                                 const DeclContext *ReferenceDC,
-                                bool ForInout) const {
+                                DeclAvailabilityFlags Flags) const {
+    Flags &= DeclAvailabilityFlag::ForInout;
+    Flags |= DeclAvailabilityFlag::ContinueOnPotentialUnavailability;
     if (diagnoseDeclAvailability(D, TC,
                                  const_cast<DeclContext*>(ReferenceDC),
                                  ReferenceRange,
-                                 /*AllowPotentiallyUnavailableProtocol*/false,
-                                 /*SignalOnPotentialUnavailability*/false,
-                                 ForInout))
+                                 Flags))
       return;
   }
 };
 } // end anonymous namespace
 
 /// Diagnose uses of unavailable declarations. Returns true if a diagnostic
 /// was emitted.
-bool AvailabilityWalker::diagAvailability(const ValueDecl *D, SourceRange R,
-                                          const ApplyExpr *call,
-                                          bool AllowPotentiallyUnavailableProtocol,
-                                          bool SignalOnPotentialUnavailability,
-                                          bool ForInout) {
+bool
+AvailabilityWalker::diagAvailability(const ValueDecl *D, SourceRange R,
+                                     const ApplyExpr *call,
+                                     DeclAvailabilityFlags Flags) {
   if (!D)
     return false;
 
@@ -2582,20 +2579,22 @@ bool AvailabilityWalker::diagAvailability(const ValueDecl *D, SourceRange R,
   if (!isAccessorWithDeprecatedStorage)
     TC.diagnoseIfDeprecated(R, DC, D, call);
 
-  if (AllowPotentiallyUnavailableProtocol && isa<ProtocolDecl>(D))
+  if (Flags.contains(DeclAvailabilityFlag::AllowPotentiallyUnavailableProtocol)
+        && isa<ProtocolDecl>(D))
     return false;
 
   // Diagnose (and possibly signal) for potential unavailability
   auto maybeUnavail = TC.checkDeclarationAvailability(D, R.Start, DC);
   if (maybeUnavail.hasValue()) {
     if (accessor) {
+      bool forInout = Flags.contains(DeclAvailabilityFlag::ForInout);
       TC.diagnosePotentialAccessorUnavailability(accessor, R, DC,
                                                  maybeUnavail.getValue(),
-                                                 ForInout);
+                                                 forInout);
     } else {
       TC.diagnosePotentialUnavailability(D, R, DC, maybeUnavail.getValue());
     }
-    if (SignalOnPotentialUnavailability)
+    if (!Flags.contains(DeclAvailabilityFlag::ContinueOnPotentialUnavailability))
       return true;
   }
   return false;
@@ -2769,13 +2768,8 @@ bool swift::diagnoseDeclAvailability(const ValueDecl *Decl,
                                      TypeChecker &TC,
                                      DeclContext *DC,
                                      SourceRange R,
-                                     bool AllowPotentiallyUnavailableProtocol,
-                                     bool SignalOnPotentialUnavailability,
-                                     bool ForInout)
+                                     DeclAvailabilityFlags Flags)
 {
   AvailabilityWalker AW(TC, DC);
-  return AW.diagAvailability(Decl, R, nullptr,
-                             AllowPotentiallyUnavailableProtocol,
-                             SignalOnPotentialUnavailability,
-                             ForInout);
+  return AW.diagAvailability(Decl, R, nullptr, Flags);
 }

lib/Sema/TypeCheckAvailability.h

@@ -17,6 +17,7 @@
 #include "swift/AST/Identifier.h"
 #include "swift/Basic/LLVM.h"
 #include "swift/Basic/SourceLoc.h"
+#include "swift/Basic/OptionSet.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/Optional.h"
 
@@ -33,16 +34,21 @@ namespace swift {
 void diagAvailability(TypeChecker &TC, const Expr *E,
                       DeclContext *DC);
 
+enum class DeclAvailabilityFlag : uint8_t {
+  AllowPotentiallyUnavailableProtocol = 1 << 0,
+  ContinueOnPotentialUnavailability = 1 << 1,
+  ForInout = 1 << 2,
+};
+using DeclAvailabilityFlags = OptionSet<DeclAvailabilityFlag>;
+
 /// Run the Availability-diagnostics algorithm otherwise used in an expr
 /// context, but for non-expr contexts such as TypeDecls referenced from
 /// TypeReprs.
 bool diagnoseDeclAvailability(const ValueDecl *Decl,
                               TypeChecker &TC,
                               DeclContext *DC,
                               SourceRange R,
-                              bool AllowPotentiallyUnavailableProtocol,
-                              bool SignalOnPotentialUnavailability,
-                              bool ForInout);
+                              DeclAvailabilityFlags Options);
 
 void diagnoseUnavailableOverride(ValueDecl *override,
                                  const ValueDecl *base,

lib/Sema/TypeCheckType.cpp

@@ -1544,16 +1544,17 @@ static Type resolveIdentTypeComponent(
 static bool diagnoseAvailability(IdentTypeRepr *IdType,
                                  DeclContext *DC,
                                  bool AllowPotentiallyUnavailableProtocol) {
+  DeclAvailabilityFlags flags =
+    DeclAvailabilityFlag::ContinueOnPotentialUnavailability;
+  if (AllowPotentiallyUnavailableProtocol)
+    flags |= DeclAvailabilityFlag::AllowPotentiallyUnavailableProtocol;
   ASTContext &ctx = DC->getASTContext();
   auto componentRange = IdType->getComponentRange();
   for (auto comp : componentRange) {
     if (auto *typeDecl = comp->getBoundDecl()) {
       assert(ctx.getLazyResolver() && "Must have a type checker!");
       TypeChecker &tc = static_cast<TypeChecker &>(*ctx.getLazyResolver());
-      if (diagnoseDeclAvailability(typeDecl, tc, DC, comp->getIdLoc(),
-                                   AllowPotentiallyUnavailableProtocol,
-                                   /*SignalOnPotentialUnavailability*/false,
-                                   /*ForInout*/false)) {
+      if (diagnoseDeclAvailability(typeDecl, tc, DC, comp->getIdLoc(), flags)) {
         return true;
       }
     }