Implement P1771

[erichkeane]

Summary

EWG met on 7/18/19 and came to the conclusion that our initial intent
was to apply to constructors, so approved the paper and expected
implementers to use implementers discretion to backport this to previous
standards. ChandlerC was particularly vocal in wanting this.

The intent is to enable the library to start using this on the
constructors of scope_guard/lock_guard.

[aaron.ballman]

There seems to be some separable concerns in this patch. I'd rather real with warn_unused_result, const, and pure attributes separately only because those are under the gnu attribute namespace and I'd prefer to match GNU's semantics for those attributes (or at least understand better where the inconsistencies are).

This is also missing documentation changes and the updated feature test macro value.

clang/lib/Sema/SemaDeclAttr.cpp

2833–2836

I'm not certain about this -- we do not allow you to put __attribute__((warn_unused_result)) on a constructor declaration, and neither does GCC. Do you know if they're planning to change their behavior as well? https://godbolt.org/z/kDZu3Q

clang/lib/Sema/SemaStmt.cpp

294

const auto * here and below?

298–305

GCC does not warn on these cases and does not let you write the attributes on a constructor. Do you know if they're intending to implement this?

clang/test/CXX/dcl.dcl/dcl.attr/dcl.attr.nodiscard/p2.cpp

71

Formatting is a bit messy here.

[erichkeane]

In D64914#1591744, @aaron.ballman wrote:

There seems to be some separable concerns in this patch. I'd rather real with warn_unused_result, const, and pure attributes separately only because those are under the gnu attribute namespace and I'd prefer to match GNU's semantics for those attributes (or at least understand better where the inconsistencies are).

This is also missing documentation changes and the updated feature test macro value.

I'll remove the const/pure from this, I was intending to do it for completeness and in anticipation of GNU changing their implementation to handle all 3, but I dont have reason to believe besides a 'hunch' that they will as well. As far as the warn_unused_result and gnu::warn_unused_result spellings, ParsedAttr doesn't seem to have a good way to separate them. Suggestions?

I'll update the documentation as well with an example of this being used on a type/constructor. The feature test macro (__has_attribute value) wasn't in the paper, and it was only altering a note, so I wasn't sure, but seeing as nodiscard has its own flag, I'll do so.

clang/lib/Sema/SemaDeclAttr.cpp

2833–2836

I'm unsure about GCC's intent, though they will likely be changing the [[nodiscard]] behavior due to the vote (and I doubt they will have an "if C++20" test either.

Do we have a good way to exclude the alternate spellings? isCXX11Attribute only checks syntax, not the actual spelling. ParsedAttr doesn't seem to even contain a way to get which namespace it is associated with either. Is something like that valuable to add?

clang/lib/Sema/SemaStmt.cpp

298–305

I do not know about pure/const, so I've removed them.

[erichkeane]

Removes pure/const, limits change to just CXX11 spelling, and changes docs/FeatureTestMacro.

[aaron.ballman]

clang/include/clang/Basic/Attr.td

2347

I don't think this is strictly required, but perhaps it's not a bad idea.

clang/include/clang/Basic/AttrDocs.td

1506

We should probably also talk about type conversions as well.

clang/lib/Sema/SemaDeclAttr.cpp

2833–2836

The way we currently do this is (isCXX11Attribute() || isC2xAttribute()) && !getScopeName(), but I am not opposed to going with an additional member. Do you have a preference either way?

clang/test/CXX/dcl.dcl/dcl.attr/dcl.attr.nodiscard/p2.cpp

70

I think this also needs tests for type conversions, from d1771r1.

130–131

Is Core treating this paper as a DR? I don't have a strong opinion here, but for the nodiscard with a message version, I made it a C++2a extension. I don't have a strong opinion, but I sort of prefer doing whatever Core decides.

[erichkeane]

I'll need to rebase this on another patch soon anyway, so I'll hold off until next week to update this particularly since we have some open questions. The additional TableGen work is tempting to do, though I'm not completely sure it'll get more than just this use.

I'd also like to see how this paper goes through CWG and see what the general attitude is there.

clang/lib/Sema/SemaDeclAttr.cpp

2833–2836

An additional member of Spelling-Kind (vs Syntax kind) seems very valuable here, though I wonder if it is valuable enough of a change for TableGen. The isCXX11Attribute && !getScopeName seems a little obtuse from a readers perspective.

clang/test/CXX/dcl.dcl/dcl.attr/dcl.attr.nodiscard/p2.cpp

130–131

I am unfamiliar with what Core is treating it as, but my understanding is that EWG encouraged implementers to treat it as such.

[aaron.ballman]

clang/lib/Sema/SemaDeclAttr.cpp

2833–2836

Yeah, I would love to solve this through the tablegen interface at some point, as that solves other problems we have (like the fact that we don't AST dump with the syntax the user wrote). Let's hold off on that for now and use the obtuse approach, but with a FIXME for us to come back and touch it again once we get tablegen to track more syntactic information along with the semantic attribute object.

clang/test/CXX/dcl.dcl/dcl.attr/dcl.attr.nodiscard/p2.cpp

130–131

We expose the attribute in all its glory in all language modes, so these changes already do what we want in effect. The only real question is whether we want to claim it's a C++17 extension or a C++2a extension. If a user turns on extension warnings, we should probably tell them when the feature was added, which is C++2a. It would be a bit weird to claim this is a C++17 when the feature test for it is __has_attribute(nodiscard) == 201907L (due to the normative wording changes).

But if Core moves it as a DR, then C++17 is fine, though I suppose SD-6 would need to make clear what is required for each given attribute feature test value to give us the answer.

[rsmith]

Please update cxx_status.html to mark P1771R1 as implemented in SVN.

clang/test/CXX/dcl.dcl/dcl.attr/dcl.attr.nodiscard/p2.cpp

130–131

We moved this change as a DR, so this feature should be treated as if it were always part of the spec.

[erichkeane]

Rebased and did all the comments (including the www_status). @aaron.ballman : Wasn't positive what you meant about the conversion functions, but I think I got one? I would also love some bikeshedding on the documentation.

[aaron.ballman]

In D64914#1595660, @erichkeane wrote:

Rebased and did all the comments (including the www_status). @aaron.ballman : Wasn't positive what you meant about the conversion functions, but I think I got one?

I was talking about [dcl.attr.nodiscard]p2.2: "an explicit type conversion (7.6.1.8 [expr.static.cast], 7.6.3 [expr.cast], 7.6.1.3 [expr.type.conv]) that constructs an object through a constructor declared nodiscard, or that initializes an object of a nodiscard type." and specifically the part about type conversion operators that are marked nodiscard directly.

clang/include/clang/Basic/AttrDocs.td

1518

I think we may want to add a case like:

struct S {
  operator marked_type() const;
  [[nodiscard]] operator int() const;
};

void func() {
  S s;
  static_cast<marked_type>(s); // diagnoses
  (int)s; // diagnoses
}

clang/lib/Sema/SemaDeclAttr.cpp

2835

Conversion functions?

clang/test/CXX/dcl.dcl/dcl.attr/dcl.attr.nodiscard/p2.cpp

100

If you specify a message on the nodiscard attribute used here, does the message get printed?

[erichkeane]

Ugg... well conversion functions are an interesting bit, as well as Type{}; with no constructors. It ends up being a function style cast to an init-list-expr, so its going to require a bit more work. Stay tuned :)

clang/lib/Sema/SemaDeclAttr.cpp

2835

Conversion functions don't return 'void', so the 2nd condition should do it, right?

[aaron.ballman]

clang/lib/Sema/SemaDeclAttr.cpp

2835

true -- we already seem to diagnose a conversion function that returns void anyway. Sorry for the noise!

[erichkeane]

Disregard that last commit... i ended up breaking stuff apparently.

[erichkeane]

Casting implementation had to happen in SemaStmt, because other 'warn unused result' stuff depends on them being the way they are.

[aaron.ballman]

clang/lib/Sema/SemaStmt.cpp

296–301

We use this pattern in a handful of places. I wonder if we want to add a private function to Sema to handle this: void DiagnoseNodiscard(const WarnUnusedResultAttr *A, SourceLocation Loc, bool IsConstructor); (maybe it could return a partial diagnostic so we can optionally apply the source ranges to it as well?)

clang/test/CXX/dcl.dcl/dcl.attr/dcl.attr.nodiscard/p2.cpp

91

Can you add a test that adds a message to the nodiscard attribute written directly on a conversion operator?

[aaron.ballman]

LGTM aside from a minor naming nit.

clang/lib/Sema/SemaStmt.cpp

201

isCtor -> IsCtor

clang/include/clang/Basic/Attr.td

 
 def WarnUnused : InheritableAttr {
   let Spellings = [GCC<"warn_unused">];
   let Subjects = SubjectList<[Record]>;
   let Documentation = [Undocumented];
 }
 
 def WarnUnusedResult : InheritableAttr {
-  let Spellings = [CXX11<"", "nodiscard", 201603>, C2x<"", "nodiscard">,
+  let Spellings = [CXX11<"", "nodiscard", 201907>, C2x<"", "nodiscard">,
                    CXX11<"clang", "warn_unused_result">,
                    GCC<"warn_unused_result">];
   let Subjects = SubjectList<[ObjCMethod, Enum, Record, FunctionLike]>;
   let Args = [StringArgument<"Message", 1>];
   let Documentation = [WarnUnusedResultsDocs];
+  let AdditionalMembers = [{
+    // Check whether this the C++11 nodiscard version, even in non C++11
+    // spellings.
+    bool IsCXX11NoDiscard() const {
+      return this->getSemanticSpelling() == CXX11_nodiscard;
+    }
+  }];
 }
 
 def Weak : InheritableAttr {
   let Spellings = [GCC<"weak">];
   let Subjects = SubjectList<[Var, Function, CXXRecord]>;
   let Documentation = [Undocumented];
 }
 

clang/include/clang/Basic/AttrDocs.td

.. code-block: c++
 
   void launch_missiles();
   void test_missiles() {
     enable_missile_safety_mode(); // diagnoses
     launch_missiles();
   }
   error_info &foo();
   void f() { foo(); } // Does not diagnose, error_info is a reference.
+
+Additionally, discarded temporaries resulting from a call to a constructor
+marked with ``[[nodiscard]]`` or a constructor of a type marked
+``[[nodiscard]]`` will also diagnose. This also applies to type conversions that
+use the annotated ``[[nodiscard]]`` constructor or result in an annotated type.
+
+.. code-block: c++
+  struct [[nodiscard]] marked_type {/*..*/ };
+  struct marked_ctor {
+    [[nodiscard]] marked_ctor();
+    marked_ctor(int);
+  };
+
+  struct S {
+    operator marked_type() const;
+    [[nodiscard]] operator int() const;
+  };
+
+  void usages() {
+    marked_type(); // diagnoses.
+    marked_ctor(); // diagnoses.
+    marked_ctor(3); // Does not diagnose, int constructor isn't marked nodiscard.
+
+    S s;
+    static_cast<marked_type>(s); // diagnoses
+    (int)s; // diagnoses
+  }
   }];
 }
 
 def FallthroughDocs : Documentation {
   let Category = DocCatStmt;
   let Heading = "fallthrough";
   let Content = [{
 The ``fallthrough`` (or ``clang::fallthrough``) attribute is used
def HIPPinnedShadowDocs : Documentation {
   let Content = [{
 The GNU style attribute __attribute__((hip_pinned_shadow)) or MSVC style attribute
 __declspec(hip_pinned_shadow) can be added to the definition of a global variable
 to indicate it is a HIP pinned shadow variable. A HIP pinned shadow variable can
 be accessed on both device side and host side. It has external linkage and is
 not initialized on device side. It has internal linkage and is initialized by
 the initializer on host side.
   }];
-}
+}
 

clang/include/clang/Basic/DiagnosticSemaKinds.td

  "property access result unused - getters should not be used for side effects">,
   InGroup<UnusedGetterReturnValue>;
 def warn_unused_container_subscript_expr : Warning<
  "container access result unused - container access should not be used for side effects">,
   InGroup<UnusedValue>;
 def warn_unused_call : Warning<
   "ignoring return value of function declared with %0 attribute">,
   InGroup<UnusedValue>;
+def warn_unused_constructor : Warning<
+  "ignoring temporary created by a constructor declared with %0 attribute">,
+  InGroup<UnusedValue>;
+def warn_unused_constructor_msg : Warning<
+  "ignoring temporary created by a constructor declared with %0 attribute: %1">,
+  InGroup<UnusedValue>;
 def warn_side_effects_unevaluated_context : Warning<
   "expression with side effects has no effect in an unevaluated context">,
   InGroup<UnevaluatedExpression>;
 def warn_side_effects_typeid : Warning<
   "expression with side effects will be evaluated despite being used as an "
   "operand to 'typeid'">, InGroup<PotentiallyEvaluatedExpression>;
 def warn_unused_result : Warning<
   "ignoring return value of function declared with %0 attribute">,

clang/lib/AST/Expr.cpp

bool Expr::isUnusedResultAWarning(const Expr *&WarnE, SourceLocation &Loc,
   // If we don't know precisely what we're looking at, let's not warn.
   case UnresolvedLookupExprClass:
   case CXXUnresolvedConstructExprClass:
     return false;
 
   case CXXTemporaryObjectExprClass:
   case CXXConstructExprClass: {
     if (const CXXRecordDecl *Type = getType()->getAsCXXRecordDecl()) {
-      if (Type->hasAttr<WarnUnusedAttr>()) {
+      const auto *WarnURAttr = Type->getAttr<WarnUnusedResultAttr>();
+      if (Type->hasAttr<WarnUnusedAttr>() ||
+          (WarnURAttr && WarnURAttr->IsCXX11NoDiscard())) {
         WarnE = this;
         Loc = getBeginLoc();
         R1 = getSourceRange();
         return true;
       }
     }
+
+    const auto *CE = cast<CXXConstructExpr>(this);
+    if (const CXXConstructorDecl *Ctor = CE->getConstructor()) {
+      const auto *WarnURAttr = Ctor->getAttr<WarnUnusedResultAttr>();
+      if (WarnURAttr && WarnURAttr->IsCXX11NoDiscard()) {
+        WarnE = this;
+        Loc = getBeginLoc();
+        R1 = getSourceRange();
+
+        if (unsigned NumArgs = CE->getNumArgs())
+          R2 = SourceRange(CE->getArg(0)->getBeginLoc(),
+                           CE->getArg(NumArgs - 1)->getEndLoc());
+        return true;
+      }
+    }
+
     return false;
   }
 
   case ObjCMessageExprClass: {
     const ObjCMessageExpr *ME = cast<ObjCMessageExpr>(this);
     if (Ctx.getLangOpts().ObjCAutoRefCount &&
         ME->isInstanceMessage() &&
         !ME->getType()->isVoidType() &&

clang/lib/Sema/SemaDeclAttr.cpp

if (const auto *FD = dyn_cast<FunctionDecl>(D)) {
     return;
   }
   D->addAttr(::new (S.Context)
              SentinelAttr(AL.getRange(), S.Context, sentinel, nullPos,
                           AL.getAttributeSpellingListIndex()));
 }
 
 static void handleWarnUnusedResult(Sema &S, Decl *D, const ParsedAttr &AL) {
   if (D->getFunctionType() &&
-      D->getFunctionType()->getReturnType()->isVoidType()) {
+      D->getFunctionType()->getReturnType()->isVoidType() &&
+      !isa<CXXConstructorDecl>(D)) {
     S.Diag(AL.getLoc(), diag::warn_attribute_void_function_method) << AL << 0;
     return;
   }
   if (const auto *MD = dyn_cast<ObjCMethodDecl>(D))
     if (MD->getReturnType()->isVoidType()) {
       S.Diag(AL.getLoc(), diag::warn_attribute_void_function_method) << AL << 1;
       return;
     }
 

clang/lib/Sema/SemaStmt.cpp

else if (Kind == Equality)
         << FixItHint::CreateReplacement(Loc, "=");
   }
 
   return true;
 }
 
 void Sema::DiagnoseUnusedExprResult(const Stmt *S) {
   if (const LabelStmt *Label = dyn_cast_or_null<LabelStmt>(S))
     return DiagnoseUnusedExprResult(Label->getSubStmt());
 
   const Expr *E = dyn_cast_or_null<Expr>(S);
   if (!E)
     return;
 
   // If we are in an unevaluated expression context, then there can be no unused
   // results because the results aren't expected to be used in the first place.
   if (isUnevaluatedContext())
if (const FullExpr *Temps = dyn_cast<FullExpr>(E))
     E = Temps->getSubExpr();
   if (const CXXBindTemporaryExpr *TempExpr = dyn_cast<CXXBindTemporaryExpr>(E))
     E = TempExpr->getSubExpr();
 
   if (DiagnoseUnusedComparison(*this, E))
     return;
 
   E = WarnExpr;
+  if (const auto *Cast = dyn_cast<CastExpr>(E))
+    if (Cast->getCastKind() == CK_NoOp ||
+        Cast->getCastKind() == CK_ConstructorConversion)
+      E = Cast->getSubExpr()->IgnoreImpCasts();
+
   if (const CallExpr *CE = dyn_cast<CallExpr>(E)) {
     if (E->getType()->isVoidType())
       return;
 
     if (const auto *A = cast_or_null<WarnUnusedResultAttr>(
             CE->getUnusedResultAttr(Context))) {
       StringRef Msg = A->getMessage();
       if (!Msg.empty())
if (const Decl *FD = CE->getCalleeDecl()) {
         Diag(Loc, diag::warn_unused_call) << R1 << R2 << "pure";
         return;
       }
       if (FD->hasAttr<ConstAttr>()) {
         Diag(Loc, diag::warn_unused_call) << R1 << R2 << "const";
         return;
       }
     }
+  } else if (const auto *CE = dyn_cast<CXXConstructExpr>(E)) {
+    if (const CXXConstructorDecl *Ctor = CE->getConstructor()) {
+      const auto *A = Ctor->getAttr<WarnUnusedResultAttr>();
+      A = A ? A : Ctor->getParent()->getAttr<WarnUnusedResultAttr>();
+      if (A) {
+        StringRef Msg = A->getMessage();
+        if (!Msg.empty())
+          Diag(Loc, diag::warn_unused_constructor_msg) << A << Msg << R1 << R2;
+        else
+          Diag(Loc, diag::warn_unused_constructor) << A << R1 << R2;
+        return;
+      }
+    }
+  } else if (const auto *ILE = dyn_cast<InitListExpr>(E)) {
+    if (const TagDecl *TD = ILE->getType()->getAsTagDecl()) {
+      if (const auto *A = TD->getAttr<WarnUnusedResultAttr>()) {
+        StringRef Msg = A->getMessage();
+        if (!Msg.empty())
+          Diag(Loc, diag::warn_unused_result_msg) << A << Msg << R1 << R2;
+        else
+          Diag(Loc, diag::warn_unused_result) << A << R1 << R2;
+        return;
+      }
+    }
   } else if (ShouldSuppress)
     return;
 
+  E = WarnExpr;
   if (const ObjCMessageExpr *ME = dyn_cast<ObjCMessageExpr>(E)) {
     if (getLangOpts().ObjCAutoRefCount && ME->isDelegateInitCall()) {
       Diag(Loc, diag::err_arc_unused_init_message) << R1;
       return;
     }
     const ObjCMethodDecl *MD = ME->getMethodDecl();
     if (MD) {
       if (const auto *A = MD->getAttr<WarnUnusedResultAttr>()) {

clang/test/CXX/dcl.dcl/dcl.attr/dcl.attr.nodiscard/p2.cpp

 }
 } // namespace PR31526
 
 struct [[nodiscard("reason")]] ReasonStruct {};
 struct LaterReason;
 struct [[nodiscard("later reason")]] LaterReason {};
 
 ReasonStruct get_reason();
 LaterReason get_later_reason();
 [[nodiscard("another reason")]] int another_reason();
 
 [[nodiscard("conflicting reason")]] int conflicting_reason();
 [[nodiscard("special reason")]] int conflicting_reason();
 
 void cxx2a_use() {
   get_reason(); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute: reason}}
   get_later_reason(); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute: later reason}}
   another_reason(); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute: another reason}}
   conflicting_reason(); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute: special reason}}
 }
 
+namespace p1771 {
+struct[[nodiscard("Don't throw me away!")]] ConvertTo{};
+struct S {
+  [[nodiscard]] S();
+  [[nodiscard("Don't let that S-Char go!")]] S(char);
+  S(int);
+  [[gnu::warn_unused_result]] S(double);
+  operator ConvertTo();
+  [[nodiscard]] operator int();
+};
+
+struct[[nodiscard("Don't throw me away either!")]] Y{};
+
+void usage() {
+  S();    // expected-warning {{ignoring temporary created by a constructor declared with 'nodiscard' attribute}}
+  S('A'); // expected-warning {{ignoring temporary created by a constructor declared with 'nodiscard' attribute: Don't let that S-Char go!}}
+  S(1);
+  S(2.2);
+  Y(); // expected-warning {{ignoring temporary created by a constructor declared with 'nodiscard' attribute: Don't throw me away either!}}
+  S s;
+  ConvertTo{}; // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute: Don't throw me away!}}
+
+// AST is different in C++20 mode, pre-2017 a move ctor for ConvertTo is there
+// as well, hense the constructor warning.
+#if __cplusplus >= 201703L
+// expected-warning@+4 {{ignoring return value of function declared with 'nodiscard' attribute: Don't throw me away!}}
+#else
+// expected-warning@+2 {{ignoring temporary created by a constructor declared with 'nodiscard' attribute: Don't throw me away!}}
+#endif
+  (ConvertTo) s;
+  (int)s; // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
+  (S)'c'; // expected-warning {{ignoring temporary created by a constructor declared with 'nodiscard' attribute: Don't let that S-Char go!}}
+#if __cplusplus >= 201703L
+// expected-warning@+4 {{ignoring return value of function declared with 'nodiscard' attribute: Don't throw me away!}}
+#else
+// expected-warning@+2 {{ignoring temporary created by a constructor declared with 'nodiscard' attribute: Don't throw me away!}}
+#endif
+  static_cast<ConvertTo>(s);
+  static_cast<int>(s); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
+}
+}; // namespace p1771
+
 #ifdef EXT
 // expected-warning@5 {{use of the 'nodiscard' attribute is a C++17 extension}}
 // expected-warning@9 {{use of the 'nodiscard' attribute is a C++17 extension}}
 // expected-warning@12 {{use of the 'nodiscard' attribute is a C++17 extension}}
 // expected-warning@13 {{use of the 'nodiscard' attribute is a C++17 extension}}
 // expected-warning@29 {{use of the 'nodiscard' attribute is a C++17 extension}}
 // expected-warning@65 {{use of the 'nodiscard' attribute is a C++2a extension}}
 // expected-warning@67 {{use of the 'nodiscard' attribute is a C++2a extension}}
 // expected-warning@71 {{use of the 'nodiscard' attribute is a C++2a extension}}
 // expected-warning@73 {{use of the 'nodiscard' attribute is a C++2a extension}}
 // expected-warning@74 {{use of the 'nodiscard' attribute is a C++2a extension}}
+// expected-warning@84 {{use of the 'nodiscard' attribute is a C++2a extension}}
+// expected-warning@86 {{use of the 'nodiscard' attribute is a C++17 extension}}
+// expected-warning@87 {{use of the 'nodiscard' attribute is a C++2a extension}}
+// expected-warning@91 {{use of the 'nodiscard' attribute is a C++17 extension}}
+// expected-warning@94 {{use of the 'nodiscard' attribute is a C++2a extension}}
 #endif

clang/test/Preprocessor/has_attribute.cpp

 // CHECK: deprecated: 201309L
 // FIXME(201806L) CHECK: ensures: 0
 // FIXME(201806L) CHECK: expects: 0
 // CHECK: fallthrough: 201603L
 // FIXME(201803L) CHECK: likely: 0
 // CHECK: maybe_unused: 201603L
 // ITANIUM: no_unique_address: 201803L
 // WINDOWS: no_unique_address: 0
-// CHECK: nodiscard: 201603L
+// CHECK: nodiscard: 201907L
 // CHECK: noreturn: 200809L
 // FIXME(201803L) CHECK: unlikely: 0
 
 // Test for Microsoft __declspec attributes
 
 #define DECLSPEC(x) x: __has_declspec_attribute(x)
 
 // CHECK: uuid: 1
 // CHECK: __uuid__: 1
 DECLSPEC(uuid)
 DECLSPEC(__uuid__)
 
 // CHECK: fallthrough: 0
 DECLSPEC(fallthrough)

clang/www/cxx_status.html

</tr>
     </tr>
     <tr>
       <td rowspan="2"><tt>[[nodiscard]]</tt> attribute</td>
       <td><a href="http://wg21.link/p0189r1">P0189R1</a></td>
       <td class="full" align="center">Clang 3.9</td>
     </tr>
       <tr> <!-- from Cologne 2019 -->
         <td><a href="http://wg21.link/p1771r1">P1771R1</a> (<a href="#dr">DR</a>)</td>
-        <td class="none" align="center">No</td>
+        <td class="none" align="center">SVN</td>
       </tr>
     <tr>
       <td><tt>[[maybe_unused]]</tt> attribute</td>
       <td><a href="http://wg21.link/p0212r1">P0212R1</a></td>
       <td class="full" align="center">Clang 3.9</td>
     </tr>
     <tr>
       <td>Aggregate initialization of classes with base classes</td>