AST: Lazy construct GenericSignatureBuilder in a GenericEnvironment

Author: slavapestov

include/swift/AST/GenericEnvironment.h

@@ -76,13 +76,12 @@ class alignas(1 << DeclAlignInBits) GenericEnvironment final
   /// generic signature.
   ArrayRef<Type> getContextTypes() const;
 
-  GenericEnvironment(GenericSignature signature,
-                     GenericSignatureBuilder *builder);
+  explicit GenericEnvironment(GenericSignature signature);
 
   friend ArchetypeType;
   friend GenericSignatureBuilder;
 
-  GenericSignatureBuilder *getGenericSignatureBuilder() const { return Builder; }
+  GenericSignatureBuilder *getGenericSignatureBuilder() const;
 
   friend QueryInterfaceTypeSubstitutions;
 
@@ -96,8 +95,7 @@ class alignas(1 << DeclAlignInBits) GenericEnvironment final
   /// Create a new, "incomplete" generic environment that will be populated
   /// by calls to \c addMapping().
   static
-  GenericEnvironment *getIncomplete(GenericSignature signature,
-                                    GenericSignatureBuilder *builder);
+  GenericEnvironment *getIncomplete(GenericSignature signature);
 
   /// Add a mapping of a generic parameter to a specific type (which may be
   /// an archetype)

lib/AST/ASTContext.cpp

@@ -4165,8 +4165,7 @@ OpaqueTypeArchetypeType::get(OpaqueTypeDecl *Decl,
 
   // Create a generic environment and bind the opaque archetype to the
   // opaque interface type from the decl's signature.
-  auto *builder = signature->getGenericSignatureBuilder();
-  auto *env = GenericEnvironment::getIncomplete(signature, builder);
+  auto *env = GenericEnvironment::getIncomplete(signature);
   env->addMapping(GenericParamKey(opaqueInterfaceTy), newOpaque);
   newOpaque->Environment = env;
 
@@ -4243,8 +4242,7 @@ GenericEnvironment *OpenedArchetypeType::getGenericEnvironment() const {
   auto &ctx = thisType->getASTContext();
   // Create a generic environment to represent the opened type.
   auto signature = ctx.getOpenedArchetypeSignature(Opened);
-  auto *builder = signature->getGenericSignatureBuilder();
-  auto *env = GenericEnvironment::getIncomplete(signature, builder);
+  auto *env = GenericEnvironment::getIncomplete(signature);
   env->addMapping(signature->getGenericParams()[0], thisType);
   Environment = env;
 
@@ -4399,15 +4397,14 @@ GenericSignature::get(TypeArrayView<GenericTypeParamType> params,
 }
 
 GenericEnvironment *GenericEnvironment::getIncomplete(
-                                             GenericSignature signature,
-                                             GenericSignatureBuilder *builder) {
+                                             GenericSignature signature) {
   auto &ctx = signature->getASTContext();
 
   // Allocate and construct the new environment.
   unsigned numGenericParams = signature->getGenericParams().size();
   size_t bytes = totalSizeToAlloc<Type>(numGenericParams);
   void *mem = ctx.Allocate(bytes, alignof(GenericEnvironment));
-  return new (mem) GenericEnvironment(signature, builder);
+  return new (mem) GenericEnvironment(signature);
 }
 
 void DeclName::CompoundDeclName::Profile(llvm::FoldingSetNodeID &id,

lib/AST/GenericEnvironment.cpp

@@ -46,15 +46,24 @@ GenericEnvironment::getGenericParams() const {
   return Signature->getGenericParams();
 }
 
-GenericEnvironment::GenericEnvironment(GenericSignature signature,
-                                       GenericSignatureBuilder *builder)
-  : Signature(signature), Builder(builder)
+GenericEnvironment::GenericEnvironment(GenericSignature signature)
+  : Signature(signature)
 {
   // Clear out the memory that holds the context types.
   std::uninitialized_fill(getContextTypes().begin(), getContextTypes().end(),
                           Type());
 }
 
+GenericSignatureBuilder *GenericEnvironment::getGenericSignatureBuilder() const {
+  if (Builder)
+    return Builder;
+
+  const_cast<GenericEnvironment *>(this)->Builder
+      = Signature->getGenericSignatureBuilder();
+
+  return Builder;
+}
+
 void GenericEnvironment::addMapping(GenericParamKey key,
                                     Type contextType) {
   // Find the index into the parallel arrays of generic parameters and
@@ -122,15 +131,14 @@ Type QueryInterfaceTypeSubstitutions::operator()(SubstitutableType *type) const{
     // If the context type isn't already known, lazily create it.
     Type contextType = self->getContextTypes()[index];
     if (!contextType) {
-      assert(self->Builder &&"Missing generic signature builder for lazy query");
+      auto *builder = self->getGenericSignatureBuilder();
       auto equivClass =
-        self->Builder->resolveEquivalenceClass(
+        builder->resolveEquivalenceClass(
                                   type,
                                   ArchetypeResolutionKind::CompleteWellFormed);
 
       auto mutableSelf = const_cast<GenericEnvironment *>(self);
-      contextType = equivClass->getTypeInContext(*mutableSelf->Builder,
-                                                 mutableSelf);
+      contextType = equivClass->getTypeInContext(*builder, mutableSelf);
 
       // FIXME: Redundant mapping from key -> index.
       if (self->getContextTypes()[index].isNull())

lib/AST/GenericSignature.cpp

@@ -247,9 +247,8 @@ CanGenericSignature GenericSignatureImpl::getCanonicalSignature() const {
 
 GenericEnvironment *GenericSignatureImpl::getGenericEnvironment() const {
   if (GenericEnv == nullptr) {
-    auto *builder = getGenericSignatureBuilder();
     const auto impl = const_cast<GenericSignatureImpl *>(this);
-    impl->GenericEnv = GenericEnvironment::getIncomplete(this, builder);
+    impl->GenericEnv = GenericEnvironment::getIncomplete(this);
   }
 
   return GenericEnv;