fix viability checking, return tristate instead of bool

Author: Tsche

include/chroma

@@ -26,7 +26,7 @@ consteval void panic(T const& message) {
   (void)is_complete_type(compile_error);  // force instantiation
 }
 
-constexpr struct unchecked_context {
+struct unchecked_context {
   template <typename F>
   static auto operator()(F&& f) {
     return [&]<typename... Ts>[[= unchecked_context{}]](Ts&&... args)
@@ -35,55 +35,62 @@ constexpr struct unchecked_context {
 #endif
     { return std::forward<F>(f)(std::forward<Ts>(args)...); };
   }
-} unchecked;
+};
+
+template <typename... Ts>
+struct assumed_colors {};
 
-#ifdef __clang__
-consteval std::vector<std::meta::info> annotations_of_with_type(std::meta::info r,
-                                                                std::meta::info t) {
-  return std::meta::annotations_of(r, t);
+consteval bool is_specialization(std::meta::info type, std::meta::info templ) {
+  if (not is_type(type)) {
+    throw "not a type";
+  }
+  return has_template_arguments(type) &&
+         template_of(type) == (is_template(templ) ? templ : template_of(templ));
 }
-#else
-using std::meta::annotations_of_with_type;
-#endif
 
-template <typename... Ts>
-struct AssumedColors {};
+enum struct Viability { accepted, rejected, ignored };
 
-consteval bool is_viable(std::meta::info fnc, std::meta::info type) {
-    if (fnc == std::meta::info()) {
-        return true;
-    }
+consteval Viability viability_of(std::meta::info fnc, std::meta::info type) {
+  using enum Viability;
+  if (fnc == std::meta::info()) {
+    return ignored;
+  }
 
-    auto is_convertible = [&](std::meta::info r) { return is_convertible_type(r, type); };
+  auto is_convertible = [&](std::meta::info r) { return is_convertible_type(r, type); };
 
-    for (auto annotation : annotations_of(fnc) | std::views::transform(std::meta::type_of)) {
-        if (annotation == ^^unchecked_context) {
-            return true;
-        }
-        if (is_specialization(annotation, ^^AssumedColors) and
-            std::ranges::any_of(template_arguments_of(annotation), is_convertible)) {
-            return true;
-        }
+  for (auto annotation : annotations_of(fnc) | std::views::transform(std::meta::type_of)) {
+    if (annotation == ^^unchecked_context) {
+      return ignored;
+    }
+    if (is_specialization(annotation, ^^assumed_colors) and
+        std::ranges::any_of(template_arguments_of(annotation), is_convertible)) {
+      return accepted;
     }
+  }
 
-    for (auto parameter : parameters_of(fnc) | std::views::transform(std::meta::type_of)) {
-        if (is_specialization(parameter, template_of(^^callable_from)) and
-            is_convertible(template_arguments_of(parameter)[0])) {
-            return true;
-        }
+  for (auto parameter : parameters_of(fnc) | std::views::transform(std::meta::type_of)) {
+    if (is_specialization(parameter, ^^callable_from) and
+        is_convertible(template_arguments_of(parameter)[0])) {
+      return accepted;
     }
-    return false;
+  }
+  return rejected;
 }
 }  // namespace _chroma_impl
 
-using _chroma_impl::unchecked;
+constexpr _chroma_impl::unchecked_context unchecked{};
 
 template <typename... Ts>
-constexpr _chroma_impl::AssumedColors<Ts...> assume_color{};
+constexpr _chroma_impl::assumed_colors<Ts...> assume_color{};
 
 namespace chroma {
 template <typename T>
 struct color {
+  color(color const&)            = delete;
+  color& operator=(color const&) = delete;
+  color(color&&)                 = default;
+  color& operator=(color&&)      = default;
+
 protected:
   constexpr color() = default;
   friend T;
@@ -97,8 +104,9 @@ struct callable_from : chroma::color<T> {
 
   consteval explicit(false)
       callable_from(std::meta::access_context ctx = std::meta::access_context::current()) {
-    if (not _chroma_impl::is_viable(ctx.scope(), ^^T)) {
-      panic(T::error_message);
+    using enum _chroma_impl::Viability;
+    if (_chroma_impl::viability_of(ctx.scope(), ^^T) == rejected) {
+      _chroma_impl::panic(T::error_message);
     }
   }
 
@@ -117,12 +125,13 @@ struct callable_from : chroma::color<T> {
 
 template <typename T>
 struct not_callable_from {
-  consteval explicit(false) not_callable_from(unchecked_context) {}
+  consteval explicit(false) not_callable_from(_chroma_impl::unchecked_context) {}
 
   consteval explicit(false)
       not_callable_from(std::meta::access_context ctx = std::meta::access_context::current()) {
-    if (_chroma_impl::is_viable(ctx.scope(), ^^T)) {
-      panic(T::error_message);
+    using enum _chroma_impl::Viability;
+    if (_chroma_impl::viability_of(ctx.scope(), ^^T) == accepted) {
+      _chroma_impl::panic(T::error_message);
     }
   }