Merge pull request #38450 from slavapestov/generic-environment-cleanup-redux

Re-apply #38384

Author: slavapestov

include/swift/AST/GenericEnvironment.h

@@ -76,16 +76,22 @@ 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;
 
+  Type getOrCreateArchetypeFromInterfaceType(Type depType);
+
+  /// Retrieve the mapping for the given generic parameter, if present.
+  ///
+  /// This is only useful when lazily populating a generic environment.
+  Optional<Type> getMappingIfPresent(GenericParamKey key) const;
+
 public:
   GenericSignature getGenericSignature() const {
     return Signature;
@@ -96,18 +102,12 @@ 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)
   void addMapping(GenericParamKey key, Type contextType);
 
-  /// Retrieve the mapping for the given generic parameter, if present.
-  ///
-  /// This is only useful when lazily populating a generic environment.
-  Optional<Type> getMappingIfPresent(GenericParamKey key) const;
-
   /// Make vanilla new/delete illegal.
   void *operator new(size_t Bytes) = delete;
   void operator delete(void *Data) = delete;
@@ -151,6 +151,8 @@ class alignas(1 << DeclAlignInBits) GenericEnvironment final
   mapConformanceRefIntoContext(Type conformingType,
                                ProtocolConformanceRef conformance) const;
 
+  /// Returns a substitution map that sends every generic parameter to its
+  /// corresponding archetype in this generic environment.
   SubstitutionMap getForwardingSubstitutionMap() const;
 
   void dump(raw_ostream &os) const;

include/swift/AST/GenericSignatureBuilder.h

@@ -228,24 +228,15 @@ class GenericSignatureBuilder {
 
     /// Lookup a nested type with the given name within this equivalence
     /// class.
-    ///
-    /// \param otherConcreteTypes If non-null, will be filled in the all of the
-    /// concrete types we found (other than the result) with the same name.
     TypeDecl *lookupNestedType(
                    GenericSignatureBuilder &builder,
-                   Identifier name,
-                   SmallVectorImpl<TypeDecl *> *otherConcreteTypes = nullptr);
+                   Identifier name);
 
     /// Retrieve the "anchor" type that canonically describes this equivalence
     /// class, for use in the canonical type.
     Type getAnchor(GenericSignatureBuilder &builder,
                    TypeArrayView<GenericTypeParamType> genericParams);
 
-    /// Retrieve (or build) the contextual type corresponding to
-    /// this equivalence class within the given generic environment.
-    Type getTypeInContext(GenericSignatureBuilder &builder,
-                          GenericEnvironment *genericEnv);
-
     /// Dump a debugging representation of this equivalence class,
     void dump(llvm::raw_ostream &out,
               GenericSignatureBuilder *builder = nullptr) const;
@@ -268,7 +259,7 @@ class GenericSignatureBuilder {
       unsigned numConformancesPresent;
       CanType superclassPresent;
       CanType concreteTypePresent;
-      llvm::TinyPtrVector<TypeDecl *> types;
+      TypeDecl *type = nullptr;
     };
 
     /// Cached nested-type information, which contains the best declaration

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

@@ -18,6 +18,8 @@
 #include "swift/AST/ASTContext.h"
 #include "swift/AST/GenericSignatureBuilder.h"
 #include "swift/AST/ProtocolConformance.h"
+#include "swift/Basic/Defer.h"
+#include "GenericSignatureBuilderImpl.h"
 
 using namespace swift;
 
@@ -46,15 +48,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
@@ -64,7 +75,9 @@ void GenericEnvironment::addMapping(GenericParamKey key,
   assert(genericParams[index] == key && "Bad generic parameter");
 
   // Add the mapping from the generic parameter to the context type.
-  assert(getContextTypes()[index].isNull() && "Already recoded this mapping");
+  assert(getContextTypes()[index].isNull() ||
+         getContextTypes()[index]->is<ErrorType>() &&
+         "Already recoded this mapping");
   getContextTypes()[index] = contextType;
 }
 
@@ -107,6 +120,116 @@ Type TypeBase::mapTypeOutOfContext() {
     SubstFlags::AllowLoweredTypes);
 }
 
+Type
+GenericEnvironment::getOrCreateArchetypeFromInterfaceType(Type depType) {
+  auto &builder = *getGenericSignatureBuilder();
+  auto &ctx = builder.getASTContext();
+
+  auto resolved =
+    builder.maybeResolveEquivalenceClass(
+                                  depType,
+                                  ArchetypeResolutionKind::CompleteWellFormed,
+                                  /*wantExactPotentialArchetype=*/false);
+  if (!resolved)
+    return ErrorType::get(depType);
+
+  if (auto concrete = resolved.getAsConcreteType()) {
+    return mapTypeIntoContext(concrete,
+                              builder.getLookupConformanceFn());
+  }
+
+  auto *equivClass = resolved.getEquivalenceClass(builder);
+
+  auto genericParams = getGenericParams();
+  Type anchor = equivClass->getAnchor(builder, genericParams);
+
+  // First, write an ErrorType to the location where this type is cached,
+  // to catch re-entrant lookups that might arise from an invalid generic
+  // signature (eg, <X where X == Array<X>>).
+  ArchetypeType *parentArchetype = nullptr;
+  GenericTypeParamType *genericParam = nullptr;
+  if (auto depMemTy = anchor->getAs<DependentMemberType>()) {
+    parentArchetype =
+      getOrCreateArchetypeFromInterfaceType(depMemTy->getBase())
+        ->getAs<ArchetypeType>();
+    if (!parentArchetype)
+      return ErrorType::get(depMemTy);
+
+    auto name = depMemTy->getName();
+    if (auto type = parentArchetype->getNestedTypeIfKnown(name))
+      return *type;
+
+    parentArchetype->registerNestedType(name, ErrorType::get(ctx));
+  } else {
+    genericParam = anchor->castTo<GenericTypeParamType>();
+    if (auto type = getMappingIfPresent(genericParam))
+      return *type;
+    addMapping(genericParam, ErrorType::get(ctx));
+  }
+
+  Type result;
+
+  // If this equivalence class is mapped to a concrete type, produce that
+  // type.
+  if (equivClass->concreteType) {
+    result = mapTypeIntoContext(equivClass->concreteType,
+                                builder.getLookupConformanceFn());
+  } else {
+    // Substitute into the superclass.
+    Type superclass = equivClass->superclass;
+    if (superclass && superclass->hasTypeParameter()) {
+      superclass = mapTypeIntoContext(superclass,
+                                      builder.getLookupConformanceFn());
+      if (superclass->is<ErrorType>())
+        superclass = Type();
+    }
+
+    // Collect the protocol conformances for the archetype.
+    SmallVector<ProtocolDecl *, 4> protos;
+    for (const auto &conforms : equivClass->conformsTo) {
+      auto proto = conforms.first;
+
+      if (!equivClass->isConformanceSatisfiedBySuperclass(proto))
+        protos.push_back(proto);
+    }
+
+    if (parentArchetype) {
+      auto *depMemTy = anchor->castTo<DependentMemberType>();
+      result = NestedArchetypeType::getNew(ctx, parentArchetype, depMemTy,
+                                           protos, superclass,
+                                           equivClass->layout);
+    } else {
+      result = PrimaryArchetypeType::getNew(ctx, this, genericParam,
+                                            protos, superclass,
+                                            equivClass->layout);
+    }
+  }
+
+  // Cache the new archetype for future lookups.
+  if (auto depMemTy = anchor->getAs<DependentMemberType>()) {
+    parentArchetype->registerNestedType(depMemTy->getName(), result);
+  } else {
+    addMapping(genericParam, result);
+  }
+
+  return result;
+}
+
+void ArchetypeType::resolveNestedType(
+                                    std::pair<Identifier, Type> &nested) const {
+  Type interfaceType = getInterfaceType();
+  Type memberInterfaceType =
+      DependentMemberType::get(interfaceType, nested.first);
+
+  Type result = getGenericEnvironment()->getOrCreateArchetypeFromInterfaceType(
+      memberInterfaceType);
+
+  assert(!nested.second ||
+         nested.second->isEqual(result) ||
+         nested.second->is<ErrorType>());
+  nested.second = result;
+}
+
 Type QueryInterfaceTypeSubstitutions::operator()(SubstitutableType *type) const{
   if (auto gp = type->getAs<GenericTypeParamType>()) {
     // Find the index into the parallel arrays of generic parameters and
@@ -120,24 +243,18 @@ Type QueryInterfaceTypeSubstitutions::operator()(SubstitutableType *type) const{
       return Type();
 
     // 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 equivClass =
-        self->Builder->resolveEquivalenceClass(
-                                  type,
-                                  ArchetypeResolutionKind::CompleteWellFormed);
-
-      auto mutableSelf = const_cast<GenericEnvironment *>(self);
-      contextType = equivClass->getTypeInContext(*mutableSelf->Builder,
-                                                 mutableSelf);
-
-      // FIXME: Redundant mapping from key -> index.
-      if (self->getContextTypes()[index].isNull())
-        mutableSelf->addMapping(key, contextType);
-    }
-
-    return contextType;
+    auto mutableSelf = const_cast<GenericEnvironment *>(self);
+    Type &contextType = mutableSelf->getContextTypes()[index];
+    if (contextType)
+      return contextType;
+
+    auto result = mutableSelf->getOrCreateArchetypeFromInterfaceType(type);
+
+    assert (!contextType ||
+            contextType->isEqual(result) ||
+            contextType->is<ErrorType>());
+    contextType = result;
+    return result;
   }
 
   return Type();

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;