[Sema] Diagnose annotating `if constexpr` with a likelihood attribute

[Mordante]

Summary

Adds a diagnostic when the user annotates an if constexpr with a likelihood attribute. The if constexpr statement is evaluated at compile time so the attribute has no effect. Annotating the accompanied else with a likelihood attribute has the same effect as annotating a generic statement. Since the attribute there is most likely not intended, a diagnostic will be issued. Since the attributes can't conflict, the "conflict" won't be diagnosed for an if constexpr.

It extends diagnostics on a patch in review.
Depends on D89899

[rjmccall]

Patch generally looks good. Minor complaint about how you're using notes.

clang/include/clang/Basic/DiagnosticSemaKinds.td

3163–3169

This isn't a useful form of re-use. The problem is that the original note is pretending to be generic when it really isn't; please rename it to something like note_annotating_infinite_loop_here (maybe in a different patch). This patch should just add a new note.

[aaron.ballman]

LGTM aside from the point @rjmccall made about the note.

[Mordante]

Thanks for the review!

clang/include/clang/Basic/DiagnosticSemaKinds.td

3163–3169

I'll fix it. I'll also change the warn at line 3158, since that uses the same select.

clang/include/clang/Basic/DiagnosticSemaKinds.td

def warn_cxx11_gnu_attribute_on_type : Warning<
   "attribute %0 ignored, because it cannot be applied to a type">,
   InGroup<IgnoredAttributes>;
 def warn_unhandled_ms_attribute_ignored : Warning<
   "__declspec attribute %0 is not supported">,
   InGroup<IgnoredAttributes>;
 def warn_attribute_has_no_effect_on_infinite_loop : Warning<
   "attribute %0 has no effect when annotating an infinite loop">,
    InGroup<IgnoredAttributes>;
 def note_attribute_has_no_effect_on_infinite_loop_here : Note<
   "annotating the infinite loop here">;
+def warn_attribute_has_no_effect_on_if_constexpr : Warning<
+  "attribute %0 has no effect when annotating an 'if constexpr' statement">,
+   InGroup<IgnoredAttributes>;
+def note_attribute_has_no_effect_on_if_constexpr_here : Note<
+  "annotating the 'if constexpr' statement here">;
 def err_decl_attribute_invalid_on_stmt : Error<
   "%0 attribute cannot be applied to a statement">;
 def err_stmt_attribute_invalid_on_decl : Error<
   "%0 attribute cannot be applied to a declaration">;
 def warn_declspec_attribute_ignored : Warning<
   "attribute %0 is ignored, place it after "
   "\"%select{class|struct|interface|union|enum}1\" to apply attribute to "
   "type declaration">, InGroup<IgnoredAttributes>;

clang/lib/Sema/SemaStmt.cpp

StmtResult Sema::ActOnIfStmt(SourceLocation IfLoc, bool IsConstexpr,
   if ((getLangOpts().C99 || getLangOpts().CPlusPlus) &&
       !Diags.isIgnored(diag::warn_comma_operator, CondExpr->getExprLoc()))
     CommaVisitor(*this).Visit(CondExpr);
 
   if (!elseStmt)
     DiagnoseEmptyStmtBody(CondExpr->getEndLoc(), thenStmt,
                           diag::warn_empty_if_body);
 
+  if (IsConstexpr) {
+    auto DiagnoseLikelihood = [&](const Stmt *S) {
+      if (const Attr *A = Stmt::getLikelihoodAttr(S)) {
+        Diags.Report(A->getLocation(),
+                     diag::warn_attribute_has_no_effect_on_if_constexpr)
+            << A << A->getRange();
+        Diags.Report(IfLoc,
+                     diag::note_attribute_has_no_effect_on_if_constexpr_here)
+            << SourceRange(IfLoc, LParenLoc.getLocWithOffset(-1));
+      }
+    };
+    DiagnoseLikelihood(thenStmt);
+    DiagnoseLikelihood(elseStmt);
+  } else {
     std::tuple<bool, const Attr *, const Attr *> LHC =
         Stmt::determineLikelihoodConflict(thenStmt, elseStmt);
     if (std::get<0>(LHC)) {
       const Attr *ThenAttr = std::get<1>(LHC);
       const Attr *ElseAttr = std::get<2>(LHC);
       Diags.Report(ThenAttr->getLocation(),
                    diag::warn_attributes_likelihood_ifstmt_conflict)
           << ThenAttr << ThenAttr->getRange();
       Diags.Report(ElseAttr->getLocation(), diag::note_conflicting_attribute)
           << ElseAttr << ElseAttr->getRange();
     }
+  }
 
   return BuildIfStmt(IfLoc, IsConstexpr, LParenLoc, InitStmt, Cond, RParenLoc,
                      thenStmt, ElseLoc, elseStmt);
 }
 
 StmtResult Sema::BuildIfStmt(SourceLocation IfLoc, bool IsConstexpr,
                              SourceLocation LParenLoc, Stmt *InitStmt,
                              ConditionResult Cond, SourceLocation RParenLoc,

clang/test/SemaCXX/attr-likelihood.cpp

-// RUN: %clang_cc1 %s -fsyntax-only -verify
+// RUN: %clang_cc1 %s -std=c++17 -fsyntax-only -verify
 // RUN: %clang_cc1 %s -DPEDANTIC -pedantic -fsyntax-only -verify
 
 #if PEDANTIC
 void g() {
   if (true)
     [[likely]] {} // expected-warning {{use of the 'likely' attribute is a C++20 extension}}
   else
     [[unlikely]] {} // expected-warning {{use of the 'unlikely' attribute is a C++20 extension}}

 
 void n() [[likely]] // expected-error {{'likely' attribute cannot be applied to types}}
 {
   try
     [[likely]] {} // expected-error {{expected '{'}}
   catch (...) [[likely]] { // expected-error {{expected expression}}
   }
 }
+
+void o()
+{
+  // expected-warning@+2 {{attribute 'likely' has no effect when annotating an 'if constexpr' statement}}
+  // expected-note@+1 {{annotating the 'if constexpr' statement here}}
+  if constexpr (true) [[likely]];
+
+  // expected-note@+1 {{annotating the 'if constexpr' statement here}}
+  if constexpr (true) {
+  // expected-warning@+1 {{attribute 'unlikely' has no effect when annotating an 'if constexpr' statement}}
+  } else [[unlikely]];
+
+  // Annotating both branches with conflicting likelihoods generates no diagnostic regarding the conflict.
+  // expected-warning@+2 {{attribute 'likely' has no effect when annotating an 'if constexpr' statement}}
+  // expected-note@+1 2 {{annotating the 'if constexpr' statement here}}
+  if constexpr (true) [[likely]] {
+  // expected-warning@+1 {{attribute 'likely' has no effect when annotating an 'if constexpr' statement}}
+  } else [[likely]];
+}
 #endif