P3385

[zebullax]

Proposal

Disclaimer

⚠️ This is a hacky experimentation to survey implementation feasibility...
It goes down happy paths so YMMV, 🟢 stands for This work in a controlled environment, probably break in a lot of cases

Status

Feature	Status	Comment
^^[[nodiscard]];	🟢
std::meta::has_identifier(r)	🟢
std::meta::is_attribute(r)	🟢
std::meta::identifier_of(r)	🟢
std::meta::attributes_of(r)	🟢
[[ [: r :] ]]	🟠	Supports r reflecting a std attribute, a type
argument	🟠	Supports string litteral for [[nodiscard]], [[deprecated]]
data_member_options_t.attributes	🗑️	Descoped away from 3385

Note
Attribute argument support is experimental, only string literal is supported for standard attribute

constexpr auto r = ^^[[nodiscard("keep me")]];
struct [[ [: r :] ]] s {}; // Arg is preserved here

Test

Throwaway smoke test ( really it will mostly not compile if tests don't pass...)

#include <experimental/meta>
#include <string>
#include <iostream>
#include <utility>

// Helpers
struct Witness {
  int nodiscard;
  int maybe_unused;
  int deprecated;
};

struct [[nodiscard("yep"), deprecated("dont use me")]] Foo {};

consteval auto member_named(std::string_view name) {
  for (std::meta::info field : nonstatic_data_members_of(^^Witness)) {
    if (has_identifier(field) && identifier_of(field) == name)
      return field;
  }
  std::unreachable();
}

// Test fragments
consteval bool testHasIdentifier() {
  constexpr auto attr = ^^[[nodiscard]];
  return std::meta::has_identifier(attr);
}

consteval bool testIsAttribute() {
  constexpr auto attr = ^^[[nodiscard]];
  return std::meta::is_attribute(attr);
}

consteval bool testIdentifierOf() {
  constexpr auto attr = ^^[[deprecated]];
  Witness s{0, 0, 0};
  s.[: member_named(std::meta::identifier_of(attr)) :]++;
  return s.deprecated == 1;
}

consteval bool testAttributesOfAttr() {
  return std::meta::identifier_of(std::meta::attributes_of(^^[[nodiscard]])[0]) == "nodiscard"
    && std::meta::attributes_of(^^[[nodiscard]]).size() == 1;
}

consteval bool testAttributesOfType() {
  static_assert(std::meta::attributes_of(^^Foo).size() == 2);
  Witness s{0, 0, 0};
    s.[: member_named(std::meta::identifier_of(std::meta::attributes_of(^^Foo)[0])) :]++;
    s.[: member_named(std::meta::identifier_of(std::meta::attributes_of(^^Foo)[1])) :]++;

    return s.nodiscard == 1 && s.maybe_unused == 0 && s.deprecated == 1;
}

consteval bool testSplicingAttr() {
  constexpr auto r = ^^[[deprecated]];
  struct [[ [: r :] ]] Type;
  return std::meta::identifier_of(std::meta::attributes_of(^^Type)[0]) == "deprecated";
}

consteval bool testSplicingType() {
  constexpr auto r = ^^Foo;
  enum class [[ [: r :] ]] Error {
    e_Fatal
  };
  Error error; // This is to test diagnostic to console
  // `main.cpp:66:3: warning: 'Error' is deprecated: dont use me [-Wdeprecated-declarations]`
  return std::meta::identifier_of(std::meta::attributes_of(^^Error)[0]) == "nodiscard"
      && std::meta::identifier_of(std::meta::attributes_of(^^Error)[1]) == "deprecated";
}

// Smoke test
int main(int, char**) {

  static_assert(testIsAttribute(), "Fail ^^[[ ]]");
  static_assert(testHasIdentifier(), "Fail std::meta::has_identifier");
  static_assert(testIdentifierOf(), "Fail std::meta::identifiers_of");
  static_assert(testAttributesOfAttr() , "Fail std::meta::attributes_of(^^[[ ]])");
  static_assert(testAttributesOfType() , "Fail std::meta::attributes_of(^^MyType)");
  static_assert(testSplicingAttr() , "Fail [[ [: ^attr :] ]]");
  static_assert(testSplicingType() , "Fail [[ [: ^type :] ]]");

  return 0;
}