Merge remote-tracking branch 'origin/main' into rebranch

Author: swift-ci

include/swift/AST/AvailabilityDomain.h

@@ -153,8 +153,7 @@ class AvailabilityDomain final {
 
   /// If `decl` represents an availability domain, returns the corresponding
   /// `AvailabilityDomain` value. Otherwise, returns `std::nullopt`.
-  static std::optional<AvailabilityDomain> forCustom(ValueDecl *decl,
-                                                     const ASTContext &ctx);
+  static std::optional<AvailabilityDomain> forCustom(ValueDecl *decl);
 
   static AvailabilityDomain forCustom(const CustomAvailabilityDomain *domain) {
     return AvailabilityDomain(domain);

include/swift/AST/Decl.h

@@ -2925,6 +2925,10 @@ class ValueDecl : public Decl {
 
     /// Whether we've evaluated the ApplyAccessNoteRequest.
     unsigned accessNoteApplied : 1;
+
+    /// Whether the AvailabilityDomainForDeclRequest request was evaluated and
+    /// yielded no availability domain.
+    unsigned noAvailabilityDomain : 1;
   } LazySemanticInfo = { };
 
   friend class DynamicallyReplacedDeclRequest;
@@ -2938,6 +2942,7 @@ class ValueDecl : public Decl {
   friend class ActorIsolationRequest;
   friend class OpaqueResultTypeRequest;
   friend class ApplyAccessNoteRequest;
+  friend class AvailabilityDomainForDeclRequest;
 
   friend class Decl;
   SourceLoc getLocFromSource() const { return NameLoc; }

include/swift/AST/TypeCheckRequests.h

@@ -5424,6 +5424,26 @@ class ModuleHasTypeCheckerPerformanceHacksEnabledRequest
   bool isCached() const { return true; }
 };
 
+class AvailabilityDomainForDeclRequest
+    : public SimpleRequest<AvailabilityDomainForDeclRequest,
+                           std::optional<AvailabilityDomain>(ValueDecl *),
+                           RequestFlags::Cached | RequestFlags::SplitCached> {
+public:
+  using SimpleRequest::SimpleRequest;
+
+private:
+  friend SimpleRequest;
+
+  // Evaluation.
+  std::optional<AvailabilityDomain> evaluate(Evaluator &evaluator,
+                                             ValueDecl *decl) const;
+
+public:
+  bool isCached() const { return true; }
+  std::optional<std::optional<AvailabilityDomain>> getCachedResult() const;
+  void cacheResult(std::optional<AvailabilityDomain> domain) const;
+};
+
 #define SWIFT_TYPEID_ZONE TypeChecker
 #define SWIFT_TYPEID_HEADER "swift/AST/TypeCheckerTypeIDZone.def"
 #include "swift/Basic/DefineTypeIDZone.h"

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -648,3 +648,7 @@ SWIFT_REQUEST(TypeChecker, BindExtensionsForIDEInspectionRequest,
 SWIFT_REQUEST(TypeChecker, ModuleHasTypeCheckerPerformanceHacksEnabledRequest,
               bool(const ModuleDecl *),
               Cached, NoLocationInfo)
+
+SWIFT_REQUEST(TypeChecker, AvailabilityDomainForDeclRequest,
+              std::optional<AvailabilityDomain>(ValueDecl *),
+              Cached | SplitCached, NoLocationInfo)

include/swift/Basic/Features.def

@@ -502,7 +502,6 @@ EXPERIMENTAL_FEATURE(CoroutineAccessorsUnwindOnCallerError, false)
 
 EXPERIMENTAL_FEATURE(AddressableParameters, true)
 SUPPRESSIBLE_EXPERIMENTAL_FEATURE(AddressableTypes, true)
-EXPERIMENTAL_FEATURE(AddressableInterop, true)
 
 /// Allow custom availability domains to be defined and referenced.
 EXPERIMENTAL_FEATURE(CustomAvailability, true)

include/swift/Runtime/Concurrent.h

@@ -593,51 +593,6 @@ struct ConcurrentReadableHashMap {
     }
   }
 
-  // Common implementation for `getOrInsert` and `GetOrInsertManyScope`
-  template <class KeyTy, typename Call>
-  void getOrInsertExternallyLocked(KeyTy key, const Call &call) {
-    auto indices = IndexStorage{Indices.load(std::memory_order_relaxed)};
-    auto indicesCapacityLog2 = indices.getCapacityLog2();
-    auto elementCount = ElementCount.load(std::memory_order_relaxed);
-    auto *elements = Elements.load(std::memory_order_relaxed);
-    auto *elementsPtr = elements ? elements->data() : nullptr;
-
-    
-    auto found = this->find(key, indices, elementCount, elementsPtr);
-    if (found.first) {
-      call(found.first, false);
-      return;
-    }
-
-    auto indicesCapacity = 1UL << indicesCapacityLog2;
-
-    // The number of slots in use is elementCount + 1, since the capacity also
-    // takes a slot.
-    auto emptyCount = indicesCapacity - (elementCount + 1);
-    auto proportion = indicesCapacity / emptyCount;
-    if (proportion >= ResizeProportion) {
-      indices = resize(indices, indicesCapacityLog2, elementsPtr);
-      found = find(key, indices, elementCount, elementsPtr);
-      assert(!found.first && "Shouldn't suddenly find the key after rehashing");
-    }
-
-    if (!elements || elementCount >= elements->Capacity) {
-      elements = resize(elements, elementCount);
-    }
-    auto *element = &elements->data()[elementCount];
-
-    // Order matters: fill out the element, then update the count,
-    // then update the index.
-    bool keep = call(element, true);
-    if (keep) {
-      assert(hash_value(key) == hash_value(*element) &&
-            "Element must have the same hash code as its key.");
-      ElementCount.store(elementCount + 1, std::memory_order_release);
-      indices.storeIndexAt(&Indices, elementCount + 1, found.second,
-                          std::memory_order_release);
-    }
-  }
-
 public:
   // Implicitly trivial constructor/destructor.
   ConcurrentReadableHashMap() = default;
@@ -729,48 +684,6 @@ struct ConcurrentReadableHashMap {
     return Snapshot(this, indices, elementsPtr, elementCount);
   }
 
-  /// A wrapper that allows performing several `getOrInsert` operations under
-  /// the same lock.
-  class GetOrInsertManyScope {
-    GetOrInsertManyScope() = delete;
-    GetOrInsertManyScope(const GetOrInsertManyScope &) = delete;
-    GetOrInsertManyScope &operator=(const GetOrInsertManyScope &) = delete;
-    GetOrInsertManyScope(GetOrInsertManyScope &&) = delete;
-    GetOrInsertManyScope &operator=(GetOrInsertManyScope &&) = delete;
-
-    ConcurrentReadableHashMap &Map;
-
-  public:
-    GetOrInsertManyScope(ConcurrentReadableHashMap &map) : Map(map) {
-      Map.WriterLock.lock();
-    }
-
-    ~GetOrInsertManyScope() {
-      Map.deallocateFreeListIfSafe();
-      Map.WriterLock.unlock();
-    }
-
-    /// Get an element by key, or insert a new element for that key if one is
-    /// not already present. Invoke `call` with the pointer to the element.
-    ///
-    /// `call` is passed the following parameters:
-    ///   - `element`: the pointer to the element corresponding to `key`
-    ///   - `created`: true if the element is newly created, false if it already
-    ///                exists
-    /// `call` returns a `bool`. When `created` is `true`, the return values
-    /// mean:
-    ///   - `true` the new entry is to be kept
-    ///   - `false` indicates that the new entry is discarded
-    /// If the new entry is kept, then the new element MUST be initialized, and
-    /// have a hash value that matches the hash value of `key`.
-    ///
-    /// The return value is ignored when `created` is `false`.
-    template <class KeyTy, typename Call>
-    void getOrInsert(KeyTy key, const Call &call) {
-      Map.getOrInsertExternallyLocked(key, call);
-    }
-  };
-
   /// Get an element by key, or insert a new element for that key if one is not
   /// already present. Invoke `call` with the pointer to the element. BEWARE:
   /// `call` is invoked with the internal writer lock held, keep work to a
@@ -790,7 +703,48 @@ struct ConcurrentReadableHashMap {
   template <class KeyTy, typename Call>
   void getOrInsert(KeyTy key, const Call &call) {
     typename MutexTy::ScopedLock guard(WriterLock);
-    getOrInsertExternallyLocked(key, call);
+
+    auto indices = IndexStorage{Indices.load(std::memory_order_relaxed)};
+    auto indicesCapacityLog2 = indices.getCapacityLog2();
+    auto elementCount = ElementCount.load(std::memory_order_relaxed);
+    auto *elements = Elements.load(std::memory_order_relaxed);
+    auto *elementsPtr = elements ? elements->data() : nullptr;
+
+    auto found = this->find(key, indices, elementCount, elementsPtr);
+    if (found.first) {
+      call(found.first, false);
+      deallocateFreeListIfSafe();
+      return;
+    }
+
+    auto indicesCapacity = 1UL << indicesCapacityLog2;
+
+    // The number of slots in use is elementCount + 1, since the capacity also
+    // takes a slot.
+    auto emptyCount = indicesCapacity - (elementCount + 1);
+    auto proportion = indicesCapacity / emptyCount;
+    if (proportion >= ResizeProportion) {
+      indices = resize(indices, indicesCapacityLog2, elementsPtr);
+      found = find(key, indices, elementCount, elementsPtr);
+      assert(!found.first && "Shouldn't suddenly find the key after rehashing");
+    }
+
+    if (!elements || elementCount >= elements->Capacity) {
+      elements = resize(elements, elementCount);
+    }
+    auto *element = &elements->data()[elementCount];
+
+    // Order matters: fill out the element, then update the count,
+    // then update the index.
+    bool keep = call(element, true);
+    if (keep) {
+      assert(hash_value(key) == hash_value(*element) &&
+             "Element must have the same hash code as its key.");
+      ElementCount.store(elementCount + 1, std::memory_order_release);
+      indices.storeIndexAt(&Indices, elementCount + 1, found.second,
+                           std::memory_order_release);
+    }
+
     deallocateFreeListIfSafe();
   }
 

lib/AST/AvailabilityDomain.cpp

@@ -39,7 +39,7 @@ getCustomDomainKind(clang::FeatureAvailKind featureAvailKind) {
 }
 
 static const CustomAvailabilityDomain *
-customDomainForClangDecl(ValueDecl *decl, const ASTContext &ctx) {
+customDomainForClangDecl(ValueDecl *decl) {
   auto *clangDecl = decl->getClangDecl();
   ASSERT(clangDecl);
 
@@ -57,6 +57,7 @@ customDomainForClangDecl(ValueDecl *decl, const ASTContext &ctx) {
   if (featureInfo.second.Kind == clang::FeatureAvailKind::None)
     return nullptr;
 
+  auto &ctx = decl->getASTContext();
   FuncDecl *predicate = nullptr;
   if (featureInfo.second.Kind == clang::FeatureAvailKind::Dynamic)
     predicate =
@@ -68,12 +69,13 @@ customDomainForClangDecl(ValueDecl *decl, const ASTContext &ctx) {
 }
 
 std::optional<AvailabilityDomain>
-AvailabilityDomain::forCustom(ValueDecl *decl, const ASTContext &ctx) {
+AvailabilityDomainForDeclRequest::evaluate(Evaluator &evaluator,
+                                           ValueDecl *decl) const {
   if (!decl)
     return std::nullopt;
 
   if (decl->hasClangNode()) {
-    if (auto *customDomain = customDomainForClangDecl(decl, ctx))
+    if (auto *customDomain = customDomainForClangDecl(decl))
       return AvailabilityDomain::forCustom(customDomain);
   } else {
     // FIXME: [availability] Handle Swift availability domains decls.
@@ -82,6 +84,15 @@ AvailabilityDomain::forCustom(ValueDecl *decl, const ASTContext &ctx) {
   return std::nullopt;
 }
 
+std::optional<AvailabilityDomain>
+AvailabilityDomain::forCustom(ValueDecl *decl) {
+  if (!decl)
+    return std::nullopt;
+
+  return evaluateOrDefault(decl->getASTContext().evaluator,
+                           AvailabilityDomainForDeclRequest{decl}, {});
+}
+
 std::optional<AvailabilityDomain>
 AvailabilityDomain::builtinDomainForString(StringRef string,
                                            const DeclContext *declContext) {

lib/AST/FeatureSet.cpp

@@ -270,7 +270,6 @@ static bool usesFeatureAddressableTypes(Decl *d) {
   return false;
 }
 
-UNINTERESTING_FEATURE(AddressableInterop)
 UNINTERESTING_FEATURE(IsolatedAny2)
 UNINTERESTING_FEATURE(GlobalActorIsolatedTypesUsability)
 UNINTERESTING_FEATURE(ObjCImplementation)

lib/AST/TypeCheckRequests.cpp

@@ -2837,3 +2837,28 @@ void SemanticAvailableAttrRequest::cacheResult(
   if (!value)
     attr->setInvalid();
 }
+
+//----------------------------------------------------------------------------//
+// AvailabilityDomainForDeclRequest computation.
+//----------------------------------------------------------------------------//
+
+std::optional<std::optional<AvailabilityDomain>>
+AvailabilityDomainForDeclRequest::getCachedResult() const {
+  auto decl = std::get<0>(getStorage());
+
+  if (decl->LazySemanticInfo.noAvailabilityDomain)
+    return std::optional<AvailabilityDomain>();
+  return decl->getASTContext().evaluator.getCachedNonEmptyOutput(*this);
+}
+
+void AvailabilityDomainForDeclRequest::cacheResult(
+    std::optional<AvailabilityDomain> domain) const {
+  auto decl = std::get<0>(getStorage());
+
+  if (!domain) {
+    decl->LazySemanticInfo.noAvailabilityDomain = 1;
+    return;
+  }
+
+  decl->getASTContext().evaluator.cacheNonEmptyOutput(*this, std::move(domain));
+}

lib/ClangImporter/ClangImporter.cpp

@@ -4087,7 +4087,7 @@ void ClangModuleUnit::lookupAvailabilityDomains(
   if (!imported)
     return;
 
-  auto customDomain = AvailabilityDomain::forCustom(imported, ctx);
+  auto customDomain = AvailabilityDomain::forCustom(imported);
   ASSERT(customDomain);
   results.push_back(*customDomain);
 }