Hello everyone,

I'd like to know if there's interest in introducing a way to selectively
ignore the effects of the [[deprecated]] attribute. Such a thing could
be useful in at least two scenarios:

 1. You have an old API that is being replaced by a new API, but the new
    API is written in terms of the old one (either temporarily or
    because you plan to make the old API private in a future release,
    without completely removing it)
 2. You have both a “safe” and an “unsafe” API and you want to encourage
    the naïve user to use the safe one, while giving the possibility to
    an experienced user to choose the unsafe API by declaring such
    intent explicitly

This is an example of case b, with *placeholder* syntax:

  // this is the old API, that still works but is deemed unsafe
[[deprecated_ignorable("unsafe", "This overload is unsafe, please use
strlen_s")]]
size_t strlen( const char* str );

// this is the new "safe" API
size_t strnlen_s( const char* str, size_t strsz );

void f(const char* str, size_t str)
{
     // this use of strlen is flagged as deprecated by the compiler,
possibly raising a warning
     auto len1 = strlen(str);

     // this line should not emit diagnostics
     auto len2 = strlen_s(str, MAX_SIZE);

     // we know what we're doing and really want to suppress the warning
     [[ignore_deprecation("unsafe")]]
     {
         // in this scope all ignorable deprecations with the tag
"unsafe" are ignored
         auto len3 = strlen(str); // no diagnostic here
     }
}

Details of the precise syntax are open to discussion. A few, certainly
not all, questions to address are:

1) Are attributes the right tool?

2) Should we use a different attribute (as "deprecated_ignorable" above)
or can/should we overload the existing [[deprecated]]?

3) The example above uses a string literal to tag the deprecation, so
that it can be referenced in [[ignore_deprecation]]. Alternatives and
variations could be considered, including, but not limited to,
identifiers instead of strings, multiple tags, etc.

4) Should [[ignore_deprecation]] be applied only to compount statements
(as in the example above) or other statements/entities? Are there scopes
that could use the attribute that we would be missing (for example
function default arguments)?

In case there's interest, I am going to write a more detailed paper with
a formal proposal.

Thanks for your feedback,

ab