[Sema] Warn on attribute nothrow conflicting with language specifiers

[erichkeane]

Summary

I discovered it was possible to create a 'nothrow' noexcept(false)
function, which is both non-sensical as well as seemingly breaking.

This patch warns if attribute nothrow is used with anything besides "noexcept".

"noexcept(true)" isn't possible, because the noexcept decl isn't parsed until
later.

[erichkeane]

Woops, didn't commit my correct tests!

[aaron.ballman]

include/clang/Basic/DiagnosticSemaKinds.td

1411

How about: "attribute 'nothrow' ignored due to conflicting exception specification"

lib/Sema/SemaDeclAttr.cpp

1988

attr doesn't meet the coding guidelines. I'd go with AL.

test/SemaCXX/warn-conflicting-nothrow-attr-exception-spec.cpp

4

You should add some tests that include templates and test it on Windows as well as non-Windows. I'm wondering about computed exception specifications during template instantiation. e.g.,

void throwing() noexcept(false);
void non_throwing() noexcept;

template <typename Fn>
struct T {
  __attribute__((nothrow)) void f(Fn) noexcept(Fn());
};

template struct T<decltype(throwing)>;
template struct T<decltype(non_throwing)>;

[erichkeane]

changes that were suggested by @aaron.ballman

It DOES warn on the template correctly, however I'm not thrilled that it misses the 'warning' info. Any idea how I can get that information to give that 'note'? I'd like an "in instantiation of template ..." type note.

[aaron.ballman]

In D38205#882737, @erichkeane wrote:

changes that were suggested by @aaron.ballman

It DOES warn on the template correctly, however I'm not thrilled that it misses the 'warning' info. Any idea how I can get that information to give that 'note'? I'd like an "in instantiation of template ..." type note.

That's usually automatic. You might want to look at Sema::EmitCurrentDiagnostic() to see what's up, it's PrintContextStack() that does the magic.

The diagnostics LGTM as-is, but further improvement isn't discouraged.

include/clang/Basic/DiagnosticSemaKinds.td

1411

Close, but not quite. The warning should not be capitalized and it's missing single quotes around nothrow.

include/clang/Basic/DiagnosticSemaKinds.td

def ext_missing_exception_specification : ExtWarn<
   InGroup<DiagGroup<"missing-exception-spec">>;
 def ext_ms_missing_exception_specification : ExtWarn<
   err_missing_exception_specification.Text>,
   InGroup<MicrosoftExceptionSpec>;
 def err_noexcept_needs_constant_expression : Error<
   "argument to noexcept specifier must be a constant expression">;
 def err_exception_spec_not_parsed : Error<
   "exception specification is not available until end of class definition">;
+def warn_nothrow_attr_disagrees_with_exception_specification
+    : ExtWarn<"Attribute nothrow ignored due to conflicting exception "
+              "specification">,
+      InGroup<IgnoredAttributes>;
 
 // C++ access checking
 def err_class_redeclared_with_different_access : Error<
   "%0 redeclared with '%1' access">;
 def err_access : Error<
   "%1 is a %select{private|protected}0 member of %3">, AccessControl;
 def ext_ms_using_declaration_inaccessible : ExtWarn<
   "using declaration referring to inaccessible member '%0' (which refers "

lib/Sema/SemaDeclAttr.cpp

S.Diag(attr.getLoc(), diag::warn_attribute_wrong_decl_type)
         << attr.getName() << ExpectedFunctionOrMethod;
     return;
   }
 
   D->addAttr(::new (S.Context) NoReturnAttr(
       attr.getRange(), S.Context, attr.getAttributeSpellingListIndex()));
 }
 
+static void handleNoThrowAttr(Sema &S, Decl *D, const AttributeList &Attrs) {
+  assert(isa<FunctionDecl>(D) && "attribute nothrow only valid on functions");
+
+  auto *FD = cast<FunctionDecl>(D);
+  const auto *FPT = FD->getType()->getAs<FunctionProtoType>();
+
+  if (FPT && FPT->hasExceptionSpec() &&
+      FPT->getExceptionSpecType() != EST_BasicNoexcept) {
+    S.Diag(Attrs.getLoc(),
+           diag::warn_nothrow_attr_disagrees_with_exception_specification);
+    S.Diag(FD->getExceptionSpecSourceRange().getBegin(),
+           diag::note_previous_decl)
+        << "exception specification";
+  }
+
+  D->addAttr(::new (S.Context) NoThrowAttr(
+      Attrs.getRange(), S.Context, Attrs.getAttributeSpellingListIndex()));
+}
+
 static void handleNoCallerSavedRegsAttr(Sema &S, Decl *D,
                                         const AttributeList &Attr) {
   if (S.CheckNoCallerSavedRegsAttr(Attr))
     return;
 
   D->addAttr(::new (S.Context) AnyX86NoCallerSavedRegistersAttr(
       Attr.getRange(), S.Context, Attr.getAttributeSpellingListIndex()));
 }
case AttributeList::AT_Hot:
     break;
   case AttributeList::AT_Naked:
     handleNakedAttr(S, D, Attr);
     break;
   case AttributeList::AT_NoReturn:
     handleNoReturnAttr(S, D, Attr);
     break;
   case AttributeList::AT_NoThrow:
-    handleSimpleAttribute<NoThrowAttr>(S, D, Attr);
+    handleNoThrowAttr(S, D, Attr);
     break;
   case AttributeList::AT_CUDAShared:
     handleSharedAttr(S, D, Attr);
     break;
   case AttributeList::AT_VecReturn:
     handleVecReturnAttr(S, D, Attr);
     break;
   case AttributeList::AT_ObjCOwnership:

test/SemaCXX/warn-conflicting-nothrow-attr-exception-spec.cpp

+// RUN: %clang_cc1 %s -fcxx-exceptions -fsyntax-only -Wexceptions -verify -std=c++14
+
+struct S {
+  //expected-warning@+2 {{Attribute nothrow ignored due to conflicting exception specification}}
+  //expected-note@+1 {{exception specification declared here}}
+  __attribute__((nothrow)) S() noexcept(true);
+  //expected-warning@+2 {{Attribute nothrow ignored due to conflicting exception specification}}
+  //expected-note@+1 {{exception specification declared here}}
+  __attribute__((nothrow)) void Func1() noexcept(false);
+  __attribute__((nothrow)) void Func3() noexcept;
+};
+
+void throwing() noexcept(false);
+void non_throwing(bool b = true) noexcept;
+
+template <typename Fn>
+struct T {
+    __attribute__((nothrow)) void f(Fn) noexcept(Fn());
+};
+
+//expected-warning@-3 {{Attribute nothrow ignored due to conflicting exception specification}}
+//expected-note@-4 {{exception specification declared here}}
+template struct T<decltype(throwing)>;
+template struct T<decltype(non_throwing)>;