Add more lifetime annotations

Morwenn · Morwenn · commit 393ac87c2c01 · 2025-10-04T11:17:28.000+02:00
diff --git a/include/cpp-sort/detail/associate_iterator.h b/include/cpp-sort/detail/associate_iterator.h
@@ -11,6 +11,7 @@
 #include <iterator>
 #include <utility>
 #include <cpp-sort/utility/iter_move.h>
+#include "config.h"
 #include "iterator_traits.h"
 
 namespace cppsort::detail
@@ -62,6 +63,7 @@ namespace cppsort::detail
         {}
 
         auto operator=(association&& other) noexcept
+            CPPSORT_LIFETIME_BOUND
             -> association&
         {
             *it = std::move(*other.it);
@@ -70,6 +72,7 @@ namespace cppsort::detail
         }
 
         auto operator=(associated_value<value_type_t<Iterator>, Data>&& other)
+            CPPSORT_LIFETIME_BOUND
             -> association&
         {
             *it = std::move(other.value);
@@ -124,6 +127,7 @@ namespace cppsort::detail
         {}
 
         auto operator=(associated_value&& other)
+            CPPSORT_LIFETIME_BOUND
             -> associated_value&
         {
             value = std::move(other.value);
@@ -133,13 +137,15 @@ namespace cppsort::detail
 
         [[nodiscard]]
         auto get()
+            CPPSORT_LIFETIME_BOUND
             -> Value&
         {
             return value;
         }
 
         [[nodiscard]]
         auto get() const
+            CPPSORT_LIFETIME_BOUND
             -> const Value&
         {
             return value;
@@ -207,27 +213,31 @@ namespace cppsort::detail
             // Increment/decrement operators
 
             auto operator++()
+                CPPSORT_LIFETIME_BOUND
                 -> associate_iterator&
             {
                 ++_it;
                 return *this;
             }
 
             auto operator--()
+                CPPSORT_LIFETIME_BOUND
                 -> associate_iterator&
             {
                 --_it;
                 return *this;
             }
 
             auto operator+=(difference_type increment)
+                CPPSORT_LIFETIME_BOUND
                 -> associate_iterator&
             {
                 _it += increment;
                 return *this;
             }
 
             auto operator-=(difference_type increment)
+                CPPSORT_LIFETIME_BOUND
                 -> associate_iterator&
             {
                 _it -= increment;
diff --git a/include/cpp-sort/detail/fake_category_iterator.h b/include/cpp-sort/detail/fake_category_iterator.h
@@ -12,6 +12,7 @@
 #include <type_traits>
 #include <utility>
 #include <cpp-sort/utility/iter_move.h>
+#include "config.h"
 #include "iterator_traits.h"
 #include "type_traits.h"
 
@@ -84,6 +85,7 @@ namespace cppsort::detail
             // Increment/decrement operators
 
             auto operator++()
+                CPPSORT_LIFETIME_BOUND
                 -> fake_category_iterator&
             {
                 ++_it;
@@ -99,6 +101,7 @@ namespace cppsort::detail
             }
 
             auto operator--()
+                CPPSORT_LIFETIME_BOUND
                 -> fake_category_iterator&
             {
                 --_it;
@@ -114,13 +117,15 @@ namespace cppsort::detail
             }
 
             auto operator+=(difference_type increment)
+                CPPSORT_LIFETIME_BOUND
                 -> fake_category_iterator&
             {
                 _it += increment;
                 return *this;
             }
 
             auto operator-=(difference_type increment)
+                CPPSORT_LIFETIME_BOUND
                 -> fake_category_iterator&
             {
                 _it -= increment;
diff --git a/include/cpp-sort/detail/fixed_size_list.h b/include/cpp-sort/detail/fixed_size_list.h
@@ -308,6 +308,7 @@ namespace cppsort::detail
             // Increment/decrement operators
 
             auto operator++() noexcept
+                CPPSORT_LIFETIME_BOUND
                 -> fixed_size_list_iterator&
             {
                 ptr_ = ptr_->next;
@@ -323,6 +324,7 @@ namespace cppsort::detail
             }
 
             auto operator--() noexcept
+                CPPSORT_LIFETIME_BOUND
                 -> fixed_size_list_iterator&
             {
                 ptr_ = ptr_->prev;
diff --git a/include/cpp-sort/detail/memory.h b/include/cpp-sort/detail/memory.h
@@ -23,6 +23,7 @@
 #include <new>
 #include <type_traits>
 #include <utility>
+#include "config.h"
 #include "type_traits.h"
 
 namespace cppsort::detail
@@ -201,6 +202,7 @@ namespace cppsort::detail
             temporary_buffer& operator=(const temporary_buffer&) = delete;
 
             auto operator=(temporary_buffer&& other) noexcept
+                CPPSORT_LIFETIME_BOUND
                 -> temporary_buffer&
             {
                 using std::swap;
diff --git a/include/cpp-sort/detail/merge_insertion_sort.h b/include/cpp-sort/detail/merge_insertion_sort.h
@@ -13,6 +13,7 @@
 #include <cpp-sort/utility/as_function.h>
 #include <cpp-sort/utility/functional.h>
 #include <cpp-sort/utility/iter_move.h>
+#include "config.h"
 #include "fixed_size_list.h"
 #include "immovable_vector.h"
 #include "iterator_traits.h"
@@ -90,27 +91,31 @@ namespace cppsort::detail
             // Increment/decrement operators
 
             auto operator++()
+                CPPSORT_LIFETIME_BOUND
                 -> group_iterator&
             {
                 std::advance(_it, _size);
                 return *this;
             }
 
             auto operator--()
+                CPPSORT_LIFETIME_BOUND
                 -> group_iterator&
             {
                 std::advance(_it, -_size);
                 return *this;
             }
 
             auto operator+=(difference_type increment)
+                CPPSORT_LIFETIME_BOUND
                 -> group_iterator&
             {
                 _it += _size * increment;
                 return *this;
             }
 
             auto operator-=(difference_type increment)
+                CPPSORT_LIFETIME_BOUND
                 -> group_iterator&
             {
                 _it -= _size * increment;
diff --git a/include/cpp-sort/detail/ska_sort.h b/include/cpp-sort/detail/ska_sort.h
@@ -23,6 +23,7 @@
 #include <utility>
 #include <cpp-sort/utility/as_function.h>
 #include <cpp-sort/utility/iter_move.h>
+#include "config.h"
 #include "iterator_traits.h" // projected_t
 #include "memcpy_cast.h"
 #include "partition.h"
@@ -460,7 +461,7 @@ namespace cppsort::detail
         using next = SubKey<void>;
         using sub_key_type = T;
 
-        static auto sub_key(const T& value, void*)
+        static auto sub_key(const T& value CPPSORT_LIFETIME_BOUND, void*)
             -> const T&
         {
             return value;
diff --git a/include/cpp-sort/metrics/moves.h b/include/cpp-sort/metrics/moves.h
@@ -18,6 +18,7 @@
 #include <cpp-sort/utility/metrics_tools.h>
 #include <cpp-sort/utility/size.h>
 #include "../detail/checkers.h"
+#include "../detail/config.h"
 #include "../detail/fake_category_iterator.h"
 #include "../detail/immovable_vector.h"
 #include "../detail/iterator_traits.h"
@@ -50,6 +51,7 @@ namespace cppsort::metrics
             }
 
             auto operator=(move_counting_wrapper&& other)
+                CPPSORT_LIFETIME_BOUND
                 -> move_counting_wrapper&
             {
                 value = std::move(other.value);
diff --git a/include/cpp-sort/utility/functional.h b/include/cpp-sort/utility/functional.h
@@ -137,7 +137,7 @@ namespace cppsort::utility
         projection_base<identity>
     {
         template<typename T>
-        constexpr auto operator()(T&& value) const noexcept
+        constexpr auto operator()(T&& value CPPSORT_LIFETIME_BOUND) const noexcept
             -> T&&
         {
             return std::forward<T>(value);
diff --git a/include/cpp-sort/utility/metrics_tools.h b/include/cpp-sort/utility/metrics_tools.h
@@ -231,7 +231,7 @@ namespace cppsort::utility
             // Stream operators
 
             template<typename U=T>
-            friend auto operator<<(std::ostream& stream, const metric& met)
+            friend auto operator<<(std::ostream& stream CPPSORT_LIFETIME_BOUND, const metric& met)
                 -> decltype(stream << std::declval<U&>())
             {
                 stream << met.value();

Original file line number	Diff line number	Diff line change
`@@ -11,6 +11,7 @@`
`11`	`11`	`#include <iterator>`
`12`	`12`	`#include <utility>`
`13`	`13`	`#include <cpp-sort/utility/iter_move.h>`
	`14`	`+#include "config.h"`
`14`	`15`	`#include "iterator_traits.h"`
`15`	`16`
`16`	`17`	`namespace cppsort::detail`
`@@ -62,6 +63,7 @@ namespace cppsort::detail`
`62`	`63`	`{}`
`63`	`64`
`64`	`65`	`auto operator=(association&& other) noexcept`
	`66`	`+ CPPSORT_LIFETIME_BOUND`
`65`	`67`	`-> association&`
`66`	`68`	`{`
`67`	`69`	`it = std::move(other.it);`
`@@ -70,6 +72,7 @@ namespace cppsort::detail`
`70`	`72`	`}`
`71`	`73`
`72`	`74`	`auto operator=(associated_value<value_type_t<Iterator>, Data>&& other)`
	`75`	`+ CPPSORT_LIFETIME_BOUND`
`73`	`76`	`-> association&`
`74`	`77`	`{`
`75`	`78`	`*it = std::move(other.value);`
`@@ -124,6 +127,7 @@ namespace cppsort::detail`
`124`	`127`	`{}`
`125`	`128`
`126`	`129`	`auto operator=(associated_value&& other)`
	`130`	`+ CPPSORT_LIFETIME_BOUND`
`127`	`131`	`-> associated_value&`
`128`	`132`	`{`
`129`	`133`	`value = std::move(other.value);`
`@@ -133,13 +137,15 @@ namespace cppsort::detail`
`133`	`137`
`134`	`138`	`[[nodiscard]]`
`135`	`139`	`auto get()`
	`140`	`+ CPPSORT_LIFETIME_BOUND`
`136`	`141`	`-> Value&`
`137`	`142`	`{`
`138`	`143`	`return value;`
`139`	`144`	`}`
`140`	`145`
`141`	`146`	`[[nodiscard]]`
`142`	`147`	`auto get() const`
	`148`	`+ CPPSORT_LIFETIME_BOUND`
`143`	`149`	`-> const Value&`
`144`	`150`	`{`
`145`	`151`	`return value;`
`@@ -207,27 +213,31 @@ namespace cppsort::detail`
`207`	`213`	`// Increment/decrement operators`
`208`	`214`
`209`	`215`	`auto operator++()`
	`216`	`+ CPPSORT_LIFETIME_BOUND`
`210`	`217`	`-> associate_iterator&`
`211`	`218`	`{`
`212`	`219`	`++_it;`
`213`	`220`	`return *this;`
`214`	`221`	`}`
`215`	`222`
`216`	`223`	`auto operator--()`
	`224`	`+ CPPSORT_LIFETIME_BOUND`
`217`	`225`	`-> associate_iterator&`
`218`	`226`	`{`
`219`	`227`	`--_it;`
`220`	`228`	`return *this;`
`221`	`229`	`}`
`222`	`230`
`223`	`231`	`auto operator+=(difference_type increment)`
	`232`	`+ CPPSORT_LIFETIME_BOUND`
`224`	`233`	`-> associate_iterator&`
`225`	`234`	`{`
`226`	`235`	`_it += increment;`
`227`	`236`	`return *this;`
`228`	`237`	`}`
`229`	`238`
`230`	`239`	`auto operator-=(difference_type increment)`
	`240`	`+ CPPSORT_LIFETIME_BOUND`
`231`	`241`	`-> associate_iterator&`
`232`	`242`	`{`
`233`	`243`	`_it -= increment;`
Original file line number	Diff line number	Diff line change
`@@ -12,6 +12,7 @@`
`12`	`12`	`#include <type_traits>`
`13`	`13`	`#include <utility>`
`14`	`14`	`#include <cpp-sort/utility/iter_move.h>`
	`15`	`+#include "config.h"`
`15`	`16`	`#include "iterator_traits.h"`
`16`	`17`	`#include "type_traits.h"`
`17`	`18`
`@@ -84,6 +85,7 @@ namespace cppsort::detail`
`84`	`85`	`// Increment/decrement operators`
`85`	`86`
`86`	`87`	`auto operator++()`
	`88`	`+ CPPSORT_LIFETIME_BOUND`
`87`	`89`	`-> fake_category_iterator&`
`88`	`90`	`{`
`89`	`91`	`++_it;`
`@@ -99,6 +101,7 @@ namespace cppsort::detail`
`99`	`101`	`}`
`100`	`102`
`101`	`103`	`auto operator--()`
	`104`	`+ CPPSORT_LIFETIME_BOUND`
`102`	`105`	`-> fake_category_iterator&`
`103`	`106`	`{`
`104`	`107`	`--_it;`
`@@ -114,13 +117,15 @@ namespace cppsort::detail`
`114`	`117`	`}`
`115`	`118`
`116`	`119`	`auto operator+=(difference_type increment)`
	`120`	`+ CPPSORT_LIFETIME_BOUND`
`117`	`121`	`-> fake_category_iterator&`
`118`	`122`	`{`
`119`	`123`	`_it += increment;`
`120`	`124`	`return *this;`
`121`	`125`	`}`
`122`	`126`
`123`	`127`	`auto operator-=(difference_type increment)`
	`128`	`+ CPPSORT_LIFETIME_BOUND`
`124`	`129`	`-> fake_category_iterator&`
`125`	`130`	`{`
`126`	`131`	`_it -= increment;`
Original file line number	Diff line number	Diff line change
`@@ -308,6 +308,7 @@ namespace cppsort::detail`
`308`	`308`	`// Increment/decrement operators`
`309`	`309`
`310`	`310`	`auto operator++() noexcept`
	`311`	`+ CPPSORT_LIFETIME_BOUND`
`311`	`312`	`-> fixed_size_list_iterator&`
`312`	`313`	`{`
`313`	`314`	`ptr_ = ptr_->next;`
`@@ -323,6 +324,7 @@ namespace cppsort::detail`
`323`	`324`	`}`
`324`	`325`
`325`	`326`	`auto operator--() noexcept`
	`327`	`+ CPPSORT_LIFETIME_BOUND`
`326`	`328`	`-> fixed_size_list_iterator&`
`327`	`329`	`{`
`328`	`330`	`ptr_ = ptr_->prev;`
Original file line number	Diff line number	Diff line change
`@@ -13,6 +13,7 @@`
`13`	`13`	`#include <cpp-sort/utility/as_function.h>`
`14`	`14`	`#include <cpp-sort/utility/functional.h>`
`15`	`15`	`#include <cpp-sort/utility/iter_move.h>`
	`16`	`+#include "config.h"`
`16`	`17`	`#include "fixed_size_list.h"`
`17`	`18`	`#include "immovable_vector.h"`
`18`	`19`	`#include "iterator_traits.h"`
`@@ -90,27 +91,31 @@ namespace cppsort::detail`
`90`	`91`	`// Increment/decrement operators`
`91`	`92`
`92`	`93`	`auto operator++()`
	`94`	`+ CPPSORT_LIFETIME_BOUND`
`93`	`95`	`-> group_iterator&`
`94`	`96`	`{`
`95`	`97`	`std::advance(_it, _size);`
`96`	`98`	`return *this;`
`97`	`99`	`}`
`98`	`100`
`99`	`101`	`auto operator--()`
	`102`	`+ CPPSORT_LIFETIME_BOUND`
`100`	`103`	`-> group_iterator&`
`101`	`104`	`{`
`102`	`105`	`std::advance(_it, -_size);`
`103`	`106`	`return *this;`
`104`	`107`	`}`
`105`	`108`
`106`	`109`	`auto operator+=(difference_type increment)`
	`110`	`+ CPPSORT_LIFETIME_BOUND`
`107`	`111`	`-> group_iterator&`
`108`	`112`	`{`
`109`	`113`	`_it += _size * increment;`
`110`	`114`	`return *this;`
`111`	`115`	`}`
`112`	`116`
`113`	`117`	`auto operator-=(difference_type increment)`
	`118`	`+ CPPSORT_LIFETIME_BOUND`
`114`	`119`	`-> group_iterator&`
`115`	`120`	`{`
`116`	`121`	`_it -= _size * increment;`
Original file line number	Diff line number	Diff line change
`@@ -18,6 +18,7 @@`
`18`	`18`	`#include <cpp-sort/utility/metrics_tools.h>`
`19`	`19`	`#include <cpp-sort/utility/size.h>`
`20`	`20`	`#include "../detail/checkers.h"`
	`21`	`+#include "../detail/config.h"`
`21`	`22`	`#include "../detail/fake_category_iterator.h"`
`22`	`23`	`#include "../detail/immovable_vector.h"`
`23`	`24`	`#include "../detail/iterator_traits.h"`
`@@ -50,6 +51,7 @@ namespace cppsort::metrics`
`50`	`51`	`}`
`51`	`52`
`52`	`53`	`auto operator=(move_counting_wrapper&& other)`
	`54`	`+ CPPSORT_LIFETIME_BOUND`
`53`	`55`	`-> move_counting_wrapper&`
`54`	`56`	`{`
`55`	`57`	`value = std::move(other.value);`
Original file line number	Diff line number	Diff line change
`@@ -137,7 +137,7 @@ namespace cppsort::utility`
`137`	`137`	`projection_base<identity>`
`138`	`138`	`{`
`139`	`139`	`template<typename T>`
`140`		`- constexpr auto operator()(T&& value) const noexcept`
	`140`	`+ constexpr auto operator()(T&& value CPPSORT_LIFETIME_BOUND) const noexcept`
`141`	`141`	`-> T&&`
`142`	`142`	`{`
`143`	`143`	`return std::forward<T>(value);`
Original file line number	Diff line number	Diff line change
`@@ -231,7 +231,7 @@ namespace cppsort::utility`
`231`	`231`	`// Stream operators`
`232`	`232`
`233`	`233`	`template<typename U=T>`
`234`		`- friend auto operator<<(std::ostream& stream, const metric& met)`
	`234`	`+ friend auto operator<<(std::ostream& stream CPPSORT_LIFETIME_BOUND, const metric& met)`
`235`	`235`	`-> decltype(stream << std::declval<U&>())`
`236`	`236`	`{`
`237`	`237`	`stream << met.value();`