AST: Replace GenericSignature::createGenericEnvironment() with getGenericEnvironment()

This memoizes the result, which is fine for all callers; the only
exception is open existential types where each new open existential
now explicitly gets a unique generic environment, allocated by
calling GenericEnvironment::getIncomplete().

Author: slavapestov

include/swift/AST/GenericSignature.h

@@ -32,6 +32,7 @@ class GenericSignatureBuilder;
 class ProtocolConformanceRef;
 class ProtocolType;
 class SubstitutionMap;
+class GenericEnvironment;
 
 /// An access path used to find a particular protocol conformance within
 /// a generic signature.
@@ -101,6 +102,8 @@ class alignas(1 << TypeAlignInBits) GenericSignature final
   unsigned NumGenericParams;
   unsigned NumRequirements;
 
+  GenericEnvironment *GenericEnv = nullptr;
+
   // Make vanilla new/delete illegal.
   void *operator new(size_t Bytes) = delete;
   void operator delete(void *Data) = delete;
@@ -132,9 +135,6 @@ class alignas(1 << TypeAlignInBits) GenericSignature final
   static ASTContext &getASTContext(TypeArrayView<GenericTypeParamType> params,
                                    ArrayRef<Requirement> requirements);
 
-  /// Retrieve the generic signature builder for the given generic signature.
-  GenericSignatureBuilder *getGenericSignatureBuilder();
-
   void buildConformanceAccessPath(
       SmallVectorImpl<ConformanceAccessPath::Entry> &path,
       ArrayRef<Requirement> reqs,
@@ -218,10 +218,13 @@ class alignas(1 << TypeAlignInBits) GenericSignature final
   /// Canonicalize the components of a generic signature.
   CanGenericSignature getCanonicalSignature() const;
 
-  /// Create a new generic environment that provides fresh contextual types
+  /// Retrieve the generic signature builder for the given generic signature.
+  GenericSignatureBuilder *getGenericSignatureBuilder();
+
+  /// Returns the generic environment that provides fresh contextual types
   /// (archetypes) that correspond to the interface types in this generic
   /// signature.
-  GenericEnvironment *createGenericEnvironment();
+  GenericEnvironment *getGenericEnvironment();
 
   /// Uniquing for the ASTContext.
   void Profile(llvm::FoldingSetNodeID &ID) {

include/swift/AST/Type.h

@@ -620,7 +620,7 @@ class CanGenericSignature {
     return Signature;
   }
 
-  bool operator==(const swift::CanGenericSignature& other) {
+  bool operator==(const swift::CanGenericSignature &other) {
     return Signature == other.Signature;
   }
 };

lib/AST/ASTContext.cpp

@@ -1634,7 +1634,7 @@ GenericEnvironment *ASTContext::getOrCreateCanonicalGenericEnvironment(
   if (known != canonicalGenericEnvironments.end())
     return known->second;
 
-  auto env = sig->createGenericEnvironment();
+  auto env = sig->getGenericEnvironment();
   canonicalGenericEnvironments[builder] = env;
   return env;
 }
@@ -3653,7 +3653,8 @@ OpaqueTypeArchetypeType::get(OpaqueTypeDecl *Decl,
 
   // Create a generic environment and bind the opaque archetype to the
   // opaque interface type from the decl's signature.
-  auto env = signature->createGenericEnvironment();
+  auto *builder = signature->getGenericSignatureBuilder();
+  auto *env = GenericEnvironment::getIncomplete(signature, builder);
   env->addMapping(GenericParamKey(opaqueInterfaceTy), newOpaque);
   newOpaque->Environment = env;
 
@@ -3726,7 +3727,8 @@ GenericEnvironment *OpenedArchetypeType::getGenericEnvironment() const {
   // Create a generic environment to represent the opened type.
   auto signature = ctx.getExistentialSignature(Opened->getCanonicalType(),
                                                nullptr);
-  auto env = signature->createGenericEnvironment();
+  auto *builder = signature->getGenericSignatureBuilder();
+  auto *env = GenericEnvironment::getIncomplete(signature, builder);
   env->addMapping(signature->getGenericParams()[0], thisType);
   Environment = env;
 

lib/AST/Builtins.cpp

@@ -479,7 +479,7 @@ namespace {
           AbstractGenericSignatureRequest{
             nullptr, std::move(genericParamTypes), { }},
           nullptr);
-      GenericEnv = GenericSig->createGenericEnvironment();
+      GenericEnv = GenericSig->getGenericEnvironment();
     }
 
     template <class G>

lib/AST/Decl.cpp

@@ -884,7 +884,7 @@ GenericContext::getLazyGenericEnvironmentSlow() const {
   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()->createGenericEnvironment();
+    auto *genericEnv = getGenericSignature()->getGenericEnvironment();
     const_cast<GenericContext *>(this)->setGenericEnvironment(genericEnv);
     return genericEnv;
   }

lib/AST/GenericSignature.cpp

@@ -339,9 +339,13 @@ GenericSignature::getCanonicalSignature() const {
            CanonicalSignatureOrASTContext.get<GenericSignature*>());
 }
 
-GenericEnvironment *GenericSignature::createGenericEnvironment() {
-  auto *builder = getGenericSignatureBuilder();
-  return GenericEnvironment::getIncomplete(this, builder);
+GenericEnvironment *GenericSignature::getGenericEnvironment() {
+  if (GenericEnv == nullptr) {
+    auto *builder = getGenericSignatureBuilder();
+    GenericEnv = GenericEnvironment::getIncomplete(this, builder);
+  }
+
+  return GenericEnv;
 }
 
 

lib/AST/RequirementEnvironment.cpp

@@ -142,7 +142,7 @@ RequirementEnvironment::RequirementEnvironment(
     if (syntheticSignature) {
       syntheticSignature = syntheticSignature->getCanonicalSignature();
       syntheticEnvironment =
-        syntheticSignature->createGenericEnvironment();
+        syntheticSignature->getGenericEnvironment();
     }
 
     return;
@@ -217,5 +217,5 @@ RequirementEnvironment::RequirementEnvironment(
       AbstractGenericSignatureRequest{
         nullptr, std::move(genericParamTypes), std::move(requirements)},
       nullptr);
-  syntheticEnvironment = syntheticSignature->createGenericEnvironment();
+  syntheticEnvironment = syntheticSignature->getGenericEnvironment();
 }

lib/ClangImporter/ImportDecl.cpp

@@ -8044,7 +8044,7 @@ GenericSignature *ClangImporter::Implementation::buildGenericSignature(
 // Calculate the generic environment from an imported generic param list.
 GenericEnvironment *ClangImporter::Implementation::buildGenericEnvironment(
     GenericParamList *genericParams, DeclContext *dc) {
-  return buildGenericSignature(genericParams, dc)->createGenericEnvironment();
+  return buildGenericSignature(genericParams, dc)->getGenericEnvironment();
 }
 
 DeclContext *

lib/IRGen/GenKeyPath.cpp

@@ -1159,7 +1159,7 @@ IRGenModule::getAddrOfKeyPathPattern(KeyPathPattern *pattern,
 
   GenericEnvironment *genericEnv = nullptr;
   if (auto sig = pattern->getGenericSignature()) {
-    genericEnv = sig->createGenericEnvironment();
+    genericEnv = sig->getGenericEnvironment();
     enumerateGenericSignatureRequirements(pattern->getGenericSignature(),
       [&](GenericRequirement reqt) { requirements.push_back(reqt); });
   }

lib/IRGen/GenReflection.cpp

@@ -231,7 +231,7 @@ getTypeRefByFunction(IRGenModule &IGM,
       if (sig) {
         enumerateGenericSignatureRequirements(sig,
                 [&](GenericRequirement reqt) { requirements.push_back(reqt); });
-        genericEnv = sig->createGenericEnvironment();
+        genericEnv = sig->getGenericEnvironment();
       }
 
       {
@@ -362,7 +362,7 @@ IRGenModule::emitWitnessTableRefString(CanType type,
     genericSig = origGenericSig->getCanonicalSignature();
     enumerateGenericSignatureRequirements(genericSig,
                 [&](GenericRequirement reqt) { requirements.push_back(reqt); });
-    genericEnv = genericSig->createGenericEnvironment();
+    genericEnv = genericSig->getGenericEnvironment();
   }
 
   IRGenMangler mangler;