fix modernize-use-nodiscard checks

Signed-off-by: Balakrishna Avulapati <ba@bavulapati.com>

Author: bavulapati

.clang-tidy

@@ -2,16 +2,18 @@
 # See https://clang.llvm.org/extra/clang-tidy/index.html
 # First disable all default checks (with -*)
 Checks: '-*,
-          bugprone-*,-bugprone-branch-clone,-bugprone-easily-swappable-parameters,-bugprone-empty-catch,
-          clang-analyzer-*,
-          clang-diagnostic-*,
-          modernize-*,
-          concurrency-*,
-          cppcoreguidelines-*,-cppcoreguidelines-rvalue-reference-param-not-moved,
-          performance-*,-performance-enum-size,
-          portability-*,
-          objc-*,
-          misc-*,-misc-no-recursion,-misc-unused-parameters,-misc-const-correctness'
+          modernize-use-nodiscard'
+# TODO(bavulapati): iterate through the rules and enable them incrementally inorder to send smaller PRs
+          # bugprone-*,-bugprone-branch-clone,-bugprone-easily-swappable-parameters,-bugprone-empty-catch,
+          # clang-analyzer-*,
+          # clang-diagnostic-*,
+          # modernize-*,
+          # concurrency-*,
+          # cppcoreguidelines-*,-cppcoreguidelines-rvalue-reference-param-not-moved,
+          # performance-*,-performance-enum-size,
+          # portability-*,
+          # objc-*,
+          # misc-*,-misc-no-recursion,-misc-unused-parameters,-misc-const-correctness'
 WarningsAsErrors: '*'
 FormatStyle: none
 UseColor: true

src/core/json/include/sourcemeta/core/json_array.h

@@ -56,31 +56,39 @@ template <typename Value> class JSONArray {
   /// Get a mutable end iterator on the array
   auto end() noexcept -> iterator { return this->data.end(); }
   /// Get a constant begin iterator on the array
-  auto begin() const noexcept -> const_iterator { return this->data.begin(); }
+  [[nodiscard]] auto begin() const noexcept -> const_iterator {
+    return this->data.begin();
+  }
   /// Get a constant end iterator on the array
-  auto end() const noexcept -> const_iterator { return this->data.end(); }
+  [[nodiscard]] auto end() const noexcept -> const_iterator {
+    return this->data.end();
+  }
   /// Get a constant begin iterator on the array
-  auto cbegin() const noexcept -> const_iterator { return this->data.cbegin(); }
+  [[nodiscard]] auto cbegin() const noexcept -> const_iterator {
+    return this->data.cbegin();
+  }
   /// Get a constant end iterator on the array
-  auto cend() const noexcept -> const_iterator { return this->data.cend(); }
+  [[nodiscard]] auto cend() const noexcept -> const_iterator {
+    return this->data.cend();
+  }
   /// Get a mutable reverse begin iterator on the array
   auto rbegin() noexcept -> reverse_iterator { return this->data.rbegin(); }
   /// Get a mutable reverse end iterator on the array
   auto rend() noexcept -> reverse_iterator { return this->data.rend(); }
   /// Get a constant reverse begin iterator on the array
-  auto rbegin() const noexcept -> const_reverse_iterator {
+  [[nodiscard]] auto rbegin() const noexcept -> const_reverse_iterator {
     return this->data.rbegin();
   }
   /// Get a constant reverse end iterator on the array
-  auto rend() const noexcept -> const_reverse_iterator {
+  [[nodiscard]] auto rend() const noexcept -> const_reverse_iterator {
     return this->data.rend();
   }
   /// Get a constant reverse begin iterator on the array
-  auto crbegin() const noexcept -> const_reverse_iterator {
+  [[nodiscard]] auto crbegin() const noexcept -> const_reverse_iterator {
     return this->data.crbegin();
   }
   /// Get a constant reverse end iterator on the array
-  auto crend() const noexcept -> const_reverse_iterator {
+  [[nodiscard]] auto crend() const noexcept -> const_reverse_iterator {
     return this->data.crend();
   }
 

src/core/json/include/sourcemeta/core/json_hash.h

@@ -14,7 +14,7 @@ template <typename T> struct HashJSON {
     return value.fast_hash();
   }
 
-  inline auto is_perfect(const hash_type) const noexcept -> bool {
+  [[nodiscard]] inline auto is_perfect(const hash_type) const noexcept -> bool {
     return false;
   }
 };
@@ -45,7 +45,8 @@ template <typename T> struct PropertyHashJSON {
     }
   };
 
-  inline auto perfect(const T &value, const std::size_t size) const noexcept
+  [[nodiscard]] inline auto perfect(const T &value,
+                                    const std::size_t size) const noexcept
       -> hash_type {
     hash_type result;
     assert(!value.empty());
@@ -134,7 +135,8 @@ template <typename T> struct PropertyHashJSON {
     }
   }
 
-  inline auto is_perfect(const hash_type &hash) const noexcept -> bool {
+  [[nodiscard]] inline auto is_perfect(const hash_type &hash) const noexcept
+      -> bool {
     // If there is anything written past the first byte,
     // then it is a perfect hash
     return hash.a > 255;

src/core/json/include/sourcemeta/core/json_object.h

@@ -46,12 +46,21 @@ template <typename Key, typename Value, typename Hash> class FlatMap {
     }
   }
 
-  auto begin() const noexcept -> const_iterator { return this->data.begin(); }
-  auto end() const noexcept -> const_iterator { return this->data.end(); }
-  auto cbegin() const noexcept -> const_iterator { return this->data.cbegin(); }
-  auto cend() const noexcept -> const_iterator { return this->data.cend(); }
+  [[nodiscard]] auto begin() const noexcept -> const_iterator {
+    return this->data.begin();
+  }
+  [[nodiscard]] auto end() const noexcept -> const_iterator {
+    return this->data.end();
+  }
+  [[nodiscard]] auto cbegin() const noexcept -> const_iterator {
+    return this->data.cbegin();
+  }
+  [[nodiscard]] auto cend() const noexcept -> const_iterator {
+    return this->data.cend();
+  }
 
-  inline auto hash(const key_type &key) const noexcept -> hash_type {
+  [[nodiscard]] inline auto hash(const key_type &key) const noexcept
+      -> hash_type {
     return this->hasher(key);
   }
 
@@ -102,7 +111,8 @@ template <typename Key, typename Value, typename Hash> class FlatMap {
   }
 
   // As a performance optimisation if the hash is known
-  inline auto find(const key_type &key, const hash_type key_hash) const
+  [[nodiscard]] inline auto find(const key_type &key,
+                                 const hash_type key_hash) const
       -> const_iterator {
     assert(this->hash(key) == key_hash);
 
@@ -129,7 +139,8 @@ template <typename Key, typename Value, typename Hash> class FlatMap {
     return this->cend();
   }
 
-  inline auto try_at(const key_type &key, const hash_type key_hash) const
+  [[nodiscard]] inline auto try_at(const key_type &key,
+                                   const hash_type key_hash) const
       -> const mapped_type * {
     assert(this->hash(key) == key_hash);
 
@@ -153,7 +164,8 @@ template <typename Key, typename Value, typename Hash> class FlatMap {
   }
 
   // As a performance optimisation if the hash is known
-  auto contains(const key_type &key, const hash_type key_hash) const -> bool {
+  [[nodiscard]] auto contains(const key_type &key,
+                              const hash_type key_hash) const -> bool {
     assert(this->hash(key) == key_hash);
 
     // Move the perfect hash condition out of the loop for extra performance
@@ -176,7 +188,8 @@ template <typename Key, typename Value, typename Hash> class FlatMap {
 
   // As a performance optimisation if the hash is known
 
-  inline auto at(const key_type &key, const hash_type key_hash) const
+  [[nodiscard]] inline auto at(const key_type &key,
+                               const hash_type key_hash) const
       -> const mapped_type & {
     assert(this->hash(key) == key_hash);
 
@@ -230,7 +243,8 @@ template <typename Key, typename Value, typename Hash> class FlatMap {
 #endif
   }
 
-  inline auto at(const size_type index) const noexcept -> const Entry & {
+  [[nodiscard]] inline auto at(const size_type index) const noexcept
+      -> const Entry & {
     return this->data[index];
   }
 
@@ -285,9 +299,13 @@ template <typename Key, typename Value, typename Hash> class FlatMap {
     return this->erase(key, this->hash(key));
   }
 
-  inline auto size() const noexcept -> size_type { return this->data.size(); }
+  [[nodiscard]] inline auto size() const noexcept -> size_type {
+    return this->data.size();
+  }
 
-  inline auto empty() const noexcept -> bool { return this->data.empty(); }
+  [[nodiscard]] inline auto empty() const noexcept -> bool {
+    return this->data.empty();
+  }
 
   inline auto clear() noexcept -> void { this->data.clear(); }
 
@@ -386,44 +404,48 @@ template <typename Key, typename Value, typename Hash> class JSONObject {
   using const_pointer = typename Container::const_pointer;
   using const_iterator = typename Container::const_iterator;
 
-  inline auto begin() const noexcept -> const_iterator {
+  [[nodiscard]] inline auto begin() const noexcept -> const_iterator {
     return this->data.begin();
   }
   /// Get a constant end iterator on the object
-  inline auto end() const noexcept -> const_iterator {
+  [[nodiscard]] inline auto end() const noexcept -> const_iterator {
     return this->data.end();
   }
   /// Get a constant begin iterator on the object
-  inline auto cbegin() const noexcept -> const_iterator {
+  [[nodiscard]] inline auto cbegin() const noexcept -> const_iterator {
     return this->data.cbegin();
   }
   /// Get a constant end iterator on the object
-  inline auto cend() const noexcept -> const_iterator {
+  [[nodiscard]] inline auto cend() const noexcept -> const_iterator {
     return this->data.cend();
   }
 
   /// Attempt to find an entry by key
-  inline auto find(const Key &key) const -> const_iterator {
+  [[nodiscard]] inline auto find(const Key &key) const -> const_iterator {
     return this->data.find(key, this->data.hash(key));
   }
 
   /// Check if an entry with the given key exists
-  inline auto defines(const Key &key,
-                      const typename Container::hash_type hash) const -> bool {
+  [[nodiscard]] inline auto
+  defines(const Key &key, const typename Container::hash_type hash) const
+      -> bool {
     return this->data.contains(key, hash);
   }
 
   /// Check the size of the object
-  inline auto size() const -> std::size_t { return this->data.size(); }
+  [[nodiscard]] inline auto size() const -> std::size_t {
+    return this->data.size();
+  }
 
   /// Access an object entry by its underlying positional index
-  inline auto at(const size_type index) const noexcept -> const
+  [[nodiscard]] inline auto at(const size_type index) const noexcept -> const
       typename Container::Entry & {
     return this->data.at(index);
   }
 
   // Hash an object property
-  inline auto hash(const Key &property) const -> typename Container::hash_type {
+  [[nodiscard]] inline auto hash(const Key &property) const ->
+      typename Container::hash_type {
     return this->data.hasher(property);
   }
 

src/core/jsonpointer/include/sourcemeta/core/jsonpointer_pointer.h

@@ -68,31 +68,39 @@ template <typename PropertyT, typename Hash> class GenericPointer {
   /// Get a mutable end iterator on the pointer
   auto end() noexcept -> iterator { return this->data.end(); }
   /// Get a constant begin iterator on the pointer
-  auto begin() const noexcept -> const_iterator { return this->data.begin(); }
+  [[nodiscard]] auto begin() const noexcept -> const_iterator {
+    return this->data.begin();
+  }
   /// Get a constant end iterator on the pointer
-  auto end() const noexcept -> const_iterator { return this->data.end(); }
+  [[nodiscard]] auto end() const noexcept -> const_iterator {
+    return this->data.end();
+  }
   /// Get a constant begin iterator on the pointer
-  auto cbegin() const noexcept -> const_iterator { return this->data.cbegin(); }
+  [[nodiscard]] auto cbegin() const noexcept -> const_iterator {
+    return this->data.cbegin();
+  }
   /// Get a constant end iterator on the pointer
-  auto cend() const noexcept -> const_iterator { return this->data.cend(); }
+  [[nodiscard]] auto cend() const noexcept -> const_iterator {
+    return this->data.cend();
+  }
   /// Get a mutable reverse begin iterator on the pointer
   auto rbegin() noexcept -> reverse_iterator { return this->data.rbegin(); }
   /// Get a mutable reverse end iterator on the pointer
   auto rend() noexcept -> reverse_iterator { return this->data.rend(); }
   /// Get a constant reverse begin iterator on the pointer
-  auto rbegin() const noexcept -> const_reverse_iterator {
+  [[nodiscard]] auto rbegin() const noexcept -> const_reverse_iterator {
     return this->data.rbegin();
   }
   /// Get a constant reverse end iterator on the pointer
-  auto rend() const noexcept -> const_reverse_iterator {
+  [[nodiscard]] auto rend() const noexcept -> const_reverse_iterator {
     return this->data.rend();
   }
   /// Get a constant reverse begin iterator on the pointer
-  auto crbegin() const noexcept -> const_reverse_iterator {
+  [[nodiscard]] auto crbegin() const noexcept -> const_reverse_iterator {
     return this->data.crbegin();
   }
   /// Get a constant reverse end iterator on the pointer
-  auto crend() const noexcept -> const_reverse_iterator {
+  [[nodiscard]] auto crend() const noexcept -> const_reverse_iterator {
     return this->data.crend();
   }
 
@@ -437,7 +445,7 @@ template <typename PropertyT, typename Hash> class GenericPointer {
   /// assert(left.concat(right) ==
   ///   sourcemeta::core::Pointer{"foo", "bar", "baz"});
   /// ```
-  auto concat(const GenericPointer<PropertyT, Hash> &other) const
+  [[nodiscard]] auto concat(const GenericPointer<PropertyT, Hash> &other) const
       -> GenericPointer<PropertyT, Hash> {
     GenericPointer<PropertyT, Hash> result{*this};
     result.push_back(other);
@@ -455,7 +463,8 @@ template <typename PropertyT, typename Hash> class GenericPointer {
   /// const sourcemeta::core::Pointer prefix{"foo", "bar"};
   /// assert(pointer.starts_with(prefix));
   /// ```
-  auto starts_with(const GenericPointer<PropertyT, Hash> &other) const -> bool {
+  [[nodiscard]] auto
+  starts_with(const GenericPointer<PropertyT, Hash> &other) const -> bool {
     return other.data.size() <= this->data.size() &&
            std::equal(other.data.cbegin(), other.data.cend(),
                       this->data.cbegin());
@@ -473,8 +482,8 @@ template <typename PropertyT, typename Hash> class GenericPointer {
   /// const sourcemeta::core::Pointer prefix{"foo", "bar", "baz"};
   /// assert(pointer.starts_with(prefix, tail));
   /// ```
-  auto starts_with(const GenericPointer<PropertyT, Hash> &other,
-                   const Token &tail) const -> bool {
+  [[nodiscard]] auto starts_with(const GenericPointer<PropertyT, Hash> &other,
+                                 const Token &tail) const -> bool {
     if (other.size() == this->size() + 1) {
       assert(!other.empty());
       return other.starts_with(*this) && other.back() == tail;
@@ -494,7 +503,8 @@ template <typename PropertyT, typename Hash> class GenericPointer {
   /// const sourcemeta::core::Pointer prefix{"foo", "bar", "qux"};
   /// assert(pointer.starts_with_initial(prefix));
   /// ```
-  auto starts_with_initial(const GenericPointer<PropertyT, Hash> &other) const
+  [[nodiscard]] auto
+  starts_with_initial(const GenericPointer<PropertyT, Hash> &other) const
       -> bool {
     const auto prefix_size{other.size()};
     if (prefix_size == 0) {
@@ -525,8 +535,9 @@ template <typename PropertyT, typename Hash> class GenericPointer {
   /// assert(pointer.rebase(prefix, replacement) ==
   ///   sourcemeta::core::Pointer{"qux", "baz"});
   /// ```
-  auto rebase(const GenericPointer<PropertyT, Hash> &prefix,
-              const GenericPointer<PropertyT, Hash> &replacement) const
+  [[nodiscard]] auto
+  rebase(const GenericPointer<PropertyT, Hash> &prefix,
+         const GenericPointer<PropertyT, Hash> &replacement) const
       -> GenericPointer<PropertyT, Hash> {
     typename Container::size_type index{0};
     while (index < prefix.size()) {
@@ -560,7 +571,8 @@ template <typename PropertyT, typename Hash> class GenericPointer {
   ///
   /// If the JSON Pointer is not relative to the base, a copy of the original
   /// input pointer is returned.
-  auto resolve_from(const GenericPointer<PropertyT, Hash> &base) const
+  [[nodiscard]] auto
+  resolve_from(const GenericPointer<PropertyT, Hash> &base) const
       -> GenericPointer<PropertyT, Hash> {
     typename Container::size_type index{0};
     while (index < base.size()) {

src/core/jsonpointer/include/sourcemeta/core/jsonpointer_position.h

@@ -51,8 +51,9 @@ class SOURCEMETA_CORE_JSONPOINTER_EXPORT PointerPositionTracker {
   auto operator()(const JSON::ParsePhase phase, const JSON::Type,
                   const std::uint64_t line, const std::uint64_t column,
                   const JSON &value) -> void;
-  auto get(const Pointer &pointer) const -> std::optional<Position>;
-  auto size() const -> std::size_t;
+  [[nodiscard]] auto get(const Pointer &pointer) const
+      -> std::optional<Position>;
+  [[nodiscard]] auto size() const -> std::size_t;
 
 private:
 // Exporting symbols that depends on the standard C++ library is considered