Print stats on displayed and ignored warnings.

[alexfh]

Summary

Also displays a hint to use -header-filter='.*' in case any warnings
are in non-user code. This will help discoverability of this option.

[klimek]

LG.
I'd slightly change the stats output.
By default, only output them if warnings were suppressed:
Suppressed N warnings (M in non-user code, L NOLINT)
<header-filter note>

clang-tidy/ClangTidy.h

private:
   ClangTidyOptions Options;
 };
 
 /// \brief Fills the list of check names that are enabled when the provided
 /// filters are applied.
 std::vector<std::string> getCheckNames(const ClangTidyOptions &Options);
 
 /// \brief Run a set of clang-tidy checks on a set of files.
-void runClangTidy(const ClangTidyOptions &Options,
+ClangTidyStats runClangTidy(const ClangTidyOptions &Options,
                             const tooling::CompilationDatabase &Compilations,
                             ArrayRef<std::string> Ranges,
                             SmallVectorImpl<ClangTidyError> *Errors);
 
 // FIXME: This interface will need to be significantly extended to be useful.
 // FIXME: Implement confidence levels for displaying/fixing errors.
 //
 /// \brief Displays the found \p Errors to the users. If \p Fix is true, \p
 /// Errors containing fixes are automatically applied.
 void handleErrors(SmallVectorImpl<ClangTidyError> &Errors, bool Fix);
 
 } // end namespace tidy
 } // end namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CLANG_TIDY_H

clang-tidy/ClangTidy.cpp

 
 std::vector<std::string> getCheckNames(const ClangTidyOptions &Options) {
   SmallVector<ClangTidyError, 8> Errors;
   clang::tidy::ClangTidyContext Context(&Errors, Options);
   ClangTidyASTConsumerFactory Factory(Context, Options);
   return Factory.getCheckNames();
 }
 
-void runClangTidy(const ClangTidyOptions &Options,
+ClangTidyStats runClangTidy(const ClangTidyOptions &Options,
                             const tooling::CompilationDatabase &Compilations,
                             ArrayRef<std::string> Ranges,
                             SmallVectorImpl<ClangTidyError> *Errors) {
   // FIXME: Ranges are currently full files. Support selecting specific
   // (line-)ranges.
   ClangTool Tool(Compilations, Ranges);
   clang::tidy::ClangTidyContext Context(Errors, Options);
   ClangTidyDiagnosticConsumer DiagConsumer(Context);
 
   Tool.setDiagnosticConsumer(&DiagConsumer);
 
private:
     private:
       ClangTidyASTConsumerFactory *Factory;
     };
 
     ClangTidyASTConsumerFactory *ConsumerFactory;
   };
 
   Tool.run(new ActionFactory(new ClangTidyASTConsumerFactory(Context, Options)));
+  return Context.getStats();
 }
 
 void handleErrors(SmallVectorImpl<ClangTidyError> &Errors, bool Fix) {
   ErrorReporter Reporter(Fix);
   for (const ClangTidyError &Error : Errors) {
     Reporter.reportDiagnostic(Error.Message, DiagnosticsEngine::Warning,
                               &Error.Fix);
     for (const ClangTidyMessage &Note : Error.Notes)
       Reporter.reportDiagnostic(Note, DiagnosticsEngine::Note);
   }
   Reporter.Finish();
 }
 
 } // namespace tidy
 } // namespace clang

clang-tidy/ClangTidyDiagnosticConsumer.h

public:
   ChecksFilter(const ClangTidyOptions& Options);
   bool isCheckEnabled(StringRef Name);
 
 private:
   llvm::Regex EnableChecks;
   llvm::Regex DisableChecks;
 };
 
+struct ClangTidyStats {
+  ClangTidyStats()
+      : ErrorsDisplayed(0), ErrorsIgnoredCheckFilter(0), ErrorsIgnoredNOLINT(0),
+        ErrorsIgnoredNonUserCode(0) {}
+
+  unsigned ErrorsDisplayed;
+  unsigned ErrorsIgnoredCheckFilter;
+  unsigned ErrorsIgnoredNOLINT;
+  unsigned ErrorsIgnoredNonUserCode;
+};
+
 /// \brief Every \c ClangTidyCheck reports errors through a \c DiagnosticEngine
 /// provided by this context.
 ///
 /// A \c ClangTidyCheck always has access to the active context to report
 /// warnings like:
 /// \code
 /// Context->Diag(Loc, "Single-argument constructors must be explicit")
 ///     << FixItHint::CreateInsertion(Loc, "explicit ");
public:
   void setSourceManager(SourceManager *SourceMgr);
 
   /// \brief Returns the name of the clang-tidy check which produced this
   /// diagnostic ID.
   StringRef getCheckName(unsigned DiagnosticID) const;
 
   ChecksFilter &getChecksFilter() { return Filter; }
   const ClangTidyOptions &getOptions() const { return Options; }
+  const ClangTidyStats &getStats() const { return Stats; }
 
 private:
   friend class ClangTidyDiagnosticConsumer; // Calls storeError().
 
   /// \brief Store a \c ClangTidyError.
   void storeError(const ClangTidyError &Error);
 
   SmallVectorImpl<ClangTidyError> *Errors;
   DiagnosticsEngine *DiagEngine;
   ClangTidyOptions Options;
   ChecksFilter Filter;
+  ClangTidyStats Stats;
 
   llvm::DenseMap<unsigned, std::string> CheckNamesByDiagnosticID;
 };
 
 /// \brief A diagnostic consumer that turns each \c Diagnostic into a
 /// \c SourceManager-independent \c ClangTidyError.
 //
 // FIXME: If we move away from unit-tests, this can be moved to a private

clang-tidy/ClangTidyDiagnosticConsumer.cpp

ClangTidyDiagnosticRenderer(const LangOptions &LangOpts,
       : DiagnosticRenderer(LangOpts, DiagOpts), Error(Error) {}
 
 protected:
   void emitDiagnosticMessage(SourceLocation Loc, PresumedLoc PLoc,
                              DiagnosticsEngine::Level Level, StringRef Message,
                              ArrayRef<CharSourceRange> Ranges,
                              const SourceManager *SM,
                              DiagOrStoredDiag Info) override {
-    if (Level == DiagnosticsEngine::Ignored)
-      return;
     ClangTidyMessage TidyMessage = Loc.isValid()
                                        ? ClangTidyMessage(Message, *SM, Loc)
                                        : ClangTidyMessage(Message);
     if (Level == DiagnosticsEngine::Note) {
       Error.Notes.push_back(TidyMessage);
       return;
     }
     assert(Error.Message.Message.empty() &&
ClangTidyMessage::ClangTidyMessage(StringRef Message,
                                    const SourceManager &Sources,
                                    SourceLocation Loc)
     : Message(Message) {
   assert(Loc.isValid() && Loc.isFileID());
   FilePath = Sources.getFilename(Loc);
   FileOffset = Sources.getFileOffset(Loc);
 }
 
-ClangTidyError::ClangTidyError(StringRef CheckName)
-    : CheckName(CheckName) {}
+ClangTidyError::ClangTidyError(StringRef CheckName) : CheckName(CheckName) {}
 
 ChecksFilter::ChecksFilter(const ClangTidyOptions &Options)
     : EnableChecks(Options.EnableChecksRegex),
       DisableChecks(Options.DisableChecksRegex) {}
 
 bool ChecksFilter::isCheckEnabled(StringRef Name) {
   return EnableChecks.match(Name) && !DisableChecks.match(Name);
 }
DiagnosticBuilder ClangTidyContext::diag(
   const char *CharacterData =
       DiagEngine->getSourceManager().getCharacterData(Loc, &Invalid);
   if (!Invalid) {
     const char *P = CharacterData;
     while (*P != '\0' && *P != '\r' && *P != '\n')
       ++P;
     StringRef RestOfLine(CharacterData, P - CharacterData + 1);
     // FIXME: Handle /\bNOLINT\b(\([^)]*\))?/ as cpplint.py does.
-    if (RestOfLine.find("NOLINT") != StringRef::npos)
+    if (RestOfLine.find("NOLINT") != StringRef::npos) {
       Level = DiagnosticIDs::Ignored;
+      ++Stats.ErrorsIgnoredNOLINT;
+    }
   }
   unsigned ID = DiagEngine->getDiagnosticIDs()->getCustomDiagID(
       Level, (Description + " [" + CheckName + "]").str());
   if (CheckNamesByDiagnosticID.count(ID) == 0)
     CheckNamesByDiagnosticID.insert(std::make_pair(ID, CheckName.str()));
   return DiagEngine->Report(Loc, ID);
 }
 
ClangTidyDiagnosticConsumer::ClangTidyDiagnosticConsumer(ClangTidyContext &Ctx)
   IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts = new DiagnosticOptions();
   Diags.reset(new DiagnosticsEngine(
       IntrusiveRefCntPtr<DiagnosticIDs>(new DiagnosticIDs), &*DiagOpts, this,
       /*ShouldOwnClient=*/false));
   Context.setDiagnosticsEngine(Diags.get());
 }
 
 void ClangTidyDiagnosticConsumer::finalizeLastError() {
-  if (!LastErrorRelatesToUserCode && !Errors.empty())
+  if (!Errors.empty()) {
+    ClangTidyError &Error = Errors.back();
+    if (!Context.getChecksFilter().isCheckEnabled(Error.CheckName)) {
+      ++Context.Stats.ErrorsIgnoredCheckFilter;
       Errors.pop_back();
+    } else if (!LastErrorRelatesToUserCode) {
+      ++Context.Stats.ErrorsIgnoredNonUserCode;
+      Errors.pop_back();
+    } else {
+      ++Context.Stats.ErrorsDisplayed;
+    }
+  }
   LastErrorRelatesToUserCode = false;
 }
 
 void ClangTidyDiagnosticConsumer::HandleDiagnostic(
     DiagnosticsEngine::Level DiagLevel, const Diagnostic &Info) {
   if (DiagLevel == DiagnosticsEngine::Note) {
     assert(!Errors.empty() &&
            "A diagnostic note can only be appended to a message.");
return std::tie(M1.FilePath, M1.FileOffset, M1.Message) <
            std::tie(M2.FilePath, M2.FileOffset, M2.Message);
   }
 };
 
 // Flushes the internal diagnostics buffer to the ClangTidyContext.
 void ClangTidyDiagnosticConsumer::finish() {
   finalizeLastError();
   std::set<const ClangTidyError*, LessClangTidyError> UniqueErrors;
-  for (const ClangTidyError &Error : Errors) {
-    if (Context.getChecksFilter().isCheckEnabled(Error.CheckName))
-      UniqueErrors.insert(&Error);
-  }
+  for (const ClangTidyError &Error : Errors)
+
   for (const ClangTidyError *Error : UniqueErrors)
     Context.storeError(*Error);
   Errors.clear();
 }
 
 } // namespace tidy
 } // namespace clang

clang-tidy/tool/ClangTidyMain.cpp

 
 static cl::opt<bool> AnalyzeTemporaryDtors(
     "analyze-temporary-dtors",
     cl::desc("Enable temporary destructor-aware analysis in clang-analyzer- "
              "checks."),
     cl::init(false),
     cl::cat(ClangTidyCategory));
 
+static void printStats(const clang::tidy::ClangTidyStats &Stats) {
+  llvm::errs() << "Warnings: displayed " << Stats.ErrorsDisplayed;
+  if (Stats.ErrorsIgnoredNonUserCode)
+    llvm::errs() << ", in non-user code " << Stats.ErrorsIgnoredNonUserCode;
+  if (Stats.ErrorsIgnoredNOLINT)
+    llvm::errs() << ", suppressed with NOLINT " << Stats.ErrorsIgnoredNOLINT;
+  if (Stats.ErrorsIgnoredCheckFilter)
+    llvm::errs() << ", suppressed with check filters "
+                 << Stats.ErrorsIgnoredCheckFilter;
+  llvm::errs() << "\n";
+  if (Stats.ErrorsIgnoredNonUserCode)
+    llvm::errs() << "Use -header-filter='.*' to display errors from all "
+                    "non-system headers.\n";
+}
+
 int main(int argc, const char **argv) {
   CommonOptionsParser OptionsParser(argc, argv, ClangTidyCategory);
 
   clang::tidy::ClangTidyOptions Options;
   Options.EnableChecksRegex = Checks;
   Options.DisableChecksRegex = DisableChecks;
   Options.HeaderFilterRegex = HeaderFilter;
   Options.AnalyzeTemporaryDtors = AnalyzeTemporaryDtors;
 
   // FIXME: Allow using --list-checks without positional arguments.
   if (ListChecks) {
     llvm::outs() << "Enabled checks:";
     for (auto CheckName : clang::tidy::getCheckNames(Options))
       llvm::outs() << "\n    " << CheckName;
     llvm::outs() << "\n\n";
     return 0;
   }
 
   SmallVector<clang::tidy::ClangTidyError, 16> Errors;
+  clang::tidy::ClangTidyStats Stats =
       clang::tidy::runClangTidy(Options, OptionsParser.getCompilations(),
                                 OptionsParser.getSourcePathList(), &Errors);
   clang::tidy::handleErrors(Errors, Fix);
 
+  printStats(Stats);
   return 0;
 }
 
 namespace clang {
 namespace tidy {
 
 // This anchor is used to force the linker to link the LLVMModule.
 extern volatile int LLVMModuleAnchorSource;

test/clang-tidy/file-filter.cpp

-// RUN: clang-tidy -checks=google-explicit-constructor -disable-checks='' -header-filter='' %s -- -I %S/Inputs/file-filter | FileCheck %s
-// RUN: clang-tidy -checks=google-explicit-constructor -disable-checks='' -header-filter='.*' %s -- -I %S/Inputs/file-filter | FileCheck --check-prefix=CHECK2 %s
-// RUN: clang-tidy -checks=google-explicit-constructor -disable-checks='' -header-filter='header2\.h' %s -- -I %S/Inputs/file-filter | FileCheck --check-prefix=CHECK3 %s
+// RUN: clang-tidy -checks=google-explicit-constructor -disable-checks='' -header-filter='' %s -- -I %S/Inputs/file-filter 2>&1 | FileCheck %s
+// RUN: clang-tidy -checks=google-explicit-constructor -disable-checks='' -header-filter='.*' %s -- -I %S/Inputs/file-filter 2>&1 | FileCheck --check-prefix=CHECK2 %s
+// RUN: clang-tidy -checks=google-explicit-constructor -disable-checks='' -header-filter='header2\.h' %s -- -I %S/Inputs/file-filter 2>&1 | FileCheck --check-prefix=CHECK3 %s
 
 #include "header1.h"
 // CHECK-NOT: warning:
 // CHECK2: header1.h:1:12: warning: Single-argument constructors must be explicit [google-explicit-constructor]
 // CHECK3-NOT: warning:
 
 #include "header2.h"
 // CHECK-NOT: warning:
 // CHECK2: header2.h:1:12: warning: Single-argument constructors {{.*}}
 // CHECK3: header2.h:1:12: warning: Single-argument constructors {{.*}}
 
 class A { A(int); };
 // CHECK: :[[@LINE-1]]:11: warning: Single-argument constructors {{.*}}
 // CHECK2: :[[@LINE-2]]:11: warning: Single-argument constructors {{.*}}
 // CHECK3: :[[@LINE-3]]:11: warning: Single-argument constructors {{.*}}
 
 // CHECK-NOT: warning:
 // CHECK2-NOT: warning:
 // CHECK3-NOT: warning:
+
+// CHECK: Warnings: displayed 1, in non-user code 2
+// CHECK: Use -header-filter='.*' to display errors from all non-system headers.
+// CHECK2: Warnings: displayed 3
+// CHECK-NOT: Use -header-filter='.*' {{.*}}
+// CHECK3: Warnings: displayed 2, in non-user code 1
+// CHECK3: Use -header-filter='.*' {{.*}}

test/clang-tidy/nolint.cpp

-// RUN: clang-tidy -checks=google-explicit-constructor -disable-checks='' %s -- | FileCheck %s
+// RUN: clang-tidy -checks=google-explicit-constructor -disable-checks='' %s -- 2>&1 | FileCheck %s
 
 class A { A(int i); };
 // CHECK: :[[@LINE-1]]:11: warning: Single-argument constructors must be explicit [google-explicit-constructor]
 
 class B { B(int i); }; // NOLINT
 // CHECK-NOT: :[[@LINE-1]]:11: warning: Single-argument constructors must be explicit [google-explicit-constructor]
 
 class C { C(int i); }; // NOLINT(we-dont-care-about-categories-yet)
 // CHECK-NOT: :[[@LINE-1]]:11: warning: Single-argument constructors must be explicit [google-explicit-constructor]
+// CHECK: Warnings: displayed 1, suppressed with NOLINT 2

test/clang-tidy/redundant-smartptr-get.cpp

void Positive() {
   // CHECK: :[[@LINE-1]]:13: warning: Redundant get() call on smart pointer.
   // CHECK: u.get() == nullptr;
   std::shared_ptr<double> *sp;
   bb = nullptr != sp->get();
   // CHECK: :[[@LINE-1]]:19: warning: Redundant get() call on smart pointer.
   // CHECK: nullptr != sp->get();
 }
 
-// CHECK-NOT: warning
+// CHECK-NOT: warning:
 
 void Negative() {
   struct NegPtr {
     int* get();
     int* operator->() {
       return &*this->get();
     }
     int& operator*() {