AST: Move mapType{In,OutOf}Context() out of ArchetypeBuilder and clean up headers

- The DeclContext versions of these methods have equivalents
  on the DeclContext class; use them instead.

- The GenericEnvironment versions of these methods are now
  static methods on the GenericEnvironment class. Note that
  these are not made redundant by the instance methods on
  GenericEnvironment, since the static methods can also be
  called with a null GenericEnvironment, in which case they
  just assert that the type is fully concrete.

- Remove some unnecessary #includes of ArchetypeBuilder.h
  and GenericEnvironment.h. Now changes to these files
  result in a lot less recompilation.

Author: slavapestov

include/swift/AST/ASTContext.h

@@ -18,7 +18,6 @@
 #define SWIFT_AST_ASTCONTEXT_H
 
 #include "llvm/Support/DataTypes.h"
-#include "swift/AST/ArchetypeBuilder.h"
 #include "swift/AST/ClangModuleLoader.h"
 #include "swift/AST/Identifier.h"
 #include "swift/AST/ProtocolConformance.h"
@@ -69,6 +68,7 @@ namespace swift {
   class TypeVariableType;
   class TupleType;
   class FunctionType;
+  class ArchetypeBuilder;
   class ArchetypeType;
   class Identifier;
   class InheritedNameSet;
@@ -825,25 +825,7 @@ class ASTContext {
                         DeclContext *gpContext,
                         ArrayRef<Substitution> Subs) const;
 
-  /// Retrieve the archetype builder and potential archetype
-  /// corresponding to the given archetype type.
-  ///
-  /// This facility is only used by the archetype builder when forming
-  /// archetypes.a
-  std::pair<ArchetypeBuilder *, ArchetypeBuilder::PotentialArchetype *>
-  getLazyArchetype(const ArchetypeType *archetype);
-
-  /// Register information for a lazily-constructed archetype.
-  void registerLazyArchetype(
-         const ArchetypeType *archetype,
-         ArchetypeBuilder &builder,
-         ArchetypeBuilder::PotentialArchetype *potentialArchetype);
-
-  /// Unregister information about the given lazily-constructed archetype.
-  void unregisterLazyArchetype(const ArchetypeType *archetype);
-
   friend ArchetypeType;
-  friend ArchetypeBuilder::PotentialArchetype;
 
   /// Provide context-level uniquing for SIL lowered type layouts and boxes.
   friend SILLayout;

include/swift/AST/AnyFunctionRef.h

@@ -14,7 +14,6 @@
 #define SWIFT_AST_ANY_FUNCTION_REF_H
 
 #include "swift/Basic/LLVM.h"
-#include "swift/AST/ArchetypeBuilder.h"
 #include "swift/AST/Decl.h"
 #include "swift/AST/Expr.h"
 #include "swift/AST/Types.h"
@@ -83,8 +82,7 @@ class AnyFunctionRef {
   Type getBodyResultType() const {
     if (auto *AFD = TheFunction.dyn_cast<AbstractFunctionDecl *>()) {
       if (auto *FD = dyn_cast<FuncDecl>(AFD))
-        return ArchetypeBuilder::mapTypeIntoContext(
-            FD, FD->getResultInterfaceType());
+        return FD->mapTypeIntoContext(FD->getResultInterfaceType());
       return TupleType::getEmpty(AFD->getASTContext());
     }
     return TheFunction.get<AbstractClosureExpr *>()->getResultType();

include/swift/AST/ArchetypeBuilder.h

@@ -303,21 +303,6 @@ class ArchetypeBuilder {
   /// For any type that cannot refer to an archetype, this routine returns null.
   PotentialArchetype *resolveArchetype(Type type);
 
-  /// Map an interface type to a contextual type.
-  static Type mapTypeIntoContext(const DeclContext *dc, Type type);
-
-  /// Map an interface type to a contextual type.
-  static Type mapTypeIntoContext(ModuleDecl *M,
-                                 GenericEnvironment *genericEnv,
-                                 Type type);
-
-  /// Map a contextual type to an interface type.
-  static Type mapTypeOutOfContext(const DeclContext *dc, Type type);
-
-  /// Map a contextual type to an interface type.
-  static Type mapTypeOutOfContext(GenericEnvironment *genericEnv,
-                                  Type type);
-
   /// \brief Dump all of the requirements, both specified and inferred.
   LLVM_ATTRIBUTE_DEPRECATED(
       void dump(),

include/swift/AST/Decl.h

@@ -22,7 +22,6 @@
 #include "swift/AST/ClangNode.h"
 #include "swift/AST/ConcreteDeclRef.h"
 #include "swift/AST/DefaultArgumentKind.h"
-#include "swift/AST/GenericEnvironment.h"
 #include "swift/AST/GenericSignature.h"
 #include "swift/AST/GenericParamKey.h"
 #include "swift/AST/LazyResolver.h"
@@ -37,7 +36,6 @@
 namespace swift {
   enum class AccessSemantics : unsigned char;
   class ApplyExpr;
-  class ArchetypeBuilder;
   class GenericEnvironment;
   class ArchetypeType;
   class ASTContext;
@@ -1495,44 +1493,18 @@ class ExtensionDecl final : public Decl, public DeclContext,
   }
 
   /// Retrieve the generic signature for this type.
-  GenericSignature *getGenericSignature() const {
-    if (auto genericEnv = GenericSigOrEnv.dyn_cast<GenericEnvironment *>())
-      return genericEnv->getGenericSignature();
-
-    if (auto genericSig = GenericSigOrEnv.dyn_cast<GenericSignature *>())
-      return genericSig;
-
-    return nullptr;
-  }
+  GenericSignature *getGenericSignature() const;
 
   /// Retrieve the generic context for this type.
-  GenericEnvironment *getGenericEnvironment() const {
-    // Fast case: we already have a generic environment.
-    if (auto genericEnv = GenericSigOrEnv.dyn_cast<GenericEnvironment *>())
-      return genericEnv;
-
-    // If we only have a generic signature, build the generic environment.
-    if (GenericSigOrEnv.dyn_cast<GenericSignature *>())
-      return getLazyGenericEnvironmentSlow();
-
-    return nullptr;
-  }
+  GenericEnvironment *getGenericEnvironment() const;
 
   /// Set a lazy generic environment.
   void setLazyGenericEnvironment(LazyMemberLoader *lazyLoader,
                                  GenericSignature *genericSig,
                                  uint64_t genericEnvData);
 
   /// Set the generic context of this extension.
-  void setGenericEnvironment(GenericEnvironment *genericEnv) {
-    assert((GenericSigOrEnv.isNull() ||
-            getGenericSignature()->getCanonicalSignature() ==
-              genericEnv->getGenericSignature()->getCanonicalSignature()) &&
-           "set a generic environment with a different generic signature");
-    this->GenericSigOrEnv = genericEnv;
-    if (genericEnv)
-      genericEnv->setOwningDeclContext(this);
-  }
+  void setGenericEnvironment(GenericEnvironment *genericEnv);
 
   /// Retrieve the type being extended.
   Type getExtendedType() const { return ExtendedType.getType(); }
@@ -2322,28 +2294,10 @@ class GenericTypeDecl : public TypeDecl, public DeclContext {
   }
 
   /// Retrieve the generic signature for this type.
-  GenericSignature *getGenericSignature() const {
-    if (auto genericEnv = GenericSigOrEnv.dyn_cast<GenericEnvironment *>())
-      return genericEnv->getGenericSignature();
-
-    if (auto genericSig = GenericSigOrEnv.dyn_cast<GenericSignature *>())
-      return genericSig;
-
-    return nullptr;
-  }
+  GenericSignature *getGenericSignature() const;
 
   /// Retrieve the generic context for this type.
-  GenericEnvironment *getGenericEnvironment() const {
-    // Fast case: we already have a generic environment.
-    if (auto genericEnv = GenericSigOrEnv.dyn_cast<GenericEnvironment *>())
-      return genericEnv;
-
-    // If we only have a generic signature, build the generic environment.
-    if (GenericSigOrEnv.dyn_cast<GenericSignature *>())
-      return getLazyGenericEnvironmentSlow();
-
-    return nullptr;
-  }
+  GenericEnvironment *getGenericEnvironment() const;
 
   void setIsValidatingGenericSignature(bool validating=true) {
     ValidatingGenericSignature = validating;
@@ -2359,16 +2313,7 @@ class GenericTypeDecl : public TypeDecl, public DeclContext {
                                  uint64_t genericEnvData);
 
   /// Set the generic context of this function.
-  void setGenericEnvironment(GenericEnvironment *genericEnv) {
-    assert((GenericSigOrEnv.isNull() ||
-            getGenericSignature()->getCanonicalSignature() ==
-              genericEnv->getGenericSignature()->getCanonicalSignature()) &&
-           "set a generic environment with a different generic signature");
-    this->GenericSigOrEnv = genericEnv;
-
-    if (genericEnv)
-      genericEnv->setOwningDeclContext(this);
-  }
+  void setGenericEnvironment(GenericEnvironment *genericEnv);
 
   // Resolve ambiguity due to multiple base classes.
   using TypeDecl::getASTContext;
@@ -4642,45 +4587,18 @@ class AbstractFunctionDecl : public ValueDecl, public DeclContext {
   bool isTransparent() const;
 
   /// Retrieve the generic signature for this function.
-  GenericSignature *getGenericSignature() const {
-    if (auto genericEnv = GenericSigOrEnv.dyn_cast<GenericEnvironment *>())
-      return genericEnv->getGenericSignature();
-
-    if (auto genericSig = GenericSigOrEnv.dyn_cast<GenericSignature *>())
-      return genericSig;
-
-    return nullptr;
-  }
+  GenericSignature *getGenericSignature() const;
 
   /// Retrieve the generic context for this function.
-  GenericEnvironment *getGenericEnvironment() const {
-    // Fast case: we already have a generic environment.
-    if (auto genericEnv = GenericSigOrEnv.dyn_cast<GenericEnvironment *>())
-      return genericEnv;
-
-    // If we only have a generic signature, build the generic environment.
-    if (GenericSigOrEnv.dyn_cast<GenericSignature *>())
-      return getLazyGenericEnvironmentSlow();
-
-    return nullptr;
-  }
+  GenericEnvironment *getGenericEnvironment() const;
 
   /// Set a lazy generic environment.
   void setLazyGenericEnvironment(LazyMemberLoader *lazyLoader,
                                  GenericSignature *genericSig,
                                  uint64_t genericEnvData);
 
   /// Set the generic context of this function.
-  void setGenericEnvironment(GenericEnvironment *genericEnv) {
-    assert((GenericSigOrEnv.isNull() ||
-            getGenericSignature()->getCanonicalSignature() ==
-              genericEnv->getGenericSignature()->getCanonicalSignature()) &&
-           "set a generic environment with a different generic signature");
-    this->GenericSigOrEnv = genericEnv;
-
-    if (genericEnv)
-      genericEnv->setOwningDeclContext(this);
-  }
+  void setGenericEnvironment(GenericEnvironment *genericEnv);
 
   // Expose our import as member status
   bool isImportAsMember() const { return IAMStatus.isImportAsMember(); }

include/swift/AST/GenericEnvironment.h

@@ -196,6 +196,15 @@ class alignas(1 << DeclAlignInBits) GenericEnvironment final
     return Mem; 
   }
 
+  /// Map an interface type to a contextual type.
+  static Type mapTypeIntoContext(ModuleDecl *M,
+                                 GenericEnvironment *genericEnv,
+                                 Type type);
+
+  /// Map a contextual type to an interface type.
+  static Type mapTypeOutOfContext(GenericEnvironment *genericEnv,
+                                  Type type);
+
   /// Map a contextual type to an interface type.
   Type mapTypeOutOfContext(Type type) const;
 

include/swift/AST/TypeRepr.h

@@ -19,7 +19,6 @@
 
 #include "swift/AST/Attr.h"
 #include "swift/AST/DeclContext.h"
-#include "swift/AST/GenericEnvironment.h"
 #include "swift/AST/Identifier.h"
 #include "swift/AST/Type.h"
 #include "swift/AST/TypeAlignments.h"
@@ -32,6 +31,7 @@
 namespace swift {
   class ASTWalker;
   class DeclContext;
+  class GenericEnvironment;
   class IdentTypeRepr;
   class ValueDecl;
 
@@ -413,9 +413,6 @@ class FunctionTypeRepr : public TypeRepr {
 
   GenericParamList *getGenericParams() const { return GenericParams; }
   GenericEnvironment *getGenericEnvironment() const { return GenericEnv; }
-  GenericSignature *getGenericSignature() const {
-    return GenericEnv ? GenericEnv->getGenericSignature() : nullptr;
-  }
 
   void setGenericEnvironment(GenericEnvironment *genericEnv) {
     assert(GenericEnv == nullptr);
@@ -915,9 +912,6 @@ class SILBoxTypeRepr : public TypeRepr {
   GenericParamList *getGenericParams() const {
     return GenericParams;
   }
-  GenericSignature *getGenericSignature() const {
-    return GenericEnv->getGenericSignature();
-  }
   GenericEnvironment *getGenericEnvironment() const {
     return GenericEnv;
   }

include/swift/AST/Witness.h

@@ -158,15 +158,6 @@ class Witness {
     return getDeclRef().getSubstitutions();
   }
 
-  /// Retrieve the generic signature of the synthetic environment.
-  GenericSignature *getSyntheticSignature() const {
-    assert(requiresSubstitution() && "No substitutions required for witness");
-    if (auto *env = getSyntheticEnvironment())
-      return env->getGenericSignature();
-    else
-      return nullptr;
-  }
-
   /// Retrieve the synthetic generic environment.
   GenericEnvironment *getSyntheticEnvironment() const {
     assert(requiresSubstitution() && "No substitutions required for witness");

lib/AST/ASTMangler.cpp

@@ -586,8 +586,8 @@ void ASTMangler::appendType(Type type) {
 
       // Find the archetype information.
       const DeclContext *DC = DeclCtx;
-      auto GTPT = ArchetypeBuilder::mapTypeOutOfContext(DC, archetype)
-                    ->castTo<GenericTypeParamType>();
+      auto GTPT = DC->mapTypeOutOfContext(archetype)
+          ->castTo<GenericTypeParamType>();
 
       if (DWARFMangling) {
         Buffer << 'q' << Index(GTPT->getIndex());
@@ -1390,7 +1390,7 @@ void ASTMangler::appendClosureComponents(Type Ty, unsigned discriminator,
   if (!Ty)
     Ty = ErrorType::get(localContext->getASTContext());
 
-  Ty = ArchetypeBuilder::mapTypeOutOfContext(parentContext, Ty);
+  Ty = parentContext->mapTypeOutOfContext(Ty);
   appendType(Ty->getCanonicalType());
   appendOperator(isImplicit ? "fu" : "fU", Index(discriminator));
 }

lib/AST/ASTPrinter.cpp

@@ -17,7 +17,6 @@
 #include "swift/AST/ASTPrinter.h"
 #include "swift/AST/ASTContext.h"
 #include "swift/AST/ASTVisitor.h"
-#include "swift/AST/ArchetypeBuilder.h"
 #include "swift/AST/Attr.h"
 #include "swift/AST/Decl.h"
 #include "swift/AST/Expr.h"
@@ -855,8 +854,7 @@ class PrintAST : public ASTVisitor<PrintAST> {
       if (T->hasArchetype()) {
         // Get the interface type, since TypeLocs still have
         // contextual types in them.
-        T = ArchetypeBuilder::mapTypeOutOfContext(
-            Current->getInnermostDeclContext(), T);
+        T = Current->getInnermostDeclContext()->mapTypeOutOfContext(T);
       }
 
       // Get the innermost nominal type context.

lib/AST/ASTVerifier.cpp

@@ -16,7 +16,6 @@
 
 #include "swift/Subsystems.h"
 #include "swift/AST/AccessScope.h"
-#include "swift/AST/ArchetypeBuilder.h"
 #include "swift/AST/AST.h"
 #include "swift/AST/ASTContext.h"
 #include "swift/AST/ASTWalker.h"
@@ -705,7 +704,7 @@ struct ASTNodeBase {};
       Type resultType;
       if (FuncDecl *FD = dyn_cast<FuncDecl>(func)) {
         resultType = FD->getResultInterfaceType();
-        resultType = ArchetypeBuilder::mapTypeIntoContext(FD, resultType);
+        resultType = FD->mapTypeIntoContext(resultType);
       } else if (auto closure = dyn_cast<AbstractClosureExpr>(func)) {
         resultType = closure->getResultType();
       } else {
@@ -1739,17 +1738,15 @@ struct ASTNodeBase {};
       Type typeForAccessors =
           var->getInterfaceType()->getReferenceStorageReferent();
       typeForAccessors =
-          ArchetypeBuilder::mapTypeIntoContext(var->getDeclContext(),
-                                               typeForAccessors);
+          var->getDeclContext()->mapTypeIntoContext(typeForAccessors);
       if (const FuncDecl *getter = var->getGetter()) {
         if (getter->getParameterLists().back()->size() != 0) {
           Out << "property getter has parameters\n";
           abort();
         }
         Type getterResultType = getter->getResultInterfaceType();
         getterResultType =
-            ArchetypeBuilder::mapTypeIntoContext(var->getDeclContext(),
-                                                 getterResultType);
+            var->getDeclContext()->mapTypeIntoContext(getterResultType);
         if (!getterResultType->isEqual(typeForAccessors)) {
           Out << "property and getter have mismatched types: '";
           typeForAccessors.print(Out);
@@ -1775,8 +1772,7 @@ struct ASTNodeBase {};
         }
         const ParamDecl *param = setter->getParameterLists().back()->get(0);
         Type paramType = param->getInterfaceType();
-        paramType = ArchetypeBuilder::mapTypeIntoContext(var->getDeclContext(),
-                                                         paramType);
+        paramType = var->getDeclContext()->mapTypeIntoContext(paramType);
         if (!paramType->isEqual(typeForAccessors)) {
           Out << "property and setter param have mismatched types: '";
           typeForAccessors.print(Out);