Implement TC_CHECK(_*) macros

The glog CHECK macros terminate on failure. Instead of termination
the TC_CHECK macros throw exceptions.

The available macros are:
TC_CHECK(condition) (boolean argument)
TC_CHECK_EQ(x, y) (checks if x == y)
TC_CHECK_NE(x, y) (checks if x != y)
TC_CHECK_LT(x, y) (checks if x <  y)
TC_CHECK_GT(x, y) (checks if x >  y)
TC_CHECK_GE(x, y) (checks if x <= y)
TC_CHECK_LE(x, y) (checks if x >= y)

Additional information can be passed through operator<< and is
included in the exception's error message, e.g.:
TC_CHECK_EQ(x, 42) << "x is not the answer";

Implementation detail: Information passed with calls to operator<< is
maintained in a separate string. The reason is that a separator is
printed between the base message  and the additional info if it is
present (e.g., 1 is not equal to 42: x is not the answer). Maintaining
two strings helps determining the correct location for the separator.

Author: Theodoros Theodoridis

tc/core/CMakeLists.txt

@@ -10,6 +10,7 @@ add_library(
   SHARED
 
   flags.cc
+  check.cc
   mapping_options.cc
   mapping_options_cpp_printer.cc
   islpp.cc

tc/core/check.cc

@@ -0,0 +1,39 @@
+#include "tc/core/check.h"
+
+#include <stdexcept>
+
+namespace tc {
+namespace detail {
+
+Checker::Checker(bool condition, std::string location, std::string baseErrorMsg)
+    : condition_(condition), location_(location), baseErrorMsg_(baseErrorMsg){};
+
+Checker::~Checker() noexcept(false) {
+  if (condition_) {
+    return;
+  }
+  std::stringstream ss;
+  ss << "Check failed [" << location_ << ']';
+
+  if (not baseErrorMsg_.empty()) {
+    ss << ' ' << baseErrorMsg_;
+  }
+
+  if (not additionalMsg_.empty()) {
+    ss << ": " << additionalMsg_;
+  }
+  throw std::runtime_error(ss.str());
+}
+
+Checker tc_check(bool condition, const char* filename, uint64_t lineno) {
+  return Checker(condition, makeLocation(filename, lineno), {});
+}
+
+std::string makeLocation(const char* filename, uint64_t lineno) {
+  std::stringstream ss;
+  ss << filename << ':' << lineno;
+  return ss.str();
+}
+
+} // namespace detail
+} // namespace tc

tc/core/check.h

@@ -0,0 +1,162 @@
+#pragma once
+
+#include <cstdint>
+#include <iosfwd>
+#include <sstream>
+#include <string>
+
+#include "tc/core/utils/type_traits.h"
+
+/*
+ * Each TC_CHECK(_*) macro checks for a condition and throws an exception if
+ * the condition does not hold
+ *
+ *
+ *Additional information can be passed through operator<< and is
+ *included in the exception's error message, e.g.:
+ *TC_CHECK_EQ(x, 42) << "x is not the answer";
+ *
+ *
+ * The message in the throw exception is:
+ * Check failed [filename:line_number] error(: info)
+ *
+ * filename: the name of the file where TC_CHECK(_*) was used
+ * lineno:   the number of the line in which TC_CHECK(_*) was used
+ * error:    this shows what failed, (e.g, "1 is not equal to 42")
+ * info:     if operator<< was called then the information passed to it is info
+ *
+ *
+ *
+ * WARNING/CORNER CASE:
+ *
+ * Checker's destructor throws. This means that if another exception is thrown
+ * before a fully constructed Checker object is destroyed then the program will
+ * std::terminate. here is one unavoidable corner case:
+ *
+ * TC_CHECK(foo) << bar;
+ *
+ * If bar is a function/constructor call and throws then the program will
+ * std::terminate (because when Checker's destructor runs it will throw a
+ * second exception).
+ */
+
+// condition should either be a bool or convertible to bool
+#define TC_CHECK(condition) \
+  tc::detail::tc_check(static_cast<bool>(condition), __FILE__, __LINE__)
+
+// checks if x == y
+#define TC_CHECK_EQ(x, y) tc::detail::tc_check_eq(x, y, __FILE__, __LINE__)
+// checks if x != y
+#define TC_CHECK_NE(x, y) tc::detail::tc_check_ne(x, y, __FILE__, __LINE__)
+// checks if x < y
+#define TC_CHECK_LT(x, y) tc::detail::tc_check_lt(x, y, __FILE__, __LINE__)
+// checks if x > y
+#define TC_CHECK_GT(x, y) tc::detail::tc_check_gt(x, y, __FILE__, __LINE__)
+// checks if x <= y
+#define TC_CHECK_LE(x, y) tc::detail::tc_check_le(x, y, __FILE__, __LINE__)
+// checks if x >= y
+#define TC_CHECK_GE(x, y) tc::detail::tc_check_ge(x, y, __FILE__, __LINE__)
+
+namespace tc {
+
+namespace detail {
+class Checker {
+ public:
+  Checker(bool condition, std::string location, std::string baseErrorMsg);
+  ~Checker() noexcept(false);
+
+  template <typename T>
+  typename std::enable_if<!tc::is_std_container<T>::value, Checker&>::type
+  operator<<(const T& msg) {
+    try {
+      std::stringstream ss;
+      ss << additionalMsg_ << msg;
+      additionalMsg_ = ss.str();
+    } catch (...) {
+      // If the above throws and we don't catch the exception then the
+      // destructor will throw a second one and the program will terminate.
+    }
+    return *this;
+  }
+
+  template <typename C>
+  typename std::enable_if<tc::is_std_container<C>::value, Checker&>::type
+  operator<<(const C& msg) {
+    try {
+      std::stringstream ss;
+      ss << additionalMsg_;
+      for (const auto& x : msg) {
+        ss << x << ',';
+      }
+      additionalMsg_ = ss.str();
+      if (msg.begin() != msg.end()) {
+        additionalMsg_.pop_back();
+      }
+    } catch (...) {
+      // If the above throws and we don't catch the exception then the
+      // destructor will throw a second one and the program will terminate.
+    }
+    return *this;
+  }
+
+ private:
+  bool condition_;
+  std::string location_;
+  std::string baseErrorMsg_;
+  std::string additionalMsg_;
+}; // namespace detail
+
+std::string makeLocation(const char* filename, uint64_t lineno);
+
+Checker tc_check(bool condition, const char* filename, uint64_t lineno);
+
+template <typename X, typename Y>
+Checker
+tc_check_eq(const X& x, const Y& y, const char* filename, uint64_t lineno) {
+  std::stringstream ss;
+  ss << x << " not equal to " << y;
+  return Checker(x == y, makeLocation(filename, lineno), ss.str());
+}
+
+template <typename X, typename Y>
+Checker
+tc_check_ne(const X& x, const Y& y, const char* filename, uint64_t lineno) {
+  std::stringstream ss;
+  ss << x << " equal to " << y;
+  return Checker(x != y, makeLocation(filename, lineno), ss.str());
+}
+
+template <typename X, typename Y>
+Checker
+tc_check_lt(const X& x, const Y& y, const char* filename, uint64_t lineno) {
+  std::stringstream ss;
+  ss << x << " not less than " << y;
+  return Checker(x < y, makeLocation(filename, lineno), ss.str());
+}
+
+template <typename X, typename Y>
+Checker
+tc_check_gt(const X& x, const Y& y, const char* filename, uint64_t lineno) {
+  std::stringstream ss;
+  ss << x << " not greater than " << y;
+  return Checker(x > y, makeLocation(filename, lineno), ss.str());
+}
+
+template <typename X, typename Y>
+Checker
+tc_check_le(const X& x, const Y& y, const char* filename, uint64_t lineno) {
+  std::stringstream ss;
+  ss << x << " not less than or equal to " << y;
+  return Checker(x <= y, makeLocation(filename, lineno), ss.str());
+}
+
+template <typename X, typename Y>
+Checker
+tc_check_ge(const X& x, const Y& y, const char* filename, uint64_t lineno) {
+  std::stringstream ss;
+  ss << x << " not greater than or equal to " << y;
+  return Checker(x >= y, makeLocation(filename, lineno), ss.str());
+}
+
+} // namespace detail
+} // namespace tc

tc/core/utils/type_traits.h

@@ -0,0 +1,23 @@
+#include <type_traits>
+
+namespace tc {
+// WG21 N3911 2.3 Implementation workaround
+// (Make sure template argument is always used.)
+template <class...>
+struct voider {
+  using type = void;
+};
+template <class... T0toN>
+using void_t = typename voider<T0toN...>::type;
+
+template <typename T, typename = void>
+struct is_std_container : std::false_type {};
+
+template <typename T>
+struct is_std_container<
+    T,
+    void_t<
+        decltype(std::declval<T&>().begin()),
+        decltype(std::declval<T&>().end()),
+        typename T::value_type>> : std::true_type {};
+} // namespace tc

test/CMakeLists.txt

@@ -29,6 +29,7 @@ set(CORE_TEST_FILES
   test_core
   test_inference
   test_tc2halide
+  test_check
 )
 
 foreach(i ${CORE_TEST_FILES})