AST: GenericSignatures don't contain type variables

Author: slavapestov

include/swift/AST/GenericSignature.h

@@ -140,9 +140,6 @@ class GenericSignature {
 
   explicit operator bool() const { return Ptr != 0; }
 
-  /// Whether the given set of requirements involves a type variable.
-  static bool hasTypeVariable(ArrayRef<Requirement> requirements);
-
   friend llvm::hash_code hash_value(GenericSignature sig) {
     using llvm::hash_value;
     return hash_value(sig.getPointer());
@@ -199,9 +196,6 @@ class GenericSignature {
   /// Retrieve the requirements.
   ArrayRef<Requirement> getRequirements() const;
 
-  /// Whether this generic signature involves a type variable.
-  bool hasTypeVariable() const;
-
   /// Returns the generic environment that provides fresh contextual types
   /// (archetypes) that correspond to the interface types in this generic
   /// signature.

lib/AST/ASTContext.cpp

@@ -414,17 +414,6 @@ struct ASTContext::Implementation {
     llvm::FoldingSet<LayoutConstraintInfo> LayoutConstraints;
     llvm::FoldingSet<OpaqueTypeArchetypeType> OpaqueArchetypes;
 
-    llvm::FoldingSet<GenericSignatureImpl> GenericSignatures;
-
-    /// Stored generic signature builders for canonical generic signatures.
-    llvm::DenseMap<GenericSignature, std::unique_ptr<GenericSignatureBuilder>>
-      GenericSignatureBuilders;
-
-    /// Stored requirement machines for canonical generic signatures.
-    llvm::DenseMap<GenericSignature,
-                   std::unique_ptr<rewriting::RequirementMachine>>
-      RequirementMachines;
-
     /// The set of function types.
     llvm::FoldingSet<FunctionType> FunctionTypes;
 
@@ -485,6 +474,12 @@ struct ASTContext::Implementation {
   llvm::FoldingSet<AutoDiffDerivativeFunctionIdentifier>
       AutoDiffDerivativeFunctionIdentifiers;
 
+  llvm::FoldingSet<GenericSignatureImpl> GenericSignatures;
+
+  /// Stored generic signature builders for canonical generic signatures.
+  llvm::DenseMap<GenericSignature, std::unique_ptr<GenericSignatureBuilder>>
+    GenericSignatureBuilders;
+
   /// A cache of information about whether particular nominal types
   /// are representable in a foreign language.
   llvm::DenseMap<NominalTypeDecl *, ForeignRepresentationInfo>
@@ -542,6 +537,14 @@ struct ASTContext::Implementation {
 
   /// Memory allocation arena for the term rewriting system.
   std::unique_ptr<rewriting::RewriteContext> TheRewriteContext;
+
+  /// Stored requirement machines for canonical generic signatures.
+  ///
+  /// This should come after TheRewriteContext above, since various destructors
+  /// compile stats in the histograms stored in our RewriteContext.
+  llvm::DenseMap<GenericSignature,
+                 std::unique_ptr<rewriting::RequirementMachine>>
+    RequirementMachines;
 };
 
 ASTContext::Implementation::Implementation()
@@ -1839,28 +1842,14 @@ void ASTContext::addLoadedModule(ModuleDecl *M) {
   getImpl().LoadedModules[M->getName()] = M;
 }
 
-static AllocationArena getArena(GenericSignature genericSig) {
-  if (!genericSig)
-    return AllocationArena::Permanent;
-
-  if (genericSig.hasTypeVariable()) {
-    assert(false && "Unsubstituted type variable leaked into generic signature");
-    return AllocationArena::ConstraintSolver;
-  }
-
-  return AllocationArena::Permanent;
-}
-
 void ASTContext::registerGenericSignatureBuilder(
                                        GenericSignature sig,
                                        GenericSignatureBuilder &&builder) {
   if (LangOpts.EnableRequirementMachine == RequirementMachineMode::Enabled)
     return;
 
   auto canSig = sig.getCanonicalSignature();
-  auto arena = getArena(sig);
-  auto &genericSignatureBuilders =
-      getImpl().getArena(arena).GenericSignatureBuilders;
+  auto &genericSignatureBuilders = getImpl().GenericSignatureBuilders;
   auto known = genericSignatureBuilders.find(canSig);
   if (known != genericSignatureBuilders.end()) {
     ++NumRegisteredGenericSignatureBuildersAlready;
@@ -1882,9 +1871,7 @@ GenericSignatureBuilder *ASTContext::getOrCreateGenericSignatureBuilder(
 
   // Check whether we already have a generic signature builder for this
   // signature and module.
-  auto arena = getArena(sig);
-  auto &genericSignatureBuilders =
-      getImpl().getArena(arena).GenericSignatureBuilders;
+  auto &genericSignatureBuilders = getImpl().GenericSignatureBuilders;
   auto known = genericSignatureBuilders.find(sig);
   if (known != genericSignatureBuilders.end())
     return known->second.get();
@@ -1962,16 +1949,13 @@ GenericSignatureBuilder *ASTContext::getOrCreateGenericSignatureBuilder(
 
 rewriting::RequirementMachine *
 ASTContext::getOrCreateRequirementMachine(CanGenericSignature sig) {
-  assert(!sig.hasTypeVariable());
-
   auto &rewriteCtx = getImpl().TheRewriteContext;
   if (!rewriteCtx)
     rewriteCtx.reset(new rewriting::RewriteContext(*this));
 
   // Check whether we already have a requirement machine for this
   // signature.
-  auto arena = getArena(sig);
-  auto &machines = getImpl().getArena(arena).RequirementMachines;
+  auto &machines = getImpl().RequirementMachines;
 
   auto &machinePtr = machines[sig];
   if (machinePtr) {
@@ -2003,8 +1987,7 @@ bool ASTContext::isRecursivelyConstructingRequirementMachine(
   if (!rewriteCtx)
     return false;
 
-  auto arena = getArena(sig);
-  auto &machines = getImpl().getArena(arena).RequirementMachines;
+  auto &machines = getImpl().RequirementMachines;
 
   auto found = machines.find(sig);
   if (found == machines.end())
@@ -4489,21 +4472,21 @@ GenericSignature::get(TypeArrayView<GenericTypeParamType> params,
   assert(!params.empty());
 
 #ifndef NDEBUG
-  for (auto req : requirements)
+  for (auto req : requirements) {
     assert(req.getFirstType()->isTypeParameter());
+    assert(!req.getFirstType()->hasTypeVariable());
+    assert(req.getKind() == RequirementKind::Layout ||
+           !req.getSecondType()->hasTypeVariable());
+  }
 #endif
 
   // Check for an existing generic signature.
   llvm::FoldingSetNodeID ID;
   GenericSignatureImpl::Profile(ID, params, requirements);
 
-  auto arena = GenericSignature::hasTypeVariable(requirements)
-                   ? AllocationArena::ConstraintSolver
-                   : AllocationArena::Permanent;
-
   auto &ctx = getASTContext(params, requirements);
   void *insertPos;
-  auto &sigs = ctx.getImpl().getArena(arena).GenericSignatures;
+  auto &sigs = ctx.getImpl().GenericSignatures;
   if (auto *sig = sigs.FindNodeOrInsertPos(ID, insertPos)) {
     if (isKnownCanonical)
       sig->CanonicalSignatureOrASTContext = &ctx;
@@ -4518,7 +4501,7 @@ GenericSignature::get(TypeArrayView<GenericTypeParamType> params,
   void *mem = ctx.Allocate(bytes, alignof(GenericSignatureImpl));
   auto *newSig =
       new (mem) GenericSignatureImpl(params, requirements, isKnownCanonical);
-  ctx.getImpl().getArena(arena).GenericSignatures.InsertNode(newSig, insertPos);
+  ctx.getImpl().GenericSignatures.InsertNode(newSig, insertPos);
   return newSig;
 }
 

lib/AST/GenericSignature.cpp

@@ -1301,31 +1301,6 @@ unsigned GenericSignatureImpl::getGenericParamOrdinal(
   return GenericParamKey(param).findIndexIn(getGenericParams());
 }
 
-bool GenericSignature::hasTypeVariable() const {
-  return GenericSignature::hasTypeVariable(getRequirements());
-}
-
-bool GenericSignature::hasTypeVariable(ArrayRef<Requirement> requirements) {
-  for (const auto &req : requirements) {
-    if (req.getFirstType()->hasTypeVariable())
-      return true;
-
-    switch (req.getKind()) {
-    case RequirementKind::Layout:
-      break;
-
-    case RequirementKind::Conformance:
-    case RequirementKind::SameType:
-    case RequirementKind::Superclass:
-      if (req.getSecondType()->hasTypeVariable())
-        return true;
-      break;
-    }
-  }
-
-  return false;
-}
-
 void GenericSignature::Profile(llvm::FoldingSetNodeID &id) const {
   return GenericSignature::Profile(id, getPointer()->getGenericParams(),
                                      getPointer()->getRequirements());