Rework storage for conformance isolation

Switch over to split caching for the conformance isolation request,
which optimizes for the common case where the conformance is
nonisolated. Also put the explicit global actor TypeExpr* in an
ASTContext side table, so we don't take a pointer's worth of storage
in every conformance.

For that side table, introduce a new "ASTContext::GlobalCache" that's
there only for side tables, so we don't have to go add get/set
operations to ASTContext and recompile the world every time we want to
add a side table like this.

Thanks, Slava!

Author: DougGregor

include/swift/AST/ASTContext.h

@@ -279,6 +279,14 @@ class ASTContext final {
   struct Implementation;
   Implementation &getImpl() const;
 
+  struct GlobalCache;
+
+  /// Retrieve a reference to the global cache within this ASTContext,
+  /// which is a place where we can stash side tables without having to
+  /// recompile the world every time we add a side table. See
+  /// "swift/AST/ASTContextGlobalCache.h"
+  GlobalCache &getGlobalCache() const;
+
   friend ConstraintCheckerArenaRAII;
 
   void operator delete(void *Data) throw();

include/swift/AST/ASTContextGlobalCache.h

@@ -0,0 +1,34 @@
+//===--- ASTContextGlobalCache.h - AST Context Cache ------------*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2020 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines the ASTContext::GlobalCache type. DO NOT include this
+// header from any other header: it should only be included in those .cpp
+// files that need to access the side tables. There are no include guards to
+// force the issue.
+//
+//===----------------------------------------------------------------------===//
+
+#include "swift/AST/ASTContext.h"
+
+namespace swift {
+
+/// A collection of side tables associated with the ASTContext itself, meant
+// as
+struct ASTContext::GlobalCache {
+  /// Mapping from normal protocol conformances to the explicitly-specified
+  /// global actor isolations, e.g., when the conformance was spelled
+  /// `@MainActor P` or similar.
+  llvm::DenseMap<const NormalProtocolConformance *, TypeExpr *>
+      conformanceExplicitGlobalActorIsolation;
+};
+
+} // end namespace 

include/swift/AST/ProtocolConformance.h

@@ -147,7 +147,7 @@ class alignas(1 << DeclAlignInBits) ProtocolConformance
     SWIFT_INLINE_BITFIELD_EMPTY(RootProtocolConformance, ProtocolConformance);
 
     SWIFT_INLINE_BITFIELD_FULL(NormalProtocolConformance, RootProtocolConformance,
-                               1+1+1+
+                               1+1+1+1+1+
                                bitmax(NumProtocolConformanceOptions,8)+
                                bitmax(NumProtocolConformanceStateBits,8)+
                                bitmax(NumConformanceEntryKindBits,8),
@@ -161,6 +161,12 @@ class alignas(1 << DeclAlignInBits) ProtocolConformance
       /// this conformance.
       IsPreconcurrencyEffectful : 1,
 
+      /// Whether the computed actor isolation is nonisolated.
+      IsComputedNonisolated : 1,
+
+      /// Whether there is an explicit global actor specified for this
+      /// conformance.
+      HasExplicitGlobalActor : 1,
       : NumPadBits,
 
       /// Options.
@@ -555,9 +561,6 @@ class NormalProtocolConformance : public RootProtocolConformance,
   /// NominalTypeDecl that declared the conformance.
   DeclContext *Context;
 
-  /// The global actor isolation for this conformance, if there is one.
-  TypeExpr *globalActorIsolation = nullptr;
-
   NormalProtocolConformance *ImplyingConformance = nullptr;
 
   /// The mapping of individual requirements in the protocol over to
@@ -582,8 +585,19 @@ class NormalProtocolConformance : public RootProtocolConformance,
 
   void resolveLazyInfo() const;
 
-  /// Set up global actor isolation for this conformance.
-  void setGlobalActorIsolation(Type globalActorType);
+  /// Retrieve the explicitly-specified global actor isolation.
+  TypeExpr *getExplicitGlobalActorIsolation() const;
+
+  // Record the explicitly-specified global actor isolation.
+  void setExplicitGlobalActorIsolation(TypeExpr *typeExpr);
+
+  bool isComputedNonisolated() const {
+    return Bits.NormalProtocolConformance.IsComputedNonisolated;
+  }
+
+  void setComputedNonnisolated(bool value = true) {
+    Bits.NormalProtocolConformance.IsComputedNonisolated = value;
+  }
 
 public:
   NormalProtocolConformance(Type conformingType, ProtocolDecl *protocol,
@@ -608,7 +622,9 @@ class NormalProtocolConformance : public RootProtocolConformance,
     Bits.NormalProtocolConformance.HasComputedAssociatedConformances = false;
     Bits.NormalProtocolConformance.SourceKind =
         unsigned(ConformanceEntryKind::Explicit);
-    globalActorIsolation = options.getGlobalActorIsolationType();
+    Bits.NormalProtocolConformance.IsComputedNonisolated = false;
+    Bits.NormalProtocolConformance.HasExplicitGlobalActor = false;
+    setExplicitGlobalActorIsolation(options.getGlobalActorIsolationType());
   }
 
   /// Get the protocol being conformed to.
@@ -651,7 +667,7 @@ class NormalProtocolConformance : public RootProtocolConformance,
 
   ProtocolConformanceOptions getOptions() const {
     return ProtocolConformanceOptions(Bits.NormalProtocolConformance.Options,
-                                      globalActorIsolation);
+                                      getExplicitGlobalActorIsolation());
   }
 
   /// Whether this is an "unchecked" conformance.

include/swift/AST/TypeCheckRequests.h

@@ -478,7 +478,8 @@ class ConformanceHasEffectRequest :
 class ConformanceIsolationRequest :
     public SimpleRequest<ConformanceIsolationRequest,
                          ActorIsolation(ProtocolConformance *),
-                         RequestFlags::Cached> {
+                         RequestFlags::SeparatelyCached |
+                         RequestFlags::SplitCached> {
 public:
   using SimpleRequest::SimpleRequest;
 
@@ -490,8 +491,10 @@ class ConformanceIsolationRequest :
   evaluate(Evaluator &evaluator, ProtocolConformance *conformance) const;
 
 public:
-  // Caching.
-  bool isCached() const;
+  // Separate caching.
+  bool isCached() const { return true; }
+  std::optional<ActorIsolation> getCachedResult() const;
+  void cacheResult(ActorIsolation result) const;
 };
 
 /// Determine whether the given declaration is 'final'.

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -408,7 +408,8 @@ SWIFT_REQUEST(TypeChecker, ConformanceHasEffectRequest,
               bool(EffectKind, ProtocolConformanceRef),
               Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, ConformanceIsolationRequest,
-              ActorIsolation(ProtocolConformance *), Cached,
+              ActorIsolation(ProtocolConformance *),
+              SeparatelyCached | SplitCached,
               NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, ResolveTypeRequest,
               Type (const TypeResolution *, TypeRepr *, GenericParamList *),

lib/AST/ASTContext.cpp

@@ -18,6 +18,7 @@
 #include "ClangTypeConverter.h"
 #include "ForeignRepresentationInfo.h"
 #include "SubstitutionMapStorage.h"
+#include "swift/AST/ASTContextGlobalCache.h"
 #include "swift/ABI/MetadataValues.h"
 #include "swift/AST/AvailabilityContextStorage.h"
 #include "swift/AST/ClangModuleLoader.h"
@@ -270,6 +271,9 @@ struct ASTContext::Implementation {
 
   llvm::BumpPtrAllocator Allocator; // used in later initializations
 
+  /// The global cache of side tables for random things.
+  GlobalCache globalCache;
+
   /// The set of cleanups to be called when the ASTContext is destroyed.
   std::vector<std::function<void(void)>> Cleanups;
 
@@ -747,6 +751,10 @@ inline ASTContext::Implementation &ASTContext::getImpl() const {
   return *reinterpret_cast<Implementation*>(pointer + offset);
 }
 
+ASTContext::GlobalCache &ASTContext::getGlobalCache() const {
+  return getImpl().globalCache;
+}
+
 void ASTContext::operator delete(void *Data) throw() {
   AlignedFree(Data);
 }

lib/AST/ProtocolConformance.cpp

@@ -17,6 +17,7 @@
 #include "swift/AST/ProtocolConformance.h"
 #include "ConformanceLookupTable.h"
 #include "swift/AST/ASTContext.h"
+#include "swift/AST/ASTContextGlobalCache.h"
 #include "swift/AST/ConformanceLookup.h"
 #include "swift/AST/Decl.h"
 #include "swift/AST/DistributedDecl.h"
@@ -474,24 +475,33 @@ void NormalProtocolConformance::resolveLazyInfo() const {
   loader->finishNormalConformance(mutableThis, LoaderContextData);
 }
 
-void NormalProtocolConformance::setGlobalActorIsolation(Type globalActorType) {
-  ASTContext &ctx = getDeclContext()->getASTContext();
-  if (globalActorIsolation)
-    globalActorIsolation->setType(MetatypeType::get(globalActorType));
-  else
-    globalActorIsolation = TypeExpr::createImplicit(globalActorType, ctx);
-
-  Bits.NormalProtocolConformance.Options |=
-      static_cast<unsigned>(ProtocolConformanceFlags::GlobalActorIsolated);
-}
-
 void NormalProtocolConformance::setLazyLoader(LazyConformanceLoader *loader,
                                               uint64_t contextData) {
   assert(!Loader && "already has a loader");
   Loader = loader;
   LoaderContextData = contextData;
 }
 
+TypeExpr *NormalProtocolConformance::getExplicitGlobalActorIsolation() const {
+  if (!Bits.NormalProtocolConformance.HasExplicitGlobalActor)
+    return nullptr;
+
+  ASTContext &ctx = getDeclContext()->getASTContext();
+  return ctx.getGlobalCache().conformanceExplicitGlobalActorIsolation[this];
+}
+
+void
+NormalProtocolConformance::setExplicitGlobalActorIsolation(TypeExpr *typeExpr) {
+  if (!typeExpr) {
+    Bits.NormalProtocolConformance.HasExplicitGlobalActor = false;
+    return;
+  }
+
+  Bits.NormalProtocolConformance.HasExplicitGlobalActor = true;
+  ASTContext &ctx = getDeclContext()->getASTContext();
+  ctx.getGlobalCache().conformanceExplicitGlobalActorIsolation[this] = typeExpr;
+}
+
 namespace {
   class PrettyStackTraceRequirement : public llvm::PrettyStackTraceEntry {
     const char *Action;

lib/AST/TypeCheckRequests.cpp

@@ -1371,33 +1371,38 @@ void AssociatedConformanceRequest::cacheResult(
 //----------------------------------------------------------------------------//
 // ConformanceIsolationRequest computation.
 //----------------------------------------------------------------------------//
-bool ConformanceIsolationRequest::isCached() const {
+std::optional<ActorIsolation>
+ConformanceIsolationRequest::getCachedResult() const {
   // We only want to cache for global-actor-isolated conformances. For
   // everything else, which is nearly every conformance, this request quickly
   // returns "nonisolated" so there is no point in caching it.
   auto conformance = std::get<0>(getStorage());
   auto rootNormal =
       dyn_cast<NormalProtocolConformance>(conformance->getRootConformance());
   if (!rootNormal)
-    return false;
+    return ActorIsolation::forNonisolated(false);
 
-  // We know this is nonisolated.
-  if (rootNormal->getOptions().contains(ProtocolConformanceFlags::Nonisolated))
-    return false;
+  // Was actor isolation non-isolated?
+  if (rootNormal->isComputedNonisolated())
+    return ActorIsolation::forNonisolated(false);
 
-  // Explicit global actor isolation needs to be checked.
-  if (rootNormal->globalActorIsolation)
-    return true;
+  ASTContext &ctx = rootNormal->getDeclContext()->getASTContext();
+  return ctx.evaluator.getCachedNonEmptyOutput(*this);
+}
 
-  // If we might infer conformance isolation, then we should cache the result.
-  auto dc = rootNormal->getDeclContext();
-  auto nominal = dc->getSelfNominalTypeDecl();
-  if (nominal &&
-      ((isa<ClassDecl>(nominal) && cast<ClassDecl>(nominal)->isActor()) ||
-       nominal->getSemanticAttrs().hasAttribute<NonisolatedAttr>()))
-    return false;
+void ConformanceIsolationRequest::cacheResult(ActorIsolation result) const {
+  auto conformance = std::get<0>(getStorage());
+  auto rootNormal =
+      cast<NormalProtocolConformance>(conformance->getRootConformance());
+
+  // Common case: conformance is nonisolated.
+  if (result.isNonisolated()) {
+    rootNormal->setComputedNonnisolated();
+    return;
+  }
 
-  return true;
+  ASTContext &ctx = rootNormal->getDeclContext()->getASTContext();
+  ctx.evaluator.cacheNonEmptyOutput(*this, std::move(result));
 }
 
 //----------------------------------------------------------------------------//

lib/Sema/TypeCheckConcurrency.cpp

@@ -7890,7 +7890,7 @@ ConformanceIsolationRequest::evaluate(Evaluator &evaluator, ProtocolConformance
 
   // If there is an explicitly-specified global actor on the isolation,
   // resolve it and report it.
-  if (auto globalActorTypeExpr = rootNormal->globalActorIsolation) {
+  if (auto globalActorTypeExpr = rootNormal->getExplicitGlobalActorIsolation()) {
     // If we don't already have a resolved global actor type, resolve it now.
     Type globalActorType = globalActorTypeExpr->getInstanceType();
     if (!globalActorType) {
@@ -7925,7 +7925,6 @@ ConformanceIsolationRequest::evaluate(Evaluator &evaluator, ProtocolConformance
       nominal) {
     auto nominalIsolation = getActorIsolation(nominal);
     if (nominalIsolation.isMainActor()) {
-      rootNormal->setGlobalActorIsolation(nominalIsolation.getGlobalActor());
       return nominalIsolation;
     }
   }