Clang now suppresses -Wreturn-type diagnostics for non-void functions

that always throw, by inferring an implicit InferredNoReturnAttr on
simple cases (single throw statements).

Author: snarang181

clang/include/clang/Basic/Attr.td

@@ -965,6 +965,13 @@ def AnalyzerNoReturn : InheritableAttr {
   let Documentation = [Undocumented];
 }
 
+def InferredNoReturn : InheritableAttr {
+  let Spellings = []; 
+  let SemaHandler = 0;
+  let Documentation = [Undocumented];
+  let Subjects = SubjectList<[Function], ErrorDiag>;
+}
+
 def Annotate : InheritableParamOrStmtAttr {
   let Spellings = [Clang<"annotate">];
   let Args = [StringArgument<"Annotation">, VariadicExprArgument<"Args">];

clang/include/clang/Sema/Sema.h

@@ -834,6 +834,8 @@ enum class CCEKind {
                            ///< message.
 };
 
+void inferNoReturnAttr(Sema &S, FunctionDecl *FD);
+
 /// Sema - This implements semantic analysis and AST building for C.
 /// \nosubgrouping
 class Sema final : public SemaBase {

clang/lib/Sema/AnalysisBasedWarnings.cpp

@@ -624,34 +624,8 @@ struct CheckFallThroughDiagnostics {
   }
 };
 
-// FIXME: This is a shallow best-effort check. Currently, we only handle
-// cases where the function body consists of a single `throw` expression,
-// possibly wrapped in an `ExprWithCleanups`. We do not perform general
-// control-flow analysis or handle more complex throwing patterns.
-// Consider expanding this to handle more cases in the future.
-bool isKnownToAlwaysThrow(const FunctionDecl *FD) {
-  if (!FD->hasBody())
-    return false;
-  const Stmt *Body = FD->getBody();
-  const Stmt *OnlyStmt = nullptr;
-
-  if (const auto *Compound = dyn_cast<CompoundStmt>(Body)) {
-    if (Compound->size() != 1)
-      return false; // More than one statement, can't be known to always throw.
-    OnlyStmt = *Compound->body_begin();
-  } else {
-    OnlyStmt = Body;
-  }
-
-  // Unwrap ExprWithCleanups if necessary.
-  if (const auto *EWC = dyn_cast<ExprWithCleanups>(OnlyStmt)) {
-    OnlyStmt = EWC->getSubExpr();
-  }
-  // Check if the only statement is a throw expression.
-  return isa<CXXThrowExpr>(OnlyStmt);
-}
-
 } // anonymous namespace
+
 /// CheckFallThroughForBody - Check that we don't fall off the end of a
 /// function that should return a value.  Check that we don't fall off the end
 /// of a noreturn function.  We assume that functions and blocks not marked
@@ -669,7 +643,7 @@ static void CheckFallThroughForBody(Sema &S, const Decl *D, const Stmt *Body,
       ReturnsVoid = CBody->getFallthroughHandler() != nullptr;
     else
       ReturnsVoid = FD->getReturnType()->isVoidType();
-    HasNoReturn = FD->isNoReturn();
+    HasNoReturn = FD->isNoReturn() || FD->hasAttr<InferredNoReturnAttr>();
   }
   else if (const auto *MD = dyn_cast<ObjCMethodDecl>(D)) {
     ReturnsVoid = MD->getReturnType()->isVoidType();
@@ -719,7 +693,7 @@ static void CheckFallThroughForBody(Sema &S, const Decl *D, const Stmt *Body,
           }
           if (const auto *CE = dyn_cast<CallExpr>(LastStmt)) {
             if (const FunctionDecl *Callee = CE->getDirectCallee();
-                Callee && isKnownToAlwaysThrow(Callee)) {
+                Callee && Callee->hasAttr<InferredNoReturnAttr>()) {
               return; // Don't warn about fall-through.
             }
           }

clang/lib/Sema/Sema.cpp

@@ -2434,9 +2434,12 @@ Sema::PopFunctionScopeInfo(const AnalysisBasedWarnings::Policy *WP,
     OpenMP().popOpenMPFunctionRegion(Scope.get());
 
   // Issue any analysis-based warnings.
-  if (WP && D)
+  if (WP && D) {
+    if (auto *FD = dyn_cast<FunctionDecl>(D)) {
+      inferNoReturnAttr(*this, const_cast<FunctionDecl *>(FD));
+    }
     AnalysisWarnings.IssueWarnings(*WP, Scope.get(), D, BlockType);
-  else
+  } else
     for (const auto &PUD : Scope->PossiblyUnreachableDiags)
       Diag(PUD.Loc, PUD.PD);
 

clang/lib/Sema/SemaDeclAttr.cpp

@@ -40,6 +40,7 @@
 #include "clang/Sema/ParsedAttr.h"
 #include "clang/Sema/Scope.h"
 #include "clang/Sema/ScopeInfo.h"
+#include "clang/Sema/Sema.h"
 #include "clang/Sema/SemaAMDGPU.h"
 #include "clang/Sema/SemaARM.h"
 #include "clang/Sema/SemaAVR.h"
@@ -1938,6 +1939,44 @@ static void handleNakedAttr(Sema &S, Decl *D, const ParsedAttr &AL) {
   D->addAttr(::new (S.Context) NakedAttr(S.Context, AL));
 }
 
+// FIXME: This is a best-effort heuristic.
+// Currently only handles single throw expressions (optionally with
+// ExprWithCleanups). We could expand this to perform control-flow analysis for
+// more complex patterns.
+static bool isKnownToAlwaysThrow(const FunctionDecl *FD) {
+  if (!FD->hasBody())
+    return false;
+  const Stmt *Body = FD->getBody();
+  const Stmt *OnlyStmt = nullptr;
+
+  if (const auto *Compound = dyn_cast<CompoundStmt>(Body)) {
+    if (Compound->size() != 1)
+      return false; // More than one statement, can't be known to always throw.
+    OnlyStmt = *Compound->body_begin();
+  } else {
+    OnlyStmt = Body;
+  }
+
+  // Unwrap ExprWithCleanups if necessary.
+  if (const auto *EWC = dyn_cast<ExprWithCleanups>(OnlyStmt)) {
+    OnlyStmt = EWC->getSubExpr();
+  }
+  // Check if the only statement is a throw expression.
+  return isa<CXXThrowExpr>(OnlyStmt);
+}
+
+void clang::inferNoReturnAttr(Sema &S, FunctionDecl *FD) {
+  DiagnosticsEngine &Diags = S.getDiagnostics();
+  if (Diags.isIgnored(diag::warn_falloff_nonvoid, FD->getLocation()) &&
+      Diags.isIgnored(diag::warn_suggest_noreturn_function, FD->getLocation()))
+    return;
+
+  if (!FD->hasAttr<NoReturnAttr>() && !FD->hasAttr<InferredNoReturnAttr>() &&
+      isKnownToAlwaysThrow(FD)) {
+    FD->addAttr(InferredNoReturnAttr::CreateImplicit(S.Context));
+  }
+}
+
 static void handleNoReturnAttr(Sema &S, Decl *D, const ParsedAttr &Attrs) {
   if (hasDeclarator(D)) return;