testing clang-tidy

[merge_guards_bot]

Unit tests: pass. 60968 tests passed, 0 failed and 727 were skipped.

clang-tidy: fail. Please fix clang-tidy findings.

clang-format: fail. Please format your changes with clang-format by running git-clang-format HEAD^ or applying this patch.

Build artifacts: diff.json, clang-tidy.txt, clang-format.patch, CMakeCache.txt, console-log.txt, test-results.xml

[JonasToth]

Nice!

[Eugene.Zelenko]

Where set of Clang-tidy checks come from? .clang-tidy? Could stricter set of custom rules be used?

clang/include/clang/Analysis/AnalysisDeclContext.h

527

Shouldn't absence of comment for closing #endif detected by Clang-tidy?

[goncharov]

In D71594#1788194, @Eugene.Zelenko wrote:

Where set of Clang-tidy checks come from? .clang-tidy? Could stricter set of custom rules be used?

Yes, clang-tidy uses the .clang-tidy. Do you want to enable additional rules for a subproject?

[Eugene.Zelenko]

In D71594#1789275, @goncharov wrote:

In D71594#1788194, @Eugene.Zelenko wrote:

Where set of Clang-tidy checks come from? .clang-tidy? Could stricter set of custom rules be used?

Yes, clang-tidy uses the .clang-tidy. Do you want to enable additional rules for a subproject?

It really depends on state of each project. There are a lot of legacy issues, but it makes sense to treat new code with more demands, for example with respect to modernize checks.

[alexfh]

What version of clang-tidy and clang-format does this run? Whatever is available in Debian packages?

clang-tools-extra/clangd/Function.h

 //===--- Function.h - Utility callable wrappers  -----------------*- C++-*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file provides utilities for callable objects.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_FUNCTION_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANGD_FUNCTION_H
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_FUN
+#define LLVM_CLANG_TOOLS_EXTRA_CLANGD_FUN
 
 #include "llvm/ADT/FunctionExtras.h"
 #include "llvm/Support/Error.h"
 #include <mutex>
 #include <tuple>
 #include <utility>
 
 namespace clang {
private:
 
   std::recursive_mutex ListenersMu;
   bool IsBroadcasting = false;
   std::vector<std::pair<Listener, unsigned>> Listeners;
   unsigned ListenerCount = 0;
 };
 
 } // namespace clangd
-} // namespace clang
+} // namespace clangg
 
 #endif

clang/include/clang/Analysis/AnalysisDeclContext.h

 private:
   friend class AnalysisDeclContext;
 
   LocationContextManager &getLocationContextManager() {
     return LocContexts;
   }
 };
 
-} // namespace clang
+}
 
-#endif // LLVM_CLANG_ANALYSIS_ANALYSISDECLCONTEXT_H
+#endif

clang/tools/clang-check/ClangCheck.cpp

 //
 //  This tool uses the Clang Tooling infrastructure, see
 //    http://clang.llvm.org/docs/HowToSetupToolingForLLVM.html
 //  for details on setting it up with LLVM source tree.
 //
 //===----------------------------------------------------------------------===//
 
 #include "clang/AST/ASTConsumer.h"
 #include "clang/CodeGen/ObjectFilePCHContainerOperations.h"
-#include "clang/Driver/Options.h"
 #include "clang/Frontend/ASTConsumers.h"
 #include "clang/Frontend/CompilerInstance.h"
 #include "clang/Rewrite/Frontend/FixItRewriter.h"
+#include "clang/Driver/Options.h"
 #include "clang/Rewrite/Frontend/FrontendActions.h"
 #include "clang/StaticAnalyzer/Frontend/FrontendActions.h"
 #include "clang/Tooling/CommonOptionsParser.h"
 #include "clang/Tooling/Tooling.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Option/OptTable.h"
 #include "llvm/Support/Path.h"
-#include "llvm/Support/Signals.h"
 #include "llvm/Support/TargetSelect.h"
+#include "llvm/Support/Signals.h"
 
 using namespace clang::driver;
 using namespace clang::tooling;
 using namespace llvm;
 
 static cl::extrahelp CommonHelp(CommonOptionsParser::HelpMessage);
 static cl::extrahelp MoreHelp(
     "\tFor example, to run clang-check on all files in a subtree of the\n"
     "\tsource tree, use:\n"
     "\n"
     "\t  find path/in/subtree -name '*.cpp'|xargs clang-check\n"
     "\n"
     "\tor using a specific build path:\n"
     "\n"
     "\t  find path/in/subtree -name '*.cpp'|xargs clang-check -p build/path\n"
     "\n"
     "\tNote, that path/in/subtree and current directory should follow the\n"
     "\trules described above.\n"
     "\n"
 );
 
 static cl::OptionCategory ClangCheckCategory("clang-check options");
-static const opt::OptTable &Options = getDriverOptTable();
+static    const opt::OptTable &Options = getDriverOptTable();
 static cl::opt<bool>
     ASTDump("ast-dump",
             cl::desc(Options.getOptionHelpText(options::OPT_ast_dump)),
             cl::cat(ClangCheckCategory));
 static cl::opt<bool>
     ASTList("ast-list",
             cl::desc(Options.getOptionHelpText(options::OPT_ast_list)),
             cl::cat(ClangCheckCategory));
if (ASTDump)
                                     /*DumpLookups=*/false,
                                     clang::ADOF_Default);
     if (ASTPrint)
       return clang::CreateASTPrinter(nullptr, ASTDumpFilter);
     return std::make_unique<clang::ASTConsumer>();
   }
 };
 
-} // namespace
+}
 
 int main(int argc, const char **argv) {
   llvm::sys::PrintStackTraceOnErrorSignal(argv[0]);
 
   // Initialize targets for clang module support.
   llvm::InitializeAllTargets();
   llvm::InitializeAllTargetMCs();
   llvm::InitializeAllAsmPrinters();

clang/tools/clang-diff/ClangDiff.cpp

ASTDump("ast-dump",
             cl::desc("Print the internal representation of the AST."),
             cl::init(false), cl::cat(ClangDiffCategory));
 
 static cl::opt<bool> ASTDumpJson(
     "ast-dump-json",
     cl::desc("Print the internal representation of the AST as JSON."),
     cl::init(false), cl::cat(ClangDiffCategory));
 
-static cl::opt<bool> PrintMatches("dump-matches",
-                                  cl::desc("Print the matched nodes."),
-                                  cl::init(false), cl::cat(ClangDiffCategory));
+static cl::opt<bool> PrintMatches("dump-matches", cl::desc("Print the matched nodes."), cl::init(false), cl::cat(ClangDiffCategory));
 
 static cl::opt<bool> HtmlDiff("html",
-                              cl::desc("Output a side-by-side diff in HTML."),
                               cl::init(false), cl::cat(ClangDiffCategory));
 
 static cl::opt<std::string> SourcePath(cl::Positional, cl::desc("<source>"),
                                        cl::Required,
                                        cl::cat(ClangDiffCategory));
 
 static cl::opt<std::string> DestinationPath(cl::Positional,
                                             cl::desc("<destination>"),

 
 static void addExtraArgs(std::unique_ptr<CompilationDatabase> &Compilations) {
   if (!Compilations)
     return;
   auto AdjustingCompilations =
       std::make_unique<ArgumentsAdjustingCompilations>(
           std::move(Compilations));
   AdjustingCompilations->appendArgumentsAdjuster(
-      getInsertArgumentAdjuster(ArgsBefore, ArgumentInsertPosition::BEGIN));
+
+      getInsertArgumentAdjuster(ArgsBefore   ,
+
+                      ArgumentInsertPosition::BEGIN));
   AdjustingCompilations->appendArgumentsAdjuster(
       getInsertArgumentAdjuster(ArgsAfter, ArgumentInsertPosition::END));
   Compilations = std::move(AdjustingCompilations);
 }
 
 static std::unique_ptr<ASTUnit>
 getAST(const std::unique_ptr<CompilationDatabase> &CommonCompilations,
        const StringRef Filename) {

clang/tools/clang-fuzzer/ClangFuzzer.cpp

 /// This file implements a function that runs Clang on a single
 ///  input. This function is then linked into the Fuzzer library.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "handle-cxx/handle_cxx.h"
 
 using namespace clang_fuzzer;
-
-extern "C" int LLVMFuzzerInitialize(int *argc, char ***argv) { return 0; }
-
 extern "C" int LLVMFuzzerTestOneInput(uint8_t *data, size_t size) {
   std::string s((const char *)data, size);
   HandleCXX(s, "./test.cc", {"-O2"});
   return 0;
 }
+
+extern "C" int LLVMFuzzerInitialize(   int *argc,
+                                       char ***argv) { return 0 ; }

clang/tools/clang-refactor/ClangRefactor.cpp

 };
 
 /// Stores the parsed -selection=test:<filename> option.
 class TestSourceSelectionArgument final : public SourceSelectionArgument {
 public:
   TestSourceSelectionArgument(TestSelectionRangesInFile TestSelections)
       : TestSelections(std::move(TestSelections)) {}
 
-  void print(raw_ostream &OS) override { TestSelections.dump(OS); }
 
   std::unique_ptr<ClangRefactorToolConsumerInterface>
   createCustomConsumer() override {
     return TestSelections.createConsumer();
   }
 
   /// Testing support: invokes the selection action for each selection range in
   /// the test file.
   bool forAllRanges(const SourceManager &SM,
                     llvm::function_ref<void(SourceRange R)> Callback) override {
     return TestSelections.foreachRange(SM, Callback);
   }
 
+  void print(raw_ostream &OS) override {
+          TestSelections.dump(OS);
+  }
 private:
   TestSelectionRangesInFile TestSelections;
 };
 
 /// Stores the parsed -selection=filename:line:column[-line:column] option.
 class SourceRangeSelectionArgument final : public SourceSelectionArgument {
 public:
   SourceRangeSelectionArgument(ParsedSourceRange Range)