Merge pull request #67761 from tshortli/ast-unavailable-decl-queries

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

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