AST: Factor out GenericSignature::getLocalRequirements() method

This encapsulates GenericEnvironment's usage of the GSB.

Author: slavapestov

include/swift/AST/GenericEnvironment.h

@@ -31,7 +31,6 @@
 namespace swift {
 
 class ArchetypeType;
-class GenericSignatureBuilder;
 class ASTContext;
 class GenericTypeParamType;
 class SILModule;
@@ -60,7 +59,6 @@ class QueryInterfaceTypeSubstitutions {
 class alignas(1 << DeclAlignInBits) GenericEnvironment final
         : private llvm::TrailingObjects<GenericEnvironment, Type> {
   GenericSignature Signature = GenericSignature();
-  GenericSignatureBuilder *Builder = nullptr;
 
   friend TrailingObjects;
 
@@ -79,10 +77,6 @@ class alignas(1 << DeclAlignInBits) GenericEnvironment final
   explicit GenericEnvironment(GenericSignature signature);
 
   friend ArchetypeType;
-  friend GenericSignatureBuilder;
-  
-  GenericSignatureBuilder *getGenericSignatureBuilder() const;
-
   friend QueryInterfaceTypeSubstitutions;
 
   Type getOrCreateArchetypeFromInterfaceType(Type depType);

include/swift/AST/GenericSignature.h

@@ -165,6 +165,18 @@ class GenericSignature {
 public:
   using RequiredProtocols = SmallVector<ProtocolDecl *, 2>;
 
+  /// Stores a set of requirements on a type parameter. Used by
+  /// GenericEnvironment for building archetypes.
+  struct LocalRequirements {
+    Type anchor;
+
+    Type concreteType;
+    Type superclass;
+
+    SmallVector<ProtocolDecl *, 2> protos;
+    LayoutConstraint layout;
+  };
+
 private:
   // Direct comparison is disabled for generic signatures.  Canonicalize them
   // first, or use isEqual.
@@ -314,6 +326,10 @@ class alignas(1 << TypeAlignInBits) GenericSignatureImpl final
   /// signature.
   GenericEnvironment *getGenericEnvironment() const;
 
+  /// Collects a set of requirements on a type parameter. Used by
+  /// GenericEnvironment for building archetypes.
+  GenericSignature::LocalRequirements getLocalRequirements(Type depType) const;
+
   /// Uniquing for the ASTContext.
   void Profile(llvm::FoldingSetNodeID &ID) const {
     Profile(ID, getGenericParams(), getRequirements());

lib/AST/GenericEnvironment.cpp

@@ -15,11 +15,10 @@
 //===----------------------------------------------------------------------===//
 
 #include "swift/AST/GenericEnvironment.h"
+#include "swift/AST/GenericSignature.h"
 #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;
 
@@ -56,16 +55,6 @@ GenericEnvironment::GenericEnvironment(GenericSignature signature)
                           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,33 +111,30 @@ Type TypeBase::mapTypeOutOfContext() {
 
 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 genericSig = getGenericSignature();
+  LookUpConformanceInSignature conformanceLookupFn(genericSig.getPointer());
+
+  auto requirements = genericSig->getLocalRequirements(depType);
+
+  // FIXME: With the RequirementMachine, we will always have an anchor.
+  if (requirements.concreteType && !requirements.anchor) {
+    if (requirements.concreteType->is<ErrorType>())
+      return requirements.concreteType;
+
+    return mapTypeIntoContext(requirements.concreteType,
+                              conformanceLookupFn);
   }
 
-  auto *equivClass = resolved.getEquivalenceClass(builder);
+  assert(requirements.anchor && "No anchor or concrete type?");
 
-  auto genericParams = getGenericParams();
-  Type anchor = equivClass->getAnchor(builder, genericParams);
+  auto &ctx = genericSig->getASTContext();
 
   // 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>()) {
+  if (auto depMemTy = requirements.anchor->getAs<DependentMemberType>()) {
     parentArchetype =
       getOrCreateArchetypeFromInterfaceType(depMemTy->getBase())
         ->getAs<ArchetypeType>();
@@ -161,7 +147,7 @@ GenericEnvironment::getOrCreateArchetypeFromInterfaceType(Type depType) {
 
     parentArchetype->registerNestedType(name, ErrorType::get(ctx));
   } else {
-    genericParam = anchor->castTo<GenericTypeParamType>();
+    genericParam = requirements.anchor->castTo<GenericTypeParamType>();
     if (auto type = getMappingIfPresent(genericParam))
       return *type;
     addMapping(genericParam, ErrorType::get(ctx));
@@ -171,42 +157,33 @@ GenericEnvironment::getOrCreateArchetypeFromInterfaceType(Type depType) {
 
   // If this equivalence class is mapped to a concrete type, produce that
   // type.
-  if (equivClass->concreteType) {
-    result = mapTypeIntoContext(equivClass->concreteType,
-                                builder.getLookupConformanceFn());
+  if (requirements.concreteType) {
+    result = mapTypeIntoContext(requirements.concreteType,
+                                conformanceLookupFn);
   } else {
     // Substitute into the superclass.
-    Type superclass = equivClass->superclass;
+    Type superclass = requirements.superclass;
     if (superclass && superclass->hasTypeParameter()) {
       superclass = mapTypeIntoContext(superclass,
-                                      builder.getLookupConformanceFn());
+                                      conformanceLookupFn);
       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>();
+      auto *depMemTy = requirements.anchor->castTo<DependentMemberType>();
       result = NestedArchetypeType::getNew(ctx, parentArchetype, depMemTy,
-                                           protos, superclass,
-                                           equivClass->layout);
+                                           requirements.protos, superclass,
+                                           requirements.layout);
     } else {
       result = PrimaryArchetypeType::getNew(ctx, this, genericParam,
-                                            protos, superclass,
-                                            equivClass->layout);
+                                            requirements.protos, superclass,
+                                            requirements.layout);
     }
   }
 
   // Cache the new archetype for future lookups.
-  if (auto depMemTy = anchor->getAs<DependentMemberType>()) {
+  if (auto depMemTy = requirements.anchor->getAs<DependentMemberType>()) {
     parentArchetype->registerNestedType(depMemTy->getName(), result);
   } else {
     addMapping(genericParam, result);

lib/AST/GenericSignature.cpp

@@ -254,6 +254,53 @@ GenericEnvironment *GenericSignatureImpl::getGenericEnvironment() const {
   return GenericEnv;
 }
 
+GenericSignature::LocalRequirements
+GenericSignatureImpl::getLocalRequirements(Type depType) const {
+  assert(depType->isTypeParameter() && "Expected a type parameter here");
+
+  GenericSignature::LocalRequirements result;
+
+  auto &builder = *getGenericSignatureBuilder();
+
+  auto resolved =
+    builder.maybeResolveEquivalenceClass(
+                                  depType,
+                                  ArchetypeResolutionKind::CompleteWellFormed,
+                                  /*wantExactPotentialArchetype=*/false);
+  if (!resolved) {
+    result.concreteType = ErrorType::get(depType);
+    return result;
+  }
+
+  if (auto concreteType = resolved.getAsConcreteType()) {
+    result.concreteType = concreteType;
+    return result;
+  }
+
+  auto *equivClass = resolved.getEquivalenceClass(builder);
+
+  auto genericParams = getGenericParams();
+  result.anchor = equivClass->getAnchor(builder, genericParams);
+
+  if (equivClass->concreteType) {
+    result.concreteType = equivClass->concreteType;
+    return result;
+  }
+
+  result.superclass = equivClass->superclass;
+
+  for (const auto &conforms : equivClass->conformsTo) {
+    auto proto = conforms.first;
+
+    if (!equivClass->isConformanceSatisfiedBySuperclass(proto))
+      result.protos.push_back(proto);
+  }
+
+  result.layout = equivClass->layout;
+
+  return result;
+}
+
 ASTContext &GenericSignatureImpl::getASTContext() const {
   // Canonical signatures store the ASTContext directly.
   if (auto ctx = CanonicalSignatureOrASTContext.dyn_cast<ASTContext *>())