NFC: Hoist queries for unavailable decl optimizations into the AST library.

Moving the query implementation up to the AST library from SIL will allow
conveniences to be written on specific AST element classes. For instance, this
will allow `EnumDecl` to expose a convenience that enumerates element decls
that are available during lowering.

Also, improve naming and documentation for these queries.

Author: tshortli

include/swift/AST/Decl.h

@@ -1234,6 +1234,18 @@ class alignas(1 << DeclAlignInBits) Decl : public ASTAllocated<Decl> {
   llvm::Optional<std::pair<const AvailableAttr *, const Decl *>>
   getSemanticUnavailableAttr() const;
 
+  /// Returns true if this declaration should be considered available during
+  /// SIL/IR lowering. A declaration would not be available during lowering if,
+  /// for example, it is annotated as unavailable with \c @available and
+  /// optimization settings require that it be omitted.
+  bool isAvailableDuringLowering() const;
+
+  /// Returns true if ABI compatibility stubs must be emitted for the given
+  /// declaration. Decls marked unavailable with \c @available require these
+  /// stubs if the compiler flags have enabled unavailable declaration ABI
+  /// compatibility mode.
+  bool requiresUnavailableDeclABICompatibilityStubs() const;
+
   // List the SPI groups declared with @_spi or inherited by this decl.
   //
   // SPI groups are inherited from the parent contexts only if the local decl

include/swift/SIL/SILModule.h

@@ -1078,23 +1078,14 @@ namespace Lowering {
 /// Determine whether the given class will be allocated/deallocated using the
 /// Objective-C runtime, i.e., +alloc and -dealloc.
 LLVM_LIBRARY_VISIBILITY bool usesObjCAllocator(ClassDecl *theClass);
-
-/// Returns true if SIL/IR lowering for the given declaration should be skipped.
-/// A declaration may not require lowering if, for example, it is annotated as
-/// unavailable and optimization settings allow it to be omitted.
-LLVM_LIBRARY_VISIBILITY bool shouldSkipLowering(const Decl *D);
-
-/// Returns true if SIL/IR lowering for the given declaration should produce
-/// a stub that traps at runtime because the code ought to be unreachable.
-LLVM_LIBRARY_VISIBILITY bool shouldLowerToUnavailableCodeStub(const Decl *D);
 } // namespace Lowering
 
 /// Apply the given function to each ABI member of \c D skipping the members
 /// that should be skipped according to \c shouldSkipLowering()
 template <typename F>
 void forEachMemberToLower(IterableDeclContext *D, F &&f) {
   for (auto *member : D->getABIMembers()) {
-    if (!Lowering::shouldSkipLowering(member))
+    if (member->isAvailableDuringLowering())
       f(member);
   }
 }

lib/AST/Availability.cpp

@@ -298,6 +298,33 @@ llvm::Optional<AvailableAttrDeclPair> Decl::getSemanticUnavailableAttr() const {
                            llvm::None);
 }
 
+static bool isUnconditionallyUnavailable(const Decl *D) {
+  if (auto unavailableAttrAndDecl = D->getSemanticUnavailableAttr())
+    return unavailableAttrAndDecl->first->isUnconditionallyUnavailable();
+
+  return false;
+}
+
+bool Decl::isAvailableDuringLowering() const {
+  // Unconditionally unavailable declarations should be skipped during lowering
+  // when -unavailable-decl-optimization=complete is specified.
+  if (getASTContext().LangOpts.UnavailableDeclOptimizationMode !=
+      UnavailableDeclOptimization::Complete)
+    return true;
+
+  return !isUnconditionallyUnavailable(this);
+}
+
+bool Decl::requiresUnavailableDeclABICompatibilityStubs() const {
+  // Code associated with unavailable declarations should trap at runtime if
+  // -unavailable-decl-optimization=stub is specified.
+  if (getASTContext().LangOpts.UnavailableDeclOptimizationMode !=
+      UnavailableDeclOptimization::Stub)
+    return false;
+
+  return isUnconditionallyUnavailable(this);
+}
+
 bool UnavailabilityReason::requiresDeploymentTargetOrEarlier(
     ASTContext &Ctx) const {
   return RequiredDeploymentRange.getLowerEndpoint() <=

lib/IRGen/GenClass.cpp

@@ -1841,7 +1841,7 @@ namespace {
 
     void buildMethod(ConstantArrayBuilder &descriptors,
                      AbstractFunctionDecl *method) {
-      if (Lowering::shouldSkipLowering(method))
+      if (!method->isAvailableDuringLowering())
         return;
 
       auto accessor = dyn_cast<AccessorDecl>(method);

lib/IRGen/GenDecl.cpp

@@ -1563,7 +1563,7 @@ void IRGenerator::noteUseOfTypeGlobals(NominalTypeDecl *type,
   if (!type)
     return;
 
-  assert(!Lowering::shouldSkipLowering(type));
+  assert(type->isAvailableDuringLowering());
 
   // Force emission of ObjC protocol descriptors used by type refs.
   if (auto proto = dyn_cast<ProtocolDecl>(type)) {
@@ -2473,7 +2473,7 @@ void swift::irgen::disableAddressSanitizer(IRGenModule &IGM, llvm::GlobalVariabl
 
 /// Emit a global declaration.
 void IRGenModule::emitGlobalDecl(Decl *D) {
-  if (Lowering::shouldSkipLowering(D))
+  if (!D->isAvailableDuringLowering())
     return;
 
   D->visitAuxiliaryDecls([&](Decl *decl) {
@@ -5550,7 +5550,7 @@ static Address getAddrOfSimpleVariable(IRGenModule &IGM,
 /// The result is always a GlobalValue.
 Address IRGenModule::getAddrOfFieldOffset(VarDecl *var,
                                           ForDefinition_t forDefinition) {
-  assert(!Lowering::shouldSkipLowering(var));
+  assert(var->isAvailableDuringLowering());
 
   LinkEntity entity = LinkEntity::forFieldOffset(var);
   return getAddrOfSimpleVariable(*this, GlobalVars, entity,
@@ -5559,7 +5559,7 @@ Address IRGenModule::getAddrOfFieldOffset(VarDecl *var,
 
 Address IRGenModule::getAddrOfEnumCase(EnumElementDecl *Case,
                                        ForDefinition_t forDefinition) {
-  assert(!Lowering::shouldSkipLowering(Case));
+  assert(Case->isAvailableDuringLowering());
 
   LinkEntity entity = LinkEntity::forEnumCase(Case);
   auto addr = getAddrOfSimpleVariable(*this, GlobalVars, entity, forDefinition);
@@ -5572,7 +5572,7 @@ Address IRGenModule::getAddrOfEnumCase(EnumElementDecl *Case,
 
 void IRGenModule::emitNestedTypeDecls(DeclRange members) {
   for (Decl *member : members) {
-    if (Lowering::shouldSkipLowering(member))
+    if (!member->isAvailableDuringLowering())
       continue;
 
     member->visitAuxiliaryDecls([&](Decl *decl) {

lib/IRGen/GenEnum.cpp

@@ -263,7 +263,7 @@ EnumImplStrategy::getTagIndex(EnumElementDecl *Case) const {
 static void emitResilientTagIndex(IRGenModule &IGM,
                                   const EnumImplStrategy *strategy,
                                   EnumElementDecl *Case) {
-  if (Lowering::shouldSkipLowering(Case))
+  if (!Case->isAvailableDuringLowering())
     return;
 
   auto resilientIdx = strategy->getTagIndex(Case);
@@ -6175,7 +6175,7 @@ EnumImplStrategy::get(TypeConverter &TC, SILType type, EnumDecl *theEnum) {
 
     // For the purposes of memory layout, treat unavailable cases as if they do
     // not have a payload.
-    if (Lowering::shouldSkipLowering(elt)) {
+    if (!elt->isAvailableDuringLowering()) {
       elementsWithNoPayload.push_back({elt, nullptr, nullptr});
       continue;
     }

lib/IRGen/GenReflection.cpp

@@ -853,9 +853,9 @@ class FieldTypeMetadataBuilder : public ReflectionMetadataBuilder {
     if (hasPayload && (decl->isIndirect() || enumDecl->isIndirect()))
       flags.setIsIndirectCase();
 
-    Type interfaceType = Lowering::shouldSkipLowering(decl)
-                             ? nullptr
-                             : decl->getArgumentInterfaceType();
+    Type interfaceType = decl->isAvailableDuringLowering()
+                             ? decl->getArgumentInterfaceType()
+                             : nullptr;
 
     addField(flags, interfaceType, decl->getBaseIdentifier().str());
   }

lib/IRGen/GenStruct.cpp

@@ -1578,7 +1578,7 @@ void IRGenModule::emitStructDecl(StructDecl *st) {
 }
 
 void IRGenModule::maybeEmitOpaqueTypeDecl(OpaqueTypeDecl *opaque) {
-  if (Lowering::shouldSkipLowering(opaque))
+  if (!opaque->isAvailableDuringLowering())
     return;
 
   if (IRGen.Opts.EnableAnonymousContextMangledNames) {

lib/IRGen/IRGenModule.h

@@ -456,7 +456,7 @@ class IRGenerator {
   }
 
   void noteLazyReemissionOfNominalTypeDescriptor(NominalTypeDecl *decl) {
-    assert(!Lowering::shouldSkipLowering(decl));
+    assert(decl->isAvailableDuringLowering());
     LazilyReemittedTypeContextDescriptors.insert(decl);
   }
 
@@ -466,7 +466,7 @@ class IRGenerator {
   }
 
   void noteUseOfMetadataAccessor(NominalTypeDecl *decl) {
-    assert(!Lowering::shouldSkipLowering(decl));
+    assert(decl->isAvailableDuringLowering());
     if (LazyMetadataAccessors.count(decl) == 0) {
       LazyMetadataAccessors.insert(decl);
     }

lib/IRGen/TBDGen.cpp

@@ -414,7 +414,7 @@ void TBDGenVisitor::addSymbol(StringRef name, SymbolSource source,
 }
 
 bool TBDGenVisitor::willVisitDecl(Decl *D) {
-  if (Lowering::shouldSkipLowering(D))
+  if (!D->isAvailableDuringLowering())
     return false;
 
   // A @_silgen_name("...") function without a body only exists to