RequirementMachine: Add overload of PropertyMap::lookUpProperties() that takes a pair of iterators

Author: slavapestov

lib/AST/RequirementMachine/InterfaceType.cpp

@@ -211,10 +211,10 @@ AssociatedTypeDecl *RewriteContext::getAssociatedTypeForSymbol(Symbol symbol) {
 /// If the root type is specified, we wrap it in a series of
 /// DependentMemberTypes. Otherwise, the root is computed from
 /// the first symbol of the range.
-template<typename Iter>
-Type getTypeForSymbolRange(Iter begin, Iter end, Type root,
-                           TypeArrayView<GenericTypeParamType> genericParams,
-                           const PropertyMap &map) {
+static Type
+getTypeForSymbolRange(const Symbol *begin, const Symbol *end, Type root,
+                      TypeArrayView<GenericTypeParamType> genericParams,
+                      const PropertyMap &map) {
   auto &ctx = map.getRewriteContext();
   Type result = root;
 

lib/AST/RequirementMachine/PropertyMap.cpp

@@ -235,17 +235,26 @@ PropertyMap::~PropertyMap() {
   clear();
 }
 
-/// Look for a property bag corresponding to a suffix of the given key.
+/// Look for a property bag corresponding to a suffix of the given range.
 ///
 /// Returns nullptr if no information is known about this key.
 PropertyBag *
-PropertyMap::lookUpProperties(const MutableTerm &key) const {
-  if (auto result = Trie.find(key.rbegin(), key.rend()))
+PropertyMap::lookUpProperties(std::reverse_iterator<const Symbol *> begin,
+                              std::reverse_iterator<const Symbol *> end) const {
+  if (auto result = Trie.find(begin, end))
     return *result;
 
   return nullptr;
 }
 
+/// Look for a property bag corresponding to a suffix of the given key.
+///
+/// Returns nullptr if no information is known about this key.
+PropertyBag *
+PropertyMap::lookUpProperties(const MutableTerm &key) const {
+  return lookUpProperties(key.rbegin(), key.rend());
+}
+
 /// Look for a property bag corresponding to the given key, creating a new
 /// property bag if necessary.
 ///

lib/AST/RequirementMachine/PropertyMap.h

@@ -212,6 +212,8 @@ class PropertyMap {
 
   ~PropertyMap();
 
+  PropertyBag *lookUpProperties(std::reverse_iterator<const Symbol *> begin,
+                                std::reverse_iterator<const Symbol *> end) const;
   PropertyBag *lookUpProperties(const MutableTerm &key) const;
 
   std::pair<CompletionResult, unsigned>

lib/AST/RequirementMachine/Term.cpp

@@ -51,19 +51,19 @@ struct Term::Storage final
 
 size_t Term::size() const { return Ptr->Size; }
 
-ArrayRef<Symbol>::iterator Term::begin() const {
+const Symbol *Term::begin() const {
   return Ptr->getElements().begin();
 }
 
-ArrayRef<Symbol>::iterator Term::end() const {
+const Symbol *Term::end() const {
   return Ptr->getElements().end();
 }
 
-ArrayRef<Symbol>::reverse_iterator Term::rbegin() const {
+std::reverse_iterator<const Symbol *> Term::rbegin() const {
   return Ptr->getElements().rbegin();
 }
 
-ArrayRef<Symbol>::reverse_iterator Term::rend() const {
+std::reverse_iterator<const Symbol *> Term::rend() const {
   return Ptr->getElements().rend();
 }
 
@@ -121,19 +121,16 @@ bool Term::containsUnresolvedSymbols() const {
   return false;
 }
 
-namespace {
-
 /// Shortlex order on symbol ranges.
 ///
 /// First we compare length, then perform a lexicographic comparison
 /// on symbols if the two ranges have the same length.
 ///
 /// This is used to implement Term::compare() and MutableTerm::compare()
 /// below.
-template<typename Iter>
-int shortlexCompare(Iter lhsBegin, Iter lhsEnd,
-                    Iter rhsBegin, Iter rhsEnd,
-                    RewriteContext &ctx) {
+static int shortlexCompare(const Symbol *lhsBegin, const Symbol *lhsEnd,
+                           const Symbol *rhsBegin, const Symbol *rhsEnd,
+                           RewriteContext &ctx) {
   unsigned lhsSize = (lhsEnd - lhsBegin);
   unsigned rhsSize = (rhsEnd - rhsBegin);
   if (lhsSize != rhsSize)
@@ -158,8 +155,6 @@ int shortlexCompare(Iter lhsBegin, Iter lhsEnd,
   return 0;
 }
 
-}
-
 /// Shortlex order on terms.
 int Term::compare(Term other, RewriteContext &ctx) const {
   return shortlexCompare(begin(), end(), other.begin(), other.end(), ctx);
@@ -170,14 +165,11 @@ int MutableTerm::compare(const MutableTerm &other, RewriteContext &ctx) const {
   return shortlexCompare(begin(), end(), other.begin(), other.end(), ctx);
 }
 
-/// Replace the subterm in the range [from,to) with \p rhs.
+/// Replace the subterm in the range [from,to) with \p rhs. The subrange must
+/// be part of this term itself.
 ///
-/// Note that \p rhs must precede [from,to) in the linear
-/// order on terms.
-void MutableTerm::rewriteSubTerm(
-    decltype(MutableTerm::Symbols)::iterator from,
-    decltype(MutableTerm::Symbols)::iterator to,
-    Term rhs) {
+/// Note that \p rhs must precede [from,to) in the linear order on terms.
+void MutableTerm::rewriteSubTerm(Symbol *from, Symbol *to, Term rhs) {
   auto oldSize = size();
   unsigned lhsLength = (unsigned)(to - from);
   assert(rhs.size() <= lhsLength);

lib/AST/RequirementMachine/Term.h

@@ -50,11 +50,11 @@ class Term final {
 public:
   size_t size() const;
 
-  ArrayRef<Symbol>::iterator begin() const;
-  ArrayRef<Symbol>::iterator end() const;
+  const Symbol *begin() const;
+  const Symbol *end() const;
 
-  ArrayRef<Symbol>::reverse_iterator rbegin() const;
-  ArrayRef<Symbol>::reverse_iterator rend() const;
+  std::reverse_iterator<const Symbol *> rbegin() const;
+  std::reverse_iterator<const Symbol *> rend() const;
 
   Symbol back() const;
 
@@ -115,8 +115,8 @@ class MutableTerm final {
   /// to become valid.
   MutableTerm() {}
 
-  explicit MutableTerm(decltype(Symbols)::const_iterator begin,
-                       decltype(Symbols)::const_iterator end)
+  explicit MutableTerm(const Symbol *begin,
+                       const Symbol *end)
     : Symbols(begin, end) {}
 
   explicit MutableTerm(llvm::SmallVector<Symbol, 3> &&symbols)
@@ -140,8 +140,7 @@ class MutableTerm final {
     Symbols.append(other.begin(), other.end());
   }
 
-  void append(decltype(Symbols)::const_iterator from,
-              decltype(Symbols)::const_iterator to) {
+  void append(const Symbol *from, const Symbol *to) {
     Symbols.append(from, to);
   }
 
@@ -155,17 +154,17 @@ class MutableTerm final {
     return begin()->getRootProtocols();
   }
 
-  decltype(Symbols)::const_iterator begin() const { return Symbols.begin(); }
-  decltype(Symbols)::const_iterator end() const { return Symbols.end(); }
+  const Symbol *begin() const { return Symbols.begin(); }
+  const Symbol *end() const { return Symbols.end(); }
 
-  decltype(Symbols)::iterator begin() { return Symbols.begin(); }
-  decltype(Symbols)::iterator end() { return Symbols.end(); }
+  Symbol *begin() { return Symbols.begin(); }
+  Symbol *end() { return Symbols.end(); }
 
-  decltype(Symbols)::const_reverse_iterator rbegin() const { return Symbols.rbegin(); }
-  decltype(Symbols)::const_reverse_iterator rend() const { return Symbols.rend(); }
+  std::reverse_iterator<const Symbol *> rbegin() const { return Symbols.rbegin(); }
+  std::reverse_iterator<const Symbol *> rend() const { return Symbols.rend(); }
 
-  decltype(Symbols)::reverse_iterator rbegin() { return Symbols.rbegin(); }
-  decltype(Symbols)::reverse_iterator rend() { return Symbols.rend(); }
+  std::reverse_iterator<Symbol *> rbegin() { return Symbols.rbegin(); }
+  std::reverse_iterator<Symbol *> rend() { return Symbols.rend(); }
 
   Symbol back() const {
     return Symbols.back();
@@ -183,9 +182,7 @@ class MutableTerm final {
     return Symbols[index];
   }
 
-  void rewriteSubTerm(decltype(Symbols)::iterator from,
-                      decltype(Symbols)::iterator to,
-                      Term rhs);
+  void rewriteSubTerm(Symbol *from, Symbol *to, Term rhs);
 
   void dump(llvm::raw_ostream &out) const;