RequirementMachine: Move RequirementMachine class to swift::rewriting namespace

Author: slavapestov

include/swift/AST/ASTContext.h

@@ -112,7 +112,6 @@ namespace swift {
   class TupleTypeElt;
   class EnumElementDecl;
   class ProtocolDecl;
-  class RequirementMachine;
   class SubstitutableType;
   class SourceManager;
   class ValueDecl;
@@ -135,6 +134,10 @@ namespace namelookup {
   class ImportCache;
 }
 
+namespace rewriting {
+  class RequirementMachine;
+}
+
 namespace syntax {
   class SyntaxArena;
 }
@@ -1160,7 +1163,7 @@ class ASTContext final {
 
   /// Retrieve or create a term rewriting system for answering queries on
   /// type parameters written against the given generic signature.
-  RequirementMachine *getOrCreateRequirementMachine(
+  rewriting::RequirementMachine *getOrCreateRequirementMachine(
       CanGenericSignature sig);
 
   /// Retrieve a generic signature with a single unconstrained type parameter,

include/swift/AST/GenericSignature.h

@@ -33,10 +33,13 @@ namespace swift {
 class GenericSignatureBuilder;
 class ProtocolConformanceRef;
 class ProtocolType;
-class RequirementMachine;
 class SubstitutionMap;
 class GenericEnvironment;
 
+namespace rewriting {
+  class RequirementMachine;
+}
+
 /// An access path used to find a particular protocol conformance within
 /// a generic signature.
 ///
@@ -82,7 +85,7 @@ class ConformanceAccessPath {
 
   friend class GenericSignatureImpl;
   friend class GenericSignatureBuilder;
-  friend class RequirementMachine;
+  friend class rewriting::RequirementMachine;
 
 public:
   typedef const Entry *const_iterator;
@@ -320,7 +323,7 @@ class alignas(1 << TypeAlignInBits) GenericSignatureImpl final
   GenericSignatureBuilder *getGenericSignatureBuilder() const;
 
   /// Retrieve the requirement machine for the given generic signature.
-  RequirementMachine *getRequirementMachine() const;
+  rewriting::RequirementMachine *getRequirementMachine() const;
 
   /// Collects a set of requirements on a type parameter. Used by
   /// GenericEnvironment for building archetypes.

lib/AST/ASTContext.cpp

@@ -420,7 +420,8 @@ struct ASTContext::Implementation {
       GenericSignatureBuilders;
 
     /// Stored requirement machines for canonical generic signatures.
-    llvm::DenseMap<GenericSignature, std::unique_ptr<RequirementMachine>>
+    llvm::DenseMap<GenericSignature,
+                   std::unique_ptr<rewriting::RequirementMachine>>
       RequirementMachines;
 
     /// The set of function types.
@@ -1892,8 +1893,8 @@ GenericSignatureBuilder *ASTContext::getOrCreateGenericSignatureBuilder(
   return builder;
 }
 
-RequirementMachine *ASTContext::getOrCreateRequirementMachine(
-    CanGenericSignature sig) {
+rewriting::RequirementMachine *
+ASTContext::getOrCreateRequirementMachine(CanGenericSignature sig) {
   assert(!sig.hasTypeVariable());
 
   auto &rewriteCtx = getImpl().TheRewriteContext;
@@ -1917,7 +1918,7 @@ RequirementMachine *ASTContext::getOrCreateRequirementMachine(
     return machine;
   }
 
-  auto *machine = new RequirementMachine(*rewriteCtx);
+  auto *machine = new rewriting::RequirementMachine(*rewriteCtx);
 
   // Store this requirement machine before adding the signature,
   // to catch re-entrant construction via addGenericSignature()

lib/AST/GenericSignature.cpp

@@ -191,7 +191,7 @@ GenericSignatureImpl::getGenericSignatureBuilder() const {
                                              CanGenericSignature(this));
 }
 
-RequirementMachine *
+rewriting::RequirementMachine *
 GenericSignatureImpl::getRequirementMachine() const {
   // The requirement machine is associated with the canonical signature.
   if (!isCanonical())

lib/AST/RequirementMachine/RequirementMachine.h

@@ -21,10 +21,6 @@ class raw_ostream;
 
 namespace swift {
 
-namespace rewriting {
-class RewriteContext;
-}
-
 class ASTContext;
 class AssociatedTypeDecl;
 class CanType;
@@ -34,17 +30,20 @@ class ProtocolDecl;
 class Requirement;
 class Type;
 
+namespace rewriting {
+class RewriteContext;
+
 /// Wraps a rewrite system with higher-level operations in terms of
 /// generic signatures and interface types.
 class RequirementMachine final {
-  friend class ASTContext;
+  friend class swift::ASTContext;
 
   struct Implementation;
 
   ASTContext &Context;
   Implementation *Impl;
 
-  explicit RequirementMachine(rewriting::RewriteContext &rewriteCtx);
+  explicit RequirementMachine(RewriteContext &rewriteCtx);
 
   RequirementMachine(const RequirementMachine &) = delete;
   RequirementMachine(RequirementMachine &&) = delete;
@@ -82,6 +81,8 @@ class RequirementMachine final {
   void dump(llvm::raw_ostream &out) const;
 };
 
+} // end namespace rewriting
+
 } // end namespace swift
 
 #endif

lib/AST/RequirementMachine/RequirementMachineImpl.h

@@ -26,11 +26,13 @@
 
 namespace swift {
 
+namespace rewriting {
+
 /// We use the PIMPL pattern to avoid creeping header dependencies.
 struct RequirementMachine::Implementation {
-  rewriting::RewriteContext &Context;
-  rewriting::RewriteSystem System;
-  rewriting::PropertyMap Map;
+  RewriteContext &Context;
+  RewriteSystem System;
+  PropertyMap Map;
   CanGenericSignature Sig;
   bool Complete = false;
 
@@ -45,17 +47,18 @@ struct RequirementMachine::Implementation {
   std::vector<std::pair<CanType, ConformanceAccessPath>>
       CurrentConformanceAccessPaths;
 
-  explicit Implementation(rewriting::RewriteContext &ctx)
+  explicit Implementation(RewriteContext &ctx)
       : Context(ctx),
         System(Context),
         Map(Context, System.getProtocols()) {}
-  void verify(const rewriting::MutableTerm &term);
+  void verify(const MutableTerm &term);
   void dump(llvm::raw_ostream &out);
 
-  rewriting::MutableTerm getLongestValidPrefix(
-      const rewriting::MutableTerm &term);
+  MutableTerm getLongestValidPrefix(const MutableTerm &term);
 };
 
 }
 
+}
+
 #endif