Expand the unused warnings for functions. Warn for:

-static function declarations
-functions in anonymous namespace
-class methods in anonymous namespace
-class method specializations in anonymous namespace
-function specializations in anonymous namespace

git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@111026 91177308-0d34-0410-b5e6-96231b3b80d8

diff --git a/include/clang/Sema/Sema.h b/include/clang/Sema/Sema.h
index d2b89824a79f9af68893461fb810dce6550de9e2..31c63705fda28e0d3594dac6d15b0f55dead83ac 100644 (file)
--- a/include/clang/Sema/Sema.h
+++ b/include/clang/Sema/Sema.h
@@ -349,7 +349,8 @@ public:
   std::vector<VarDecl *> TentativeDefinitions;
 
   /// \brief The set of file scoped decls seen so far that have not been used
-  /// and must warn if not used.
+  /// and must warn if not used. For functions only contains the first
+  /// declaration.
   std::vector<const DeclaratorDecl*> UnusedFileScopedDecls;
 
   class AccessedEntity {
@@ -1877,6 +1878,7 @@ public:
                                             MultiStmtArg Handlers);
   void DiagnoseReturnInConstructorExceptionHandler(CXXTryStmt *TryBlock);
 
+  bool ShouldWarnIfUnusedFileScopedDecl(const DeclaratorDecl *D) const;
   void MarkUnusedFileScopedDecl(const DeclaratorDecl *D);
 
   /// DiagnoseUnusedExprResult - If the statement passed in is an expression

diff --git a/lib/Sema/Sema.cpp b/lib/Sema/Sema.cpp
index f5c85ad99cd5e80662c5b59e9f002c7771310e10..76e059138e6b2b57815803700a50f70993c483d9 100644 (file)
--- a/lib/Sema/Sema.cpp
+++ b/lib/Sema/Sema.cpp
@@ -235,6 +235,24 @@ void Sema::DeleteExpr(ExprTy *E) {
 void Sema::DeleteStmt(StmtTy *S) {
 }
 
+/// \brief Used to prune the decls of Sema's UnusedFileScopedDecls vector.
+static bool ShouldRemoveFromUnused(Sema *SemaRef, const DeclaratorDecl *D) {
+  if (D->isUsed())
+    return true;
+
+  if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
+    // For functions, UnusedFileScopedDecls stores the first declaration.
+    // Later redecls may add new information resulting in not having to warn,
+    // so check again.
+    const FunctionDecl *DeclToCheck;
+    if (!FD->hasBody(DeclToCheck))
+      DeclToCheck = FD->getMostRecentDeclaration();
+    if (DeclToCheck != FD)
+      return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck);
+  }
+  return false;
+}
+
 /// ActOnEndOfTranslationUnit - This is called at the very end of the
 /// translation unit when EOF is reached and all but the top-level scope is
 /// popped.
@@ -263,10 +281,10 @@ void Sema::ActOnEndOfTranslationUnit() {
     }
   
   // Remove file scoped decls that turned out to be used.
-  UnusedFileScopedDecls.erase(std::remove_if(UnusedFileScopedDecls.begin(), 
-                                             UnusedFileScopedDecls.end(), 
-                             std::bind2nd(std::mem_fun(&DeclaratorDecl::isUsed),
-                                          true)), 
+  UnusedFileScopedDecls.erase(std::remove_if(UnusedFileScopedDecls.begin(),
+                                             UnusedFileScopedDecls.end(),
+                              std::bind1st(std::ptr_fun(ShouldRemoveFromUnused),
+                                           this)),
                               UnusedFileScopedDecls.end());
 
   if (!CompleteTranslationUnit)
@@ -334,9 +352,13 @@ void Sema::ActOnEndOfTranslationUnit() {
   for (std::vector<const DeclaratorDecl*>::iterator
          I = UnusedFileScopedDecls.begin(),
          E = UnusedFileScopedDecls.end(); I != E; ++I) {
-    if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(*I))
-      Diag(FD->getLocation(), diag::warn_unused_function) << FD->getDeclName();
-    else
+    if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(*I)) {
+      const FunctionDecl *DiagD;
+      if (!FD->hasBody(DiagD))
+        DiagD = FD;
+      Diag(DiagD->getLocation(), diag::warn_unused_function)
+            << DiagD->getDeclName();
+    } else
       Diag((*I)->getLocation(), diag::warn_unused_variable)
             << cast<VarDecl>(*I)->getDeclName();
   }

diff --git a/lib/Sema/SemaDecl.cpp b/lib/Sema/SemaDecl.cpp
index e1f9c82fecad4a3aeb27b72922314ba84f966095..cf6f20f60ae90f210d1acc08e3e9b0835b6cfa49 100644 (file)
--- a/lib/Sema/SemaDecl.cpp
+++ b/lib/Sema/SemaDecl.cpp
@@ -521,25 +521,40 @@ static void RemoveUsingDecls(LookupResult &R) {
   F.done();
 }
 
-static bool ShouldWarnIfUnusedFileScopedDecl(const DeclaratorDecl *D) {
+bool Sema::ShouldWarnIfUnusedFileScopedDecl(const DeclaratorDecl *D) const {
+  assert(D);
+  if (D->isInvalidDecl() || D->isUsed() || D->hasAttr<UnusedAttr>())
+    return false;
+  if (D->getLinkage() == ExternalLinkage)
+    return false;
+
+  // Ignore class templates.
+  if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(D))
+    if (MD->getParent()->getDescribedClassTemplate())
+      return false;
+
+  if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
+    if (FD->isThisDeclarationADefinition())
+      return !Context.DeclMustBeEmitted(FD);
+    return true;
+   }
+
+   return false;
+ }
+
+ void Sema::MarkUnusedFileScopedDecl(const DeclaratorDecl *D) {
+  if (!D)
+    return;
+
   if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
-    // Warn for static, non-inlined function definitions that
-    // have not been used.
-    // FIXME: Also include static functions declared but not defined.
-    return (!FD->isInvalidDecl() 
-         && !FD->isInlined() && FD->getLinkage() == InternalLinkage
-         && !FD->isUsed() && !FD->hasAttr<UnusedAttr>()
-         && !FD->hasAttr<ConstructorAttr>()
-         && !FD->hasAttr<DestructorAttr>());
+    const FunctionDecl *First = FD->getFirstDeclaration();
+    if (FD != First && ShouldWarnIfUnusedFileScopedDecl(First))
+      return; // First should already be in the vector.
   }
-  
-  return false;
-}
 
-void Sema::MarkUnusedFileScopedDecl(const DeclaratorDecl *D) {
-  if (ShouldWarnIfUnusedFileScopedDecl(D))
-    UnusedFileScopedDecls.push_back(D);
-}
+   if (ShouldWarnIfUnusedFileScopedDecl(D))
+     UnusedFileScopedDecls.push_back(D);
+ }
 
 static bool ShouldDiagnoseUnusedDecl(const NamedDecl *D) {
   if (D->isInvalidDecl())
@@ -3638,8 +3653,7 @@ Sema::ActOnFunctionDeclarator(Scope* S, Declarator& D, DeclContext* DC,
   if (FunctionTemplate)
     return FunctionTemplate;
 
-  if (IsFunctionDefinition)
-    MarkUnusedFileScopedDecl(NewFD);
+  MarkUnusedFileScopedDecl(NewFD);
 
   return NewFD;
 }

diff --git a/lib/Sema/SemaTemplateInstantiateDecl.cpp b/lib/Sema/SemaTemplateInstantiateDecl.cpp
index fd630f2ef3e291ab97b06e08bc0e62039ecdda0d..a48f1e06b8356896e0a96e83f3252e7c167f8fa0 100644 (file)
--- a/lib/Sema/SemaTemplateInstantiateDecl.cpp
+++ b/lib/Sema/SemaTemplateInstantiateDecl.cpp
@@ -1204,6 +1204,8 @@ Decl *TemplateDeclInstantiator::VisitFunctionDecl(FunctionDecl *D,
       PrincipalDecl->isInIdentifierNamespace(Decl::IDNS_Ordinary))
     PrincipalDecl->setNonMemberOperator();
 
+  SemaRef.MarkUnusedFileScopedDecl(Function);
+
   return Function;
 }
 
@@ -1415,6 +1417,8 @@ TemplateDeclInstantiator::VisitCXXMethodDecl(CXXMethodDecl *D,
     else
       Owner->addDecl(DeclToAdd);
   }
+  
+  SemaRef.MarkUnusedFileScopedDecl(Method);
 
   return Method;
 }

diff --git a/test/Sema/warn-unused-function.c b/test/Sema/warn-unused-function.c
index d5e676b1160332ea6d34b704d71e0d8e0f6d0ed5..5ae0cce0798d3c17b7ec6f882d6cefb1c91b0287 100644 (file)
--- a/test/Sema/warn-unused-function.c
+++ b/test/Sema/warn-unused-function.c
@@ -35,3 +35,12 @@ void bar2(void) { }
 
 __attribute__((destructor)) static void bar3(void);
 void bar3(void) { }
+
+static void f10(void); // expected-warning{{unused}}
+static void f10(void);
+
+static void f11(void);
+static void f11(void) { }  // expected-warning{{unused}}
+
+static void f12(void) { }  // expected-warning{{unused}}
+static void f12(void);

diff --git a/test/SemaCXX/warn-unused-filescoped.cpp b/test/SemaCXX/warn-unused-filescoped.cpp
new file mode 100644 (file)
index 0000000..0ad2362
--- /dev/null
+++ b/test/SemaCXX/warn-unused-filescoped.cpp
@@ -0,0 +1,27 @@
+// RUN: %clang_cc1 -fsyntax-only -verify -Wunused %s
+
+static void f1(); // expected-warning{{unused}}
+
+namespace {
+  void f2();  // expected-warning{{unused}}
+
+  void f3() { }  // expected-warning{{unused}}
+
+  struct S {
+    void m1() { }  // expected-warning{{unused}}
+    void m2();  // expected-warning{{unused}}
+    void m3();
+  };
+
+  template <typename T>
+  struct TS {
+    void m();
+  };
+  template <> void TS<int>::m() { }  // expected-warning{{unused}}
+
+  template <typename T>
+  void tf() { }
+  template <> void tf<int>() { }  // expected-warning{{unused}}
+}
+
+void S::m3() { }  // expected-warning{{unused}}