AST: Replace ASTContext::getOrCreateArchetypeBuilder() with getCanonicalGenericEnvironment()

Instead of keeping around an entire ArchetypeBuilder, it suffices
to build a GenericEnvironment instead, and use it for queries by
mapping interface types to archetypes.

Author: slavapestov

include/swift/AST/ASTContext.h

@@ -58,6 +58,7 @@ namespace swift {
   class ExtensionDecl;
   class ForeignRepresentationInfo;
   class FuncDecl;
+  class GenericEnvironment;
   class InFlightDiagnostic;
   class LazyResolver;
   class PatternBindingDecl;
@@ -773,10 +774,10 @@ class ASTContext {
   /// not necessarily loaded.
   void getVisibleTopLevelClangModules(SmallVectorImpl<clang::Module*> &Modules) const;
 
-  /// Retrieve or create the stored archetype builder for the given
+  /// Retrieve or create the canonical GenericEnvironment for the given
   /// canonical generic signature and module.
-  ArchetypeBuilder *getOrCreateArchetypeBuilder(CanGenericSignature sig,
-                                                ModuleDecl *mod);
+  GenericEnvironment *getCanonicalGenericEnvironment(CanGenericSignature sig,
+                                                     ModuleDecl *mod);
 
   /// Retrieve the inherited name set for the given class.
   const InheritedNameSet *getAllPropertyNames(ClassDecl *classDecl,

include/swift/AST/GenericSignature.h

@@ -139,8 +139,8 @@ class alignas(1 << TypeAlignInBits) GenericSignature final
   static ASTContext &getASTContext(ArrayRef<GenericTypeParamType *> params,
                                    ArrayRef<Requirement> requirements);
 
-  /// Retrieve the archetype builder for the given generic signature.
-  ArchetypeBuilder *getArchetypeBuilder(ModuleDecl &mod);
+  /// Retrieve the canonical generic environment for this generic signature.
+  GenericEnvironment *getCanonicalGenericEnvironment(ModuleDecl &mod);
 
 public:
   /// Create a new generic signature with the given type parameters and
@@ -233,10 +233,9 @@ class alignas(1 << TypeAlignInBits) GenericSignature final
   /// Determine the superclass bound on the given dependent type.
   Type getSuperclassBound(Type type, ModuleDecl &mod);
 
-  using ConformsToArray = SmallVector<ProtocolDecl *, 2>;
   /// Determine the set of protocols to which the given dependent type
   /// must conform.
-  ConformsToArray getConformsTo(Type type, ModuleDecl &mod);
+  ArrayRef<ProtocolDecl *> getConformsTo(Type type, ModuleDecl &mod);
 
   /// Determine whether the given dependent type is equal to a concrete type.
   bool isConcreteType(Type type, ModuleDecl &mod);

lib/AST/ASTContext.cpp

@@ -215,9 +215,9 @@ struct ASTContext::Implementation {
                            ArchetypeBuilder::PotentialArchetype *>>
     LazyArchetypes;
 
-  /// \brief Stored archetype builders.
+  /// \brief Stored canonical generic environments.
   llvm::DenseMap<std::pair<GenericSignature *, ModuleDecl *>,
-                 std::unique_ptr<ArchetypeBuilder>> ArchetypeBuilders;
+                 GenericEnvironment *> GenericEnvironments;
 
   /// The set of property names that show up in the defining module of a
   /// class.
@@ -1268,24 +1268,26 @@ void ASTContext::getVisibleTopLevelClangModules(
     collectAllModules(Modules);
 }
 
-ArchetypeBuilder *ASTContext::getOrCreateArchetypeBuilder(
-                    CanGenericSignature sig,
-                    ModuleDecl *mod) {
-  // Check whether we already have an archetype builder for this
+GenericEnvironment *
+ASTContext::getCanonicalGenericEnvironment(CanGenericSignature sig,
+                                           ModuleDecl *mod) {
+  // Check whether we already have a generic environment for this
   // signature and module.
-  auto known = Impl.ArchetypeBuilders.find({sig, mod});
-  if (known != Impl.ArchetypeBuilders.end())
-    return known->second.get();
+  auto known = Impl.GenericEnvironments.find({sig, mod});
+  if (known != Impl.GenericEnvironments.end())
+    return known->second;
 
   // Create a new archetype builder with the given signature.
-  auto builder = new ArchetypeBuilder(*mod, Diags);
-  builder->addGenericSignature(sig, nullptr,
-                               /*treatRequirementsAsExplicit=*/true);
-  
-  // Store this archetype builder.
-  Impl.ArchetypeBuilders[{sig, mod}]
-    = std::unique_ptr<ArchetypeBuilder>(builder);
-  return builder;
+  ArchetypeBuilder builder(*mod, Diags);
+  builder.addGenericSignature(sig, nullptr,
+                              /*treatRequirementsAsExplicit=*/true);
+
+  // Get the generic environment from the builder.
+  auto *env = builder.getGenericEnvironment();
+
+  // Store this generic environment.
+  Impl.GenericEnvironments[{sig, mod}] = env;
+  return env;
 }
 
 Module *

lib/AST/GenericSignature.cpp

@@ -15,6 +15,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "swift/AST/GenericSignature.h"
+#include "swift/AST/GenericEnvironment.h"
 #include "swift/AST/ASTContext.h"
 #include "swift/AST/Decl.h"
 #include "swift/AST/Module.h"
@@ -68,14 +69,15 @@ ASTContext &GenericSignature::getASTContext(
     return requirements.front().getFirstType()->getASTContext();
 }
 
-ArchetypeBuilder *GenericSignature::getArchetypeBuilder(ModuleDecl &mod) {
-  // The archetype builder is associated with the canonical signature.
+GenericEnvironment *
+GenericSignature::getCanonicalGenericEnvironment(ModuleDecl &mod) {
+  // The generic environment is associated with the canonical signature.
   if (!isCanonical())
-    return getCanonicalSignature()->getArchetypeBuilder(mod);
+    return getCanonicalSignature()->getCanonicalGenericEnvironment(mod);
 
   // Archetype builders are stored on the ASTContext.
-  return getASTContext().getOrCreateArchetypeBuilder(CanGenericSignature(this),
-                                                     &mod);
+  return getASTContext().getCanonicalGenericEnvironment(
+      CanGenericSignature(this), &mod);
 }
 
 bool GenericSignature::isCanonical() const {
@@ -248,70 +250,37 @@ getSubstitutions(ModuleDecl &mod,
 bool GenericSignature::requiresClass(Type type, ModuleDecl &mod) {
   if (!type->isTypeParameter()) return false;
 
-  auto &builder = *getArchetypeBuilder(mod);
-  auto pa = builder.resolveArchetype(type);
-  if (!pa) return false;
-
-  pa = pa->getRepresentative();
-
-  // If this type was mapped to a concrete type, then there is no
-  // requirement.
-  if (pa->isConcreteType()) return false;
-
-  // If there is a superclass bound, then obviously it must be a class.
-  if (pa->getSuperclass()) return true;
-
-  // If any of the protocols are class-bound, then it must be a class.
-  for (auto proto : pa->getConformsTo()) {
-    if (proto.first->requiresClass()) return true;
-  }
-
+  auto genericEnv = getCanonicalGenericEnvironment(mod);
+  auto contextTy = genericEnv->mapTypeIntoContext(&mod, type);
+  if (auto *archetypeTy = contextTy->getAs<ArchetypeType>())
+    return archetypeTy->requiresClass();
   return false;
 }
 
 /// Determine the superclass bound on the given dependent type.
 Type GenericSignature::getSuperclassBound(Type type, ModuleDecl &mod) {
   if (!type->isTypeParameter()) return nullptr;
 
-  auto &builder = *getArchetypeBuilder(mod);
-  auto pa = builder.resolveArchetype(type);
-  if (!pa) return nullptr;
-
-  pa = pa->getRepresentative();
-
-  // If this type was mapped to a concrete type, then there is no
-  // requirement.
-  if (pa->isConcreteType()) return nullptr;
+  auto genericEnv = getCanonicalGenericEnvironment(mod);
+  auto contextTy = genericEnv->mapTypeIntoContext(&mod, type);
+  if (auto *archetypeTy = contextTy->getAs<ArchetypeType>())
+    return archetypeTy->getSuperclass();
 
-  // Retrieve the superclass bound.
-  return pa->getSuperclass();
+  return Type();
 }
 
 /// Determine the set of protocols to which the given dependent type
 /// must conform.
-SmallVector<ProtocolDecl *, 2> GenericSignature::getConformsTo(Type type,
-                                                               ModuleDecl &mod) {
+ArrayRef<ProtocolDecl *> GenericSignature::getConformsTo(Type type,
+                                                         ModuleDecl &mod) {
   if (!type->isTypeParameter()) return { };
 
-  auto &builder = *getArchetypeBuilder(mod);
-  auto pa = builder.resolveArchetype(type);
-  if (!pa) return { };
+  auto genericEnv = getCanonicalGenericEnvironment(mod);
+  auto contextTy = genericEnv->mapTypeIntoContext(&mod, type);
+  if (auto *archetypeTy = contextTy->getAs<ArchetypeType>())
+    return archetypeTy->getConformsTo();
 
-  pa = pa->getRepresentative();
-
-  // If this type was mapped to a concrete type, then there are no
-  // requirements.
-  if (pa->isConcreteType()) return { };
-
-  // Retrieve the protocols to which this type conforms.
-  SmallVector<ProtocolDecl *, 2> result;
-  for (auto proto : pa->getConformsTo())
-    result.push_back(proto.first);
-
-  // Canonicalize the resulting set of protocols.
-  ProtocolType::canonicalizeProtocols(result);
-
-  return result;
+  return { };
 }
 
 /// Determine whether the given dependent type is equal to a concrete type.
@@ -325,29 +294,18 @@ bool GenericSignature::isConcreteType(Type type, ModuleDecl &mod) {
 Type GenericSignature::getConcreteType(Type type, ModuleDecl &mod) {
   if (!type->isTypeParameter()) return Type();
 
-  auto &builder = *getArchetypeBuilder(mod);
-  auto pa = builder.resolveArchetype(type);
-  if (!pa) return Type();
-
-  pa = pa->getRepresentative();
-  if (!pa->isConcreteType()) return Type();
+  auto genericEnv = getCanonicalGenericEnvironment(mod);
+  auto contextTy = genericEnv->mapTypeIntoContext(&mod, type);
+  if (contextTy->is<ArchetypeType>())
+    return Type();
 
-  return pa->getConcreteType();
+  return contextTy;
 }
 
 Type GenericSignature::getRepresentative(Type type, ModuleDecl &mod) {
-  assert(type->isTypeParameter());
-  auto &builder = *getArchetypeBuilder(mod);
-  auto pa = builder.resolveArchetype(type);
-  assert(pa && "not a valid dependent type of this signature?");
-  auto rep = pa->getRepresentative();
-  if (rep->isConcreteType()) return rep->getConcreteType();
-  if (pa == rep) {
-    assert(rep->getDependentType(builder, /*allowUnresolved*/ false)
-              ->getCanonicalType() == type->getCanonicalType());
-    return type;
-  }
-  return rep->getDependentType(builder, /*allowUnresolved*/ false);
+  auto genericEnv = getCanonicalGenericEnvironment(mod);
+  auto contextTy = genericEnv->mapTypeIntoContext(&mod, type);
+  return genericEnv->mapTypeOutOfContext(&mod, contextTy)->getCanonicalType();
 }
 
 bool GenericSignature::areSameTypeParameterInContext(Type type1, Type type2,
@@ -358,18 +316,10 @@ bool GenericSignature::areSameTypeParameterInContext(Type type1, Type type2,
   if (type1.getPointer() == type2.getPointer())
     return true;
 
-  auto &builder = *getArchetypeBuilder(mod);
-  auto pa1 = builder.resolveArchetype(type1);
-  assert(pa1 && "not a valid dependent type of this signature?");
-  pa1 = pa1->getRepresentative();
-  assert(!pa1->isConcreteType());
-
-  auto pa2 = builder.resolveArchetype(type2);
-  assert(pa2 && "not a valid dependent type of this signature?");
-  pa2 = pa2->getRepresentative();
-  assert(!pa2->isConcreteType());
-
-  return pa1 == pa2;
+  auto genericEnv = getCanonicalGenericEnvironment(mod);
+  auto first = genericEnv->mapTypeIntoContext(&mod, type1);
+  auto second = genericEnv->mapTypeIntoContext(&mod, type2);
+  return first->isEqual(second);
 }
 
 bool GenericSignature::isCanonicalTypeInContext(Type type, ModuleDecl &mod) {
@@ -383,48 +333,13 @@ bool GenericSignature::isCanonicalTypeInContext(Type type, ModuleDecl &mod) {
   if (!type->hasTypeParameter())
     return true;
 
-  auto &builder = *getArchetypeBuilder(mod);
-
-  // Look for non-canonical type parameters.
-  return !type.findIf([&](Type component) -> bool {
-    if (!component->isTypeParameter()) return false;
-
-    auto pa = builder.resolveArchetype(component);
-    if (!pa) return false;
-
-    auto rep = pa->getArchetypeAnchor();
-    return (rep->isConcreteType() || pa != rep);
-  });
+  auto genericEnv = getCanonicalGenericEnvironment(mod);
+  auto contextTy = genericEnv->mapTypeIntoContext(&mod, type);
+  return type->isEqual(genericEnv->mapTypeOutOfContext(&mod, contextTy));
 }
 
 CanType GenericSignature::getCanonicalTypeInContext(Type type, ModuleDecl &mod) {
-  type = type->getCanonicalType();
-
-  // All the contextual canonicality rules apply to type parameters, so if the
-  // type doesn't involve any type parameters, it's already canonical.
-  if (!type->hasTypeParameter())
-    return CanType(type);
-
-  auto &builder = *getArchetypeBuilder(mod);
-
-  // Replace non-canonical type parameters.
-  type = type.transform([&](Type component) -> Type {
-    if (!component->isTypeParameter()) return component;
-
-    // Resolve the potential archetype.  This can be null in nested generic
-    // types, which we can't immediately canonicalize.
-    auto pa = builder.resolveArchetype(component);
-    if (!pa) return component;
-
-    auto rep = pa->getArchetypeAnchor();
-    if (rep->isConcreteType()) {
-      return getCanonicalTypeInContext(rep->getConcreteType(), mod);
-    } else {
-      return rep->getDependentType(builder, /*allowUnresolved*/ false);
-    }
-  });
-
-  auto result = type->getCanonicalType();
-  assert(isCanonicalTypeInContext(result, mod));
-  return result;
+  auto genericEnv = getCanonicalGenericEnvironment(mod);
+  auto contextTy = genericEnv->mapTypeIntoContext(&mod, type);
+  return genericEnv->mapTypeOutOfContext(&mod, contextTy)->getCanonicalType();
 }

lib/IRGen/Fulfillment.cpp

@@ -328,7 +328,8 @@ bool FulfillmentMap::Everything
                    ::hasLimitedInterestingConformances(CanType type) const {
   return false;
 }
-GenericSignature::ConformsToArray
+
+ArrayRef<ProtocolDecl *>
 FulfillmentMap::Everything::getInterestingConformances(CanType type) const{
   return {};
 }

lib/IRGen/Fulfillment.h

@@ -63,7 +63,7 @@ class FulfillmentMap {
     virtual bool hasLimitedInterestingConformances(CanType type) const = 0;
 
     /// Return the limited interesting conformances for an interesting type.
-    virtual GenericSignature::ConformsToArray
+    virtual ArrayRef<ProtocolDecl *>
       getInterestingConformances(CanType type) const = 0;
 
     virtual ~InterestingKeysCallback() = default;
@@ -75,7 +75,7 @@ class FulfillmentMap {
     bool isInterestingType(CanType type) const override;
     bool hasInterestingType(CanType type) const override;
     bool hasLimitedInterestingConformances(CanType type) const override;
-    GenericSignature::ConformsToArray
+    ArrayRef<ProtocolDecl *>
       getInterestingConformances(CanType type) const override;
   };
 

lib/IRGen/GenCall.cpp

@@ -1183,16 +1183,15 @@ void CallEmission::emitToMemory(Address addr,
   // We're never being asked to do anything with *formal*
   // indirect results here, just the possibility of a direct-in-SIL
   // result that's actually being passed indirectly.
-  CanType origResultType = origFnType->getSILResult().getSwiftRValueType();
+  SILType origResultType = origFnType->getSILResult();
   CanType substResultType = substFnType->getSILResult().getSwiftRValueType();
 
-  if (origResultType->hasTypeParameter())
-    origResultType = IGF.IGM.getContextArchetypes()
-      .substDependentType(origResultType)
-      ->getCanonicalType();
+  if (origResultType.hasTypeParameter())
+    origResultType = IGF.IGM.mapTypeIntoContext(origResultType);
 
-  if (origResultType != substResultType) {
-    auto origTy = IGF.IGM.getStoragePointerTypeForLowered(origResultType);
+  if (origResultType.getSwiftRValueType() != substResultType) {
+    auto origTy = IGF.IGM.getStoragePointerTypeForLowered(
+        origResultType.getSwiftRValueType());
     origAddr = IGF.Builder.CreateBitCast(origAddr, origTy);
   }