AST: GenericContexts store a GenericSignature instead of a GenericEnvironment

slavapestov · slavapestov · commit 0405ab5ffc6a · 2019-09-06T17:16:04.000-04:00
This eliminates the entire 'lazy generic environment' concept;
essentially, all generic environments are now lazy, and since
each signature has exactly one environment, their construction
no longer needs to be co-ordinated with deserialization.
diff --git a/include/swift/AST/ASTContext.h b/include/swift/AST/ASTContext.h
@@ -68,7 +68,6 @@ namespace swift {
   class InFlightDiagnostic;
   class IterableDeclContext;
   class LazyContextData;
-  class LazyGenericContextData;
   class LazyIterableDeclContextData;
   class LazyMemberLoader;
   class LazyResolver;
@@ -817,15 +816,6 @@ class ASTContext final {
   LazyContextData *getOrCreateLazyContextData(const DeclContext *decl,
                                               LazyMemberLoader *lazyLoader);
 
-  /// Get the lazy function data for the given generic context.
-  ///
-  /// \param lazyLoader If non-null, the lazy loader to use when creating the
-  /// function data. The pointer must either be null or be consistent
-  /// across all calls for the same \p func.
-  LazyGenericContextData *getOrCreateLazyGenericContextData(
-                                              const GenericContext *dc,
-                                              LazyMemberLoader *lazyLoader);
-
   /// Get the lazy iterable context for the given iterable declaration context.
   ///
   /// \param lazyLoader If non-null, the lazy loader to use when creating the
diff --git a/include/swift/AST/Decl.h b/include/swift/AST/Decl.h
@@ -1482,18 +1482,11 @@ class alignas(8) _GenericContext {
   /// moves the trailing where clause into the generic parameter list.
   TrailingWhereClause *TrailingWhere = nullptr;
 
-  /// The generic signature or environment of this declaration.
-  ///
-  /// When this declaration stores only a signature, the generic
-  /// environment will be lazily loaded.
-  mutable llvm::PointerUnion<GenericSignature *, GenericEnvironment *>
-    GenericSigOrEnv;
+  /// The generic signature of this declaration.
+  GenericSignature *GenericSig = nullptr;
 };
 
 class GenericContext : private _GenericContext, public DeclContext {
-  /// Lazily populate the generic environment.
-  GenericEnvironment *getLazyGenericEnvironmentSlow() const;
-
 protected:
   GenericContext(DeclContextKind Kind, DeclContext *Parent)
     : _GenericContext(), DeclContext(Kind, Parent) { }
@@ -1542,18 +1535,12 @@ class GenericContext : private _GenericContext, public DeclContext {
   /// Retrieve the generic requirements.
   ArrayRef<Requirement> getGenericRequirements() const;
 
-  /// Set a lazy generic environment.
-  void setLazyGenericEnvironment(LazyMemberLoader *lazyLoader,
-                                 GenericSignature *genericSig,
-                                 uint64_t genericEnvData);
-
-  /// Whether this generic context has a lazily-created generic environment
-  /// that has not yet been constructed.
-  bool hasLazyGenericEnvironment() const;
-
   /// Set the generic context of this context.
   void setGenericEnvironment(GenericEnvironment *genericEnv);
 
+  /// Set the generic signature of this context.
+  void setGenericSignature(GenericSignature *genericSig);
+
   /// Retrieve the position of any where clause for this context's
   /// generic parameters.
   SourceRange getGenericTrailingWhereClauseSourceRange() const;
diff --git a/include/swift/AST/DeclContext.h b/include/swift/AST/DeclContext.h
@@ -360,10 +360,6 @@ class alignas(1 << DeclContextAlignInBits) DeclContext {
   /// of its parents.
   GenericEnvironment *getGenericEnvironmentOfContext() const;
 
-  /// Whether the context has a generic environment that will be constructed
-  /// on first access (but has not yet been constructed).
-  bool contextHasLazyGenericEnvironment() const;
-
   /// Map an interface type to a contextual type within this context.
   Type mapTypeIntoContext(Type type) const;
 
diff --git a/include/swift/AST/LazyResolver.h b/include/swift/AST/LazyResolver.h
@@ -85,15 +85,8 @@ class LazyContextData {
   LazyMemberLoader *loader;
 };
 
-/// Context data for generic contexts.
-class LazyGenericContextData : public LazyContextData {
-public:
-  /// The context data used for loading the generic environment.
-  uint64_t genericEnvData = 0;
-};
-
 /// Context data for iterable decl contexts.
-class LazyIterableDeclContextData : public LazyGenericContextData {
+class LazyIterableDeclContextData : public LazyContextData {
 public:
   /// The context data used for loading all of the members of the iterable
   /// context.
@@ -145,10 +138,6 @@ class alignas(void*) LazyMemberLoader {
   virtual Type loadAssociatedTypeDefault(const AssociatedTypeDecl *ATD,
                                          uint64_t contextData) = 0;
 
-  /// Returns the generic environment.
-  virtual GenericEnvironment *loadGenericEnvironment(const DeclContext *decl,
-                                                     uint64_t contextData) = 0;
-
   /// Loads the requirement signature for a protocol.
   virtual void
   loadRequirementSignature(const ProtocolDecl *proto, uint64_t contextData,
diff --git a/include/swift/Basic/Statistics.def b/include/swift/Basic/Statistics.def
@@ -249,12 +249,6 @@ FRONTEND_STATISTIC(Sema, NumFunctionsTypechecked)
 /// amount of work the GSB does analyzing type signatures.
 FRONTEND_STATISTIC(Sema, NumGenericSignatureBuilders)
 
-/// Number of lazy generic environments registered.
-FRONTEND_STATISTIC(Sema, NumLazyGenericEnvironments)
-
-/// Number of lazy generic environments deserialized.
-FRONTEND_STATISTIC(Sema, NumLazyGenericEnvironmentsLoaded)
-
 /// Number of lazy requirement signatures registered.
 FRONTEND_STATISTIC(Sema, NumLazyRequirementSignatures)
 
diff --git a/lib/AST/ASTContext.cpp b/lib/AST/ASTContext.cpp
@@ -1970,10 +1970,10 @@ LazyContextData *ASTContext::getOrCreateLazyContextData(
   assert(lazyLoader && "Queried lazy data for non-lazy iterable context");
   if (isa<ProtocolDecl>(dc))
     entry = Allocate<LazyProtocolData>();
-  else if (isa<NominalTypeDecl>(dc) || isa<ExtensionDecl>(dc))
+  else {
+    assert(isa<NominalTypeDecl>(dc) || isa<ExtensionDecl>(dc));
     entry = Allocate<LazyIterableDeclContextData>();
-  else
-    entry = Allocate<LazyGenericContextData>();
+  }
 
   entry->loader = lazyLoader;
   return entry;
@@ -1992,13 +1992,6 @@ LazyIterableDeclContextData *ASTContext::getOrCreateLazyIterableContextData(
                                                                    lazyLoader);
 }
 
-LazyGenericContextData *ASTContext::getOrCreateLazyGenericContextData(
-                                               const GenericContext *dc,
-                                               LazyMemberLoader *lazyLoader) {
-  return (LazyGenericContextData *)getOrCreateLazyContextData(dc,
-                                                              lazyLoader);
-}
-
 bool ASTContext::hasDelayedConformanceErrors() const {
   for (const auto &entry : getImpl().DelayedConformanceDiags) {
     auto &diagnostics = entry.getSecond();
diff --git a/lib/AST/Decl.cpp b/lib/AST/Decl.cpp
@@ -66,10 +66,6 @@ using namespace swift;
 
 #define DEBUG_TYPE "Serialization"
 
-STATISTIC(NumLazyGenericEnvironments,
-          "# of lazily-deserialized generic environments known");
-STATISTIC(NumLazyGenericEnvironmentsLoaded,
-          "# of lazily-deserialized generic environments loaded");
 STATISTIC(NumLazyRequirementSignatures,
           "# of lazily-deserialized requirement signatures known");
 
@@ -829,11 +825,8 @@ void GenericContext::setGenericParams(GenericParamList *params) {
 }
 
 GenericSignature *GenericContext::getGenericSignature() const {
-  if (auto genericEnv = GenericSigOrEnv.dyn_cast<GenericEnvironment *>())
-    return genericEnv->getGenericSignature();
-
-  if (auto genericSig = GenericSigOrEnv.dyn_cast<GenericSignature *>())
-    return genericSig;
+  if (GenericSig)
+    return GenericSig;
 
   // The signature of a Protocol is trivial (Self: TheProtocol) so let's compute
   // it.
@@ -842,81 +835,28 @@ GenericSignature *GenericContext::getGenericSignature() const {
     auto self = PD->getSelfInterfaceType()->castTo<GenericTypeParamType>();
     auto req =
         Requirement(RequirementKind::Conformance, self, PD->getDeclaredType());
-    auto *genericSig = GenericSignature::get({self}, {req});
-
-    // Save it for next time.
-    const_cast<GenericContext *>(this)->GenericSigOrEnv = genericSig;
-    return genericSig;
+    const_cast<GenericContext *>(this)->GenericSig
+      = GenericSignature::get({self}, {req});
+    return GenericSig;
   }
 
   return nullptr;
 }
 
 GenericEnvironment *GenericContext::getGenericEnvironment() const {
-  // Fast case: we already have a generic environment.
-  if (auto genericEnv = GenericSigOrEnv.dyn_cast<GenericEnvironment *>())
-    return genericEnv;
-
-  // If we only have a generic signature, build the generic environment.
-  if (GenericSigOrEnv.dyn_cast<GenericSignature *>() || isa<ProtocolDecl>(this))
-    return getLazyGenericEnvironmentSlow();
+  if (auto *genericSig = getGenericSignature())
+    return genericSig->getGenericEnvironment();
 
   return nullptr;
 }
 
-bool GenericContext::hasLazyGenericEnvironment() const {
-  return GenericSigOrEnv.dyn_cast<GenericSignature *>() != nullptr;
-}
-
 void GenericContext::setGenericEnvironment(GenericEnvironment *genericEnv) {
-  assert((GenericSigOrEnv.isNull() ||
-          getGenericSignature()->getCanonicalSignature() ==
-            genericEnv->getGenericSignature()->getCanonicalSignature()) &&
-         "set a generic environment with a different generic signature");
-  this->GenericSigOrEnv = genericEnv;
+  setGenericSignature(genericEnv ? genericEnv->getGenericSignature() : nullptr);
 }
 
-GenericEnvironment *
-GenericContext::getLazyGenericEnvironmentSlow() const {
-  assert(GenericSigOrEnv.is<GenericSignature *>() &&
-         "not a lazily computed generic environment");
-
-  if (auto PD = dyn_cast<ProtocolDecl>(this)) {
-    // The signature of a Protocol is trivial (Self: TheProtocol) so let's
-    // compute it directly.
-    auto *genericEnv = getGenericSignature()->getGenericEnvironment();
-    const_cast<GenericContext *>(this)->setGenericEnvironment(genericEnv);
-    return genericEnv;
-  }
-
-  auto contextData = getASTContext().getOrCreateLazyGenericContextData(
-    this, nullptr);
-  auto *genericEnv = contextData->loader->loadGenericEnvironment(
-    this, contextData->genericEnvData);
-
-  const_cast<GenericContext *>(this)->setGenericEnvironment(genericEnv);
-  ++NumLazyGenericEnvironmentsLoaded;
-  // FIXME: (transitional) increment the redundant "always-on" counter.
-  if (getASTContext().Stats)
-    getASTContext().Stats->getFrontendCounters().NumLazyGenericEnvironmentsLoaded++;
-  return genericEnv;
-}
-
-void GenericContext::setLazyGenericEnvironment(LazyMemberLoader *lazyLoader,
-                                               GenericSignature *genericSig,
-                                               uint64_t genericEnvData) {
-  assert(GenericSigOrEnv.isNull() && "already have a generic signature");
-  GenericSigOrEnv = genericSig;
-
-  auto contextData =
-    getASTContext().getOrCreateLazyGenericContextData(this, lazyLoader);
-  contextData->genericEnvData = genericEnvData;
-
-  ++NumLazyGenericEnvironments;
-  // FIXME: (transitional) increment the redundant "always-on" counter.
-  if (getASTContext().Stats)
-    getASTContext().Stats->getFrontendCounters().NumLazyGenericEnvironments++;
-
+void GenericContext::setGenericSignature(GenericSignature *genericSig) {
+  assert(GenericSig == nullptr && "Generic signature cannot be changed");
+  this->GenericSig = genericSig;
 }
 
 SourceRange GenericContext::getGenericTrailingWhereClauseSourceRange() const {
diff --git a/lib/AST/DeclContext.cpp b/lib/AST/DeclContext.cpp
@@ -175,17 +175,6 @@ GenericEnvironment *DeclContext::getGenericEnvironmentOfContext() const {
   return nullptr;
 }
 
-bool DeclContext::contextHasLazyGenericEnvironment() const {
-  auto dc = this;
-  do {
-    if (auto decl = dc->getAsDecl())
-      if (auto GC = decl->getAsGenericContext())
-        return GC->hasLazyGenericEnvironment();
-  } while ((dc = dc->getParent()));
-
-  return false;
-}
-
 Type DeclContext::mapTypeIntoContext(Type type) const {
   return GenericEnvironment::mapTypeIntoContext(
       getGenericEnvironmentOfContext(), type);
diff --git a/lib/ClangImporter/ImporterImpl.h b/lib/ClangImporter/ImporterImpl.h
@@ -1242,12 +1242,6 @@ class LLVM_LIBRARY_VISIBILITY ClangImporter::Implementation
                                  uint64_t contextData) override {
     llvm_unreachable("unimplemented for ClangImporter");
   }
-  
-  /// Returns the generic environment.
-  virtual GenericEnvironment *loadGenericEnvironment(const DeclContext *decl,
-                                                     uint64_t contextData) override {
-    llvm_unreachable("unimplemented for ClangImporter");
-  }
 
   void loadRequirementSignature(const ProtocolDecl *decl, uint64_t contextData,
                                 SmallVectorImpl<Requirement> &reqs) override {
diff --git a/lib/Serialization/Deserialization.cpp b/lib/Serialization/Deserialization.cpp
diff --git a/lib/Serialization/ModuleFile.h b/lib/Serialization/ModuleFile.h
