Add source_location support

Author: toroidal-code

include/class_description.hpp

@@ -229,7 +229,7 @@ Result ClassDescription<T>::run(Formatters::BaseFormatter &printer) {
 template <class T>
 ExpectationValue<T> ItCD<T>::is_expected() {
   auto cd = static_cast<ClassDescription<T> *>(this->get_parent());
-  ExpectationValue<T> expectation(*this, cd->subject);
+  ExpectationValue<T> expectation(*this, cd->subject, std::source_location::current());
   return expectation;
 }
 

include/expectations/expectation.hpp

@@ -395,6 +395,7 @@ Result Expectation<A>::to_have_error(std::string msg) {
 template <typename A>
 class ExpectationValue : public Expectation<A> {
   A value;
+  std::source_location location;
 
  public:
   /**
@@ -404,7 +405,8 @@ class ExpectationValue : public Expectation<A> {
    *
    * @return The constructed ExpectationValue.
    */
-  ExpectationValue(ItBase &it, A value) : Expectation<A>(it), value(value) {}
+  ExpectationValue(ItBase &it, A value, std::source_location location)
+      : Expectation<A>(it), value(value), location{location} {}
 
   /**
    * @brief Create an Expectation using an initializer list.
@@ -414,8 +416,8 @@ class ExpectationValue : public Expectation<A> {
    * @return The constructed Expectation.
    */
   template <typename U>
-  ExpectationValue(ItBase &it, std::initializer_list<U> init_list)
-      : Expectation<A>(it), value(std::vector<U>(init_list)) {}
+  ExpectationValue(ItBase &it, std::initializer_list<U> init_list, std::source_location location)
+      : Expectation<A>(it), value(std::vector<U>(init_list)), location{location} {}
 
   /** @brief Get the target of the expectation. */
   A &get_target() & override { return value; }
@@ -436,9 +438,10 @@ class ExpectationFunc : public Expectation<decltype(std::declval<F>()())> {
   using block_ret_t = decltype(std::declval<F>()());
   F block;
   std::shared_ptr<block_ret_t> computed = nullptr;
+  std::source_location location;
 
  public:
-  ExpectationFunc(ExpectationFunc<F> const &copy) : Expectation<block_ret_t>(copy), block(copy.block) {}
+  ExpectationFunc(ExpectationFunc<F> const &copy, std::source_location location) : Expectation<block_ret_t>(copy), block(copy.block), location{location} {}
 
   /**
    * @brief Create an ExpectationValue using a value.
@@ -447,7 +450,7 @@ class ExpectationFunc : public Expectation<decltype(std::declval<F>()())> {
    *
    * @return The constructed ExpectationValue.
    */
-  ExpectationFunc(ItBase &it, F block) : Expectation<block_ret_t>(it), block(block) {}
+  ExpectationFunc(ItBase &it, F block, std::source_location location) : Expectation<block_ret_t>(it), block(block), location{location} {}
 
   /**
    * @brief Create an Expectation using a function.

include/it.hpp

@@ -48,7 +48,7 @@ class ItD : public ItBase {
    *
    * @return the constructed ItD object
    */
-  ItD(const Child &parent, const char* description, Block block)
+  ItD(const Child &parent, const char *description, Block block)
       : ItBase(parent, description), block(std::move(block)) {}
 
   /**
@@ -104,7 +104,7 @@ class ItCD : public ItBase {
   T &subject;
 
   // This is only ever instantiated by ClassDescription<T>
-  ItCD(const Child &parent, T &subject, const char* description, Block block)
+  ItCD(const Child &parent, T &subject, const char *description, Block block)
       : ItBase(parent, description), block(block), subject(subject) {}
 
   ItCD(const Child &parent, T &subject, Block block) : ItBase(parent), block(block), subject(subject) {}
@@ -123,18 +123,18 @@ class ItCD : public ItBase {
  * @endcode
  */
 template <Util::is_not_functional T>
-ExpectationValue<T> ItBase::expect(T value) {
-  return ExpectationValue<T>(*this, value);
+ExpectationValue<T> ItBase::expect(T value, std::source_location location) {
+  return ExpectationValue<T>(*this, value, location);
 }
 
 template <Util::is_functional T>
-ExpectationFunc<T> ItBase::expect(T block) {
-  return ExpectationFunc<T>(*this, block);
+ExpectationFunc<T> ItBase::expect(T block, std::source_location location) {
+  return ExpectationFunc<T>(*this, block, location);
 }
 
 template <typename T>
-ExpectationValue<T> ItBase::expect(Let<T> &let) {
-  return ExpectationValue<T>(*this, let.value());
+ExpectationValue<T> ItBase::expect(Let<T> &let, std::source_location location) {
+  return ExpectationValue<T>(*this, let.value(), location);
 }
 
 /**
@@ -145,12 +145,13 @@ ExpectationValue<T> ItBase::expect(Let<T> &let) {
  * @endcode
  */
 template <typename T>
-ExpectationValue<std::initializer_list<T>> ItBase::expect(std::initializer_list<T> init_list) {
-  return ExpectationValue<std::initializer_list<T>>(*this, init_list);
+ExpectationValue<std::initializer_list<T>> ItBase::expect(std::initializer_list<T> init_list,
+                                                          std::source_location location) {
+  return ExpectationValue<std::initializer_list<T>>(*this, init_list, location);
 }
 
-inline ExpectationValue<std::string> ItBase::expect(const char *str) {
-  return ExpectationValue<std::string>(*this, std::string(str));
+inline ExpectationValue<std::string> ItBase::expect(const char *str, std::source_location location) {
+  return ExpectationValue<std::string>(*this, std::string(str), location);
 }
 
 }  // namespace CppSpec

include/it_base.hpp

@@ -1,6 +1,7 @@
 /** @file */
 #pragma once
 
+#include <source_location>
 #include <string>
 #include <utility>
 #include <vector>
@@ -84,7 +85,7 @@ class ItBase : public Runnable {
    * @return a ExpectationValue object containing the given value.
    */
   template <Util::is_not_functional T>
-  ExpectationValue<T> expect(T value);
+  ExpectationValue<T> expect(T value, std::source_location location = std::source_location::current());
 
   /**
    * @brief The `expect` object generator for lambdas
@@ -96,7 +97,7 @@ class ItBase : public Runnable {
    * @return a ExpectationFunc object containing the given value.
    */
   template <Util::is_functional T>
-  ExpectationFunc<T> expect(T block);
+  ExpectationFunc<T> expect(T block, std::source_location location = std::source_location::current());
 
   /**
    * @brief The `expect` object generator for initializer lists
@@ -108,7 +109,7 @@ class ItBase : public Runnable {
    * @return a ExpectationValue object containing the given init_list.
    */
   template <typename T>
-  ExpectationValue<std::initializer_list<T>> expect(std::initializer_list<T> init_list);
+  ExpectationValue<std::initializer_list<T>> expect(std::initializer_list<T> init_list, std::source_location location = std::source_location::current());
 
   /**
    * @brief The `expect` object generator for Let
@@ -120,15 +121,15 @@ class ItBase : public Runnable {
    * @return a ExpectationValue object containing the given value.
    */
   template <typename T>
-  ExpectationValue<T> expect(Let<T> &let);
+  ExpectationValue<T> expect(Let<T> &let, std::source_location location = std::source_location::current());
 
   /**
    * @brief The `expect` object generator for const char*
    *
    * @param string the string to wrap
    * @return a ExpectationValue object containing a C++ string
    */
-  ExpectationValue<std::string> expect(const char *string);
+  ExpectationValue<std::string> expect(const char *string, std::source_location location = std::source_location::current());
 };
 
 }  // namespace CppSpec

spec/expectations/expectation_spec.cpp

@@ -106,7 +106,7 @@ describe expectation_spec("Expectation", $ {
 	  // we explicitly want a function. Any other time
 	  // that would be perfectly okay.
       std::function<int()> foo = [] { return 1 + 2; };
-      ExpectationFunc<decltype(foo)> expectation(self, foo);
+      ExpectationFunc<decltype(foo)> expectation(self, foo, std::source_location::current());
       expect(expectation.get_target()).to_equal(3);
     });
   });

spec/matchers/be_within_spec.cpp

@@ -1,3 +1,4 @@
+#include <source_location>
 #include "cppspec.hpp"
 
 using namespace CppSpec;
@@ -38,7 +39,7 @@ describe be_within_spec("expect(actual).to_be_within(delta).of(expected)", $  {
   it("passes with negative arguments", _ {
     expect(-1.0001).to_be_within(5).percent_of(-1);
   });
-  
+
   it("works with std::time", _ {
     expect(std::time(nullptr)).to_be_within(0.1).of(std::time(nullptr));
   });
@@ -57,7 +58,7 @@ describe be_within_spec("expect(actual).to_be_within(delta).of(expected)", $  {
 
   it("provides a description", _ {
     auto d = 5.1;
-    ExpectationValue<double> ex(self, d);
+    ExpectationValue<double> ex(self, d, std::source_location::current());
     Matchers::BeWithin<double, double> matcher(ex, 0.5);
     matcher.of(5.0);
     expect(matcher.description()).to_equal("be within 0.5 of 5");
@@ -83,7 +84,7 @@ describe be_within_spec("expect(actual).to_be_within(delta).of(expected)", $  {
 
     it("provides a description", _ {
       auto d = 5.1;
-      ExpectationValue<double> ex(self, d);
+      ExpectationValue<double> ex(self, d, std::source_location::current());
       Matchers::BeWithin<double, double> matcher(ex, 0.5);
       matcher.percent_of(5.0);
       expect(matcher.description()).to_equal("be within 0.5% of 5");
@@ -136,4 +137,4 @@ describe be_within_spec("expect(actual).to_be_within(delta).of(expected)", $  {
 });
 
 
-CPPSPEC_MAIN(be_within_spec);
+CPPSPEC_MAIN(be_within_spec);