Revert "Begin untangling GenericEnvironment from GenericSignatureBuilder"

Author: compnerd

include/swift/AST/GenericEnvironment.h

@@ -76,22 +76,16 @@ class alignas(1 << DeclAlignInBits) GenericEnvironment final
   /// generic signature.
   ArrayRef<Type> getContextTypes() const;
 
-  explicit GenericEnvironment(GenericSignature signature);
+  GenericEnvironment(GenericSignature signature,
+                     GenericSignatureBuilder *builder);
 
   friend ArchetypeType;
   friend GenericSignatureBuilder;
 
-  GenericSignatureBuilder *getGenericSignatureBuilder() const;
+  GenericSignatureBuilder *getGenericSignatureBuilder() const { return Builder; }
 
   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;
@@ -102,12 +96,18 @@ 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);
+  GenericEnvironment *getIncomplete(GenericSignature signature,
+                                    GenericSignatureBuilder *builder);
 
   /// 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,8 +151,6 @@ 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,15 +228,24 @@ 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);
+                   Identifier name,
+                   SmallVectorImpl<TypeDecl *> *otherConcreteTypes = nullptr);
 
     /// 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;
@@ -259,7 +268,7 @@ class GenericSignatureBuilder {
       unsigned numConformancesPresent;
       CanType superclassPresent;
       CanType concreteTypePresent;
-      TypeDecl *type;
+      llvm::TinyPtrVector<TypeDecl *> types;
     };
 
     /// Cached nested-type information, which contains the best declaration

lib/AST/ASTContext.cpp

@@ -4165,7 +4165,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 = GenericEnvironment::getIncomplete(signature);
+  auto *builder = signature->getGenericSignatureBuilder();
+  auto *env = GenericEnvironment::getIncomplete(signature, builder);
   env->addMapping(GenericParamKey(opaqueInterfaceTy), newOpaque);
   newOpaque->Environment = env;
 
@@ -4242,7 +4243,8 @@ GenericEnvironment *OpenedArchetypeType::getGenericEnvironment() const {
   auto &ctx = thisType->getASTContext();
   // Create a generic environment to represent the opened type.
   auto signature = ctx.getOpenedArchetypeSignature(Opened);
-  auto *env = GenericEnvironment::getIncomplete(signature);
+  auto *builder = signature->getGenericSignatureBuilder();
+  auto *env = GenericEnvironment::getIncomplete(signature, builder);
   env->addMapping(signature->getGenericParams()[0], thisType);
   Environment = env;
 
@@ -4397,14 +4399,15 @@ GenericSignature::get(TypeArrayView<GenericTypeParamType> params,
 }
 
 GenericEnvironment *GenericEnvironment::getIncomplete(
-                                             GenericSignature signature) {
+                                             GenericSignature signature,
+                                             GenericSignatureBuilder *builder) {
   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);
+  return new (mem) GenericEnvironment(signature, builder);
 }
 
 void DeclName::CompoundDeclName::Profile(llvm::FoldingSetNodeID &id,

lib/AST/GenericEnvironment.cpp

@@ -18,8 +18,6 @@
 #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;
 
@@ -48,24 +46,15 @@ GenericEnvironment::getGenericParams() const {
   return Signature->getGenericParams();
 }
 
-GenericEnvironment::GenericEnvironment(GenericSignature signature)
-  : Signature(signature)
+GenericEnvironment::GenericEnvironment(GenericSignature signature,
+                                       GenericSignatureBuilder *builder)
+  : Signature(signature), Builder(builder)
 {
   // 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
@@ -75,9 +64,7 @@ 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() ||
-         getContextTypes()[index]->is<ErrorType>() &&
-         "Already recoded this mapping");
+  assert(getContextTypes()[index].isNull() && "Already recoded this mapping");
   getContextTypes()[index] = contextType;
 }
 
@@ -120,116 +107,6 @@ 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
@@ -243,18 +120,24 @@ Type QueryInterfaceTypeSubstitutions::operator()(SubstitutableType *type) const{
       return Type();
 
     // If the context type isn't already known, lazily create it.
-    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;
+    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;
   }
 
   return Type();

lib/AST/GenericSignature.cpp

@@ -247,8 +247,9 @@ 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);
+    impl->GenericEnv = GenericEnvironment::getIncomplete(this, builder);
   }
 
   return GenericEnv;