[llvm][ADT] Some AddressRanges.h improvements

- Add `const`-qualifications to parameters where applicable.
- Rename parameter to adhere to the project's parameter naming
convention.
- Remove redundant template argument.
- Add pointer-qualifications to `auto`-typed variables that are deduced
to pointers.
- Remove redundant name-qualification.
- Change non-explicit conversion operator to an explicit one to avoid
surprising implicit conversions.

Author: VoltrexKeyva

llvm/include/llvm/ADT/AddressRanges.h

@@ -22,14 +22,16 @@ namespace llvm {
 class AddressRange {
 public:
   AddressRange() {}
-  AddressRange(uint64_t S, uint64_t E) : Start(S), End(E) {
+  AddressRange(const uint64_t S, const uint64_t E) : Start(S), End(E) {
     assert(Start <= End);
   }
   uint64_t start() const { return Start; }
   uint64_t end() const { return End; }
   uint64_t size() const { return End - Start; }
   uint64_t empty() const { return size() == 0; }
-  bool contains(uint64_t Addr) const { return Start <= Addr && Addr < End; }
+  bool contains(const uint64_t Addr) const {
+    return Start <= Addr && Addr < End;
+  }
   bool contains(const AddressRange &R) const {
     return Start <= R.Start && R.End <= End;
   }
@@ -63,16 +65,16 @@ template <typename T> class AddressRangesBase {
 public:
   void clear() { Ranges.clear(); }
   bool empty() const { return Ranges.empty(); }
-  bool contains(uint64_t Addr) const {
+  bool contains(const uint64_t Addr) const {
     return find(Addr, Addr + 1) != Ranges.end();
   }
-  bool contains(AddressRange Range) const {
+  bool contains(const AddressRange Range) const {
     return find(Range.start(), Range.end()) != Ranges.end();
   }
   void reserve(size_t Capacity) { Ranges.reserve(Capacity); }
   size_t size() const { return Ranges.size(); }
 
-  std::optional<T> getRangeThatContains(uint64_t Addr) const {
+  std::optional<T> getRangeThatContains(const uint64_t Addr) const {
     typename Collection::const_iterator It = find(Addr, Addr + 1);
     if (It == Ranges.end())
       return std::nullopt;
@@ -83,17 +85,18 @@ template <typename T> class AddressRangesBase {
   typename Collection::const_iterator begin() const { return Ranges.begin(); }
   typename Collection::const_iterator end() const { return Ranges.end(); }
 
-  const T &operator[](size_t i) const {
-    assert(i < Ranges.size());
-    return Ranges[i];
+  const T &operator[](size_t I) const {
+    assert(I < Ranges.size());
+    return Ranges[I];
   }
 
-  bool operator==(const AddressRangesBase<T> &RHS) const {
+  bool operator==(const AddressRangesBase &RHS) const {
     return Ranges == RHS.Ranges;
   }
 
 protected:
-  typename Collection::const_iterator find(uint64_t Start, uint64_t End) const {
+  typename Collection::const_iterator find(const uint64_t Start,
+                                           const uint64_t End) const {
     if (Start >= End)
       return Ranges.end();
 
@@ -124,8 +127,8 @@ class AddressRanges : public AddressRangesBase<AddressRange> {
     if (Range.empty())
       return Ranges.end();
 
-    auto It = llvm::upper_bound(Ranges, Range);
-    auto It2 = It;
+    auto *It = upper_bound(Ranges, Range);
+    auto *It2 = It;
     while (It2 != Ranges.end() && It2->start() <= Range.end())
       ++It2;
     if (It != It2) {
@@ -144,7 +147,7 @@ class AddressRanges : public AddressRangesBase<AddressRange> {
 
 class AddressRangeValuePair {
 public:
-  operator AddressRange() const { return Range; }
+  explicit operator AddressRange() const { return Range; }
 
   AddressRange Range;
   int64_t Value = 0;
@@ -164,15 +167,15 @@ inline bool operator==(const AddressRangeValuePair &LHS,
 /// ranges are not combined during insertion.
 class AddressRangesMap : public AddressRangesBase<AddressRangeValuePair> {
 public:
-  void insert(AddressRange Range, int64_t Value) {
+  void insert(AddressRange Range, const int64_t Value) {
     if (Range.empty())
       return;
 
     // Search for range which is less than or equal incoming Range.
-    auto It = std::partition_point(Ranges.begin(), Ranges.end(),
-                                   [=](const AddressRangeValuePair &R) {
-                                     return R.Range.start() <= Range.start();
-                                   });
+    auto *It = std::partition_point(Ranges.begin(), Ranges.end(),
+                                    [=](const AddressRangeValuePair &R) {
+                                      return R.Range.start() <= Range.start();
+                                    });
 
     if (It != Ranges.begin())
       It--;