clang-tidy/ClangTidy.cpp - clang-tools-extra - Git at Google

 //===--- tools/extra/clang-tidy/ClangTidy.cpp - Clang tidy tool -----------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 ///  \file This file implements a clang-tidy tool.
 ///
 ///  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 "ClangTidy.h"
 #include "ClangTidyDiagnosticConsumer.h"
 #include "ClangTidyModuleRegistry.h"
 #include "clang/AST/ASTConsumer.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/Decl.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "clang/Lex/PPCallbacks.h"
 #include "clang/Lex/Preprocessor.h"
 #include "clang/Frontend/ASTConsumers.h"
 #include "clang/Frontend/CompilerInstance.h"
 #include "clang/Frontend/FrontendActions.h"
 #include "clang/Frontend/TextDiagnosticPrinter.h"
 #include "clang/Rewrite/Frontend/FixItRewriter.h"
 #include "clang/Rewrite/Frontend/FrontendActions.h"
 #include "clang/StaticAnalyzer/Frontend/FrontendActions.h"
 #include "clang/Tooling/Tooling.h"
 #include "clang/Tooling/Refactoring.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/Signals.h"
 #include <vector>

 using namespace clang::ast_matchers;
 using namespace clang::driver;
 using namespace clang::tooling;
 using namespace llvm;

 namespace clang {
 namespace tidy {
 namespace {

 /// \brief A combined ASTConsumer that forwards calls to two different
 /// consumers.
 ///
 /// FIXME: This currently forwards just enough methods for the static analyzer
 /// and the \c MatchFinder's consumer to work; expand this to all methods of
 /// ASTConsumer and put it into a common location.
 class CombiningASTConsumer : public ASTConsumer {
 public:
   CombiningASTConsumer(ASTConsumer *Consumer1, ASTConsumer *Consumer2)
       : Consumer1(Consumer1), Consumer2(Consumer2) {}

   virtual void Initialize(ASTContext &Context) LLVM_OVERRIDE {
     Consumer1->Initialize(Context);
     Consumer2->Initialize(Context);
   }
   virtual bool HandleTopLevelDecl(DeclGroupRef D) LLVM_OVERRIDE {
     return Consumer1->HandleTopLevelDecl(D) && Consumer2->HandleTopLevelDecl(D);
   }
   virtual void HandleTopLevelDeclInObjCContainer(DeclGroupRef D) LLVM_OVERRIDE {
     Consumer1->HandleTopLevelDeclInObjCContainer(D);
     Consumer2->HandleTopLevelDeclInObjCContainer(D);
   }
   virtual void HandleTranslationUnit(ASTContext &Context) LLVM_OVERRIDE {
     Consumer1->HandleTranslationUnit(Context);
     Consumer2->HandleTranslationUnit(Context);
   }

 private:
   llvm::OwningPtr<ASTConsumer> Consumer1;
   llvm::OwningPtr<ASTConsumer> Consumer2;
 };

 /// \brief Action that runs clang-tidy and static analyzer checks.
 ///
 /// FIXME: Note that this inherits from \c AnalysisAction as this is the only
 /// way we can currently get to AnalysisAction::CreateASTConsumer. Ideally
 /// we'd want to build a more generic way to use \c FrontendAction based
 /// checkers in clang-tidy, but that needs some preparation work first.
 class ClangTidyAction : public ento::AnalysisAction {
 public:
   ClangTidyAction(StringRef CheckRegexString,
                   SmallVectorImpl<ClangTidyCheck *> &Checks,
                   ClangTidyContext &Context, MatchFinder &Finder)
       : CheckRegexString(CheckRegexString), Checks(Checks), Context(Context),
         Finder(Finder) {}

 private:
   clang::ASTConsumer *CreateASTConsumer(clang::CompilerInstance &Compiler,
                                         StringRef File) LLVM_OVERRIDE {
     AnalyzerOptionsRef Options = Compiler.getAnalyzerOpts();
     llvm::Regex CheckRegex(CheckRegexString);

     // Always add all core checkers if any other static analyzer checks are
     // enabled. This is currently necessary, as other path sensitive checks rely
     // on the core checkers.
     if (CheckRegex.match("clang-analyzer-"))
       Options->CheckersControlList.push_back(std::make_pair("core", true));

 // Run our regex against all possible static analyzer checkers.
 // Note that debug checkers print values / run programs to visualize the CFG
 // and are thus not applicable to clang-tidy in general.
 #define GET_CHECKERS
 #define CHECKER(FULLNAME, CLASS, DESCFILE, HELPTEXT, GROUPINDEX, HIDDEN)       \
   if (!StringRef(FULLNAME).startswith("core") &&                               \
       !StringRef(FULLNAME).startswith("debug") &&                              \
       CheckRegex.match("clang-analyzer-" FULLNAME))                            \
     Options->CheckersControlList.push_back(std::make_pair(FULLNAME, true));
 #include "../../../lib/StaticAnalyzer/Checkers/Checkers.inc"
 #undef CHECKER
 #undef GET_CHECKERS

     Options->AnalysisStoreOpt = RegionStoreModel;
     Options->AnalysisDiagOpt = PD_TEXT;
     Options->AnalyzeNestedBlocks = true;
     Options->eagerlyAssumeBinOpBifurcation = true;
     return new CombiningASTConsumer(
         Finder.newASTConsumer(),
         ento::AnalysisAction::CreateASTConsumer(Compiler, File));
   }

   virtual bool BeginSourceFileAction(CompilerInstance &Compiler,
                                      llvm::StringRef Filename) LLVM_OVERRIDE {
     if (!ento::AnalysisAction::BeginSourceFileAction(Compiler, Filename))
       return false;
     Context.setSourceManager(&Compiler.getSourceManager());
     for (SmallVectorImpl<ClangTidyCheck *>::iterator I = Checks.begin(),
                                                      E = Checks.end();
          I != E; ++I)
       (*I)->registerPPCallbacks(Compiler);
     return true;
   }

   std::string CheckRegexString;
   SmallVectorImpl<ClangTidyCheck *> &Checks;
   ClangTidyContext &Context;
   MatchFinder &Finder;
 };

 class ClangTidyActionFactory : public FrontendActionFactory {
 public:
   ClangTidyActionFactory(StringRef CheckRegexString, ClangTidyContext &Context)
       : CheckRegexString(CheckRegexString), Context(Context) {
     ClangTidyCheckFactories CheckFactories;
     for (ClangTidyModuleRegistry::iterator I = ClangTidyModuleRegistry::begin(),
                                            E = ClangTidyModuleRegistry::end();
          I != E; ++I) {
       OwningPtr<ClangTidyModule> Module(I->instantiate());
       Module->addCheckFactories(CheckFactories);
     }

     SmallVector<ClangTidyCheck *, 16> Checks;
     CheckFactories.createChecks(CheckRegexString, Checks);

     for (SmallVectorImpl<ClangTidyCheck *>::iterator I = Checks.begin(),
                                                      E = Checks.end();
          I != E; ++I) {
       (*I)->setContext(&Context);
       (*I)->registerMatchers(&Finder);
     }
   }

   virtual FrontendAction *create() {
     return new ClangTidyAction(CheckRegexString, Checks, Context, Finder);
   }

 private:
   std::string CheckRegexString;
   SmallVector<ClangTidyCheck *, 8> Checks;
   ClangTidyContext &Context;
   MatchFinder Finder;
 };

 } // namespace

 ClangTidyMessage::ClangTidyMessage(StringRef Message) : Message(Message) {}

 ClangTidyMessage::ClangTidyMessage(StringRef Message,
                                    const SourceManager &Sources,
                                    SourceLocation Loc)
     : Message(Message) {
   FilePath = Sources.getFilename(Loc);
   FileOffset = Sources.getFileOffset(Loc);
 }

 ClangTidyError::ClangTidyError(const ClangTidyMessage &Message)
     : Message(Message) {}

 DiagnosticBuilder ClangTidyContext::Diag(SourceLocation Loc,
                                          StringRef Message) {
   return DiagEngine->Report(
       Loc, DiagEngine->getCustomDiagID(DiagnosticsEngine::Warning, Message));
 }

 void ClangTidyContext::setDiagnosticsEngine(DiagnosticsEngine *Engine) {
   DiagEngine = Engine;
 }

 void ClangTidyContext::setSourceManager(SourceManager *SourceMgr) {
   DiagEngine->setSourceManager(SourceMgr);
 }

 /// \brief Store a \c ClangTidyError.
 void ClangTidyContext::storeError(const ClangTidyError &Error) {
   Errors->push_back(Error);
 }

 void ClangTidyCheck::run(const ast_matchers::MatchFinder::MatchResult &Result) {
   Context->setSourceManager(Result.SourceManager);
   check(Result);
 }

 FrontendActionFactory *createClangTidyActionFactory(StringRef CheckRegexString,
                                                     ClangTidyContext &Context) {
   return new ClangTidyActionFactory(CheckRegexString, Context);
 }

 void runClangTidy(StringRef CheckRegexString,
                   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);
   ClangTidyDiagnosticConsumer DiagConsumer(Context);

   Tool.setDiagnosticConsumer(&DiagConsumer);
   Tool.run(createClangTidyActionFactory(CheckRegexString, Context));
 }

 static void reportDiagnostic(const ClangTidyMessage &Message,
                              SourceManager &SourceMgr,
                              DiagnosticsEngine::Level Level,
                              DiagnosticsEngine &Diags) {
   SourceLocation Loc;
   if (!Message.FilePath.empty()) {
     const FileEntry *File =
         SourceMgr.getFileManager().getFile(Message.FilePath);
     FileID ID = SourceMgr.createFileID(File, SourceLocation(), SrcMgr::C_User);
     Loc = SourceMgr.getLocForStartOfFile(ID);
     Loc = Loc.getLocWithOffset(Message.FileOffset);
   }
   Diags.Report(Loc, Diags.getCustomDiagID(Level, Message.Message));
 }

 void handleErrors(SmallVectorImpl<ClangTidyError> &Errors, bool Fix) {
   FileManager Files((FileSystemOptions()));
   IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts = new DiagnosticOptions();
   DiagnosticConsumer *DiagPrinter =
       new TextDiagnosticPrinter(llvm::outs(), &*DiagOpts);
   DiagnosticsEngine Diags(IntrusiveRefCntPtr<DiagnosticIDs>(new DiagnosticIDs),
                           &*DiagOpts, DiagPrinter);
   DiagPrinter->BeginSourceFile(LangOptions());
   SourceManager SourceMgr(Diags, Files);
   Rewriter Rewrite(SourceMgr, LangOptions());
   for (SmallVectorImpl<ClangTidyError>::iterator I = Errors.begin(),
                                                  E = Errors.end();
        I != E; ++I) {
     reportDiagnostic(I->Message, SourceMgr, DiagnosticsEngine::Warning, Diags);
     for (unsigned i = 0, e = I->Notes.size(); i != e; ++i) {
       reportDiagnostic(I->Notes[i], SourceMgr, DiagnosticsEngine::Note, Diags);
     }
     tooling::applyAllReplacements(I->Fix, Rewrite);
   }
   // FIXME: Run clang-format on changes.
   if (Fix)
     Rewrite.overwriteChangedFiles();
 }

 } // namespace tidy
 } // namespace clang
	//===--- tools/extra/clang-tidy/ClangTidy.cpp - Clang tidy tool -----------===//
	//
	// The LLVM Compiler Infrastructure
	//
	// This file is distributed under the University of Illinois Open Source
	// License. See LICENSE.TXT for details.
	//
	//===----------------------------------------------------------------------===//
	///
	/// \file This file implements a clang-tidy tool.
	///
	/// 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 "ClangTidy.h"
	#include "ClangTidyDiagnosticConsumer.h"
	#include "ClangTidyModuleRegistry.h"
	#include "clang/AST/ASTConsumer.h"
	#include "clang/AST/ASTContext.h"
	#include "clang/AST/Decl.h"
	#include "clang/ASTMatchers/ASTMatchFinder.h"
	#include "clang/Lex/PPCallbacks.h"
	#include "clang/Lex/Preprocessor.h"
	#include "clang/Frontend/ASTConsumers.h"
	#include "clang/Frontend/CompilerInstance.h"
	#include "clang/Frontend/FrontendActions.h"
	#include "clang/Frontend/TextDiagnosticPrinter.h"
	#include "clang/Rewrite/Frontend/FixItRewriter.h"
	#include "clang/Rewrite/Frontend/FrontendActions.h"
	#include "clang/StaticAnalyzer/Frontend/FrontendActions.h"
	#include "clang/Tooling/Tooling.h"
	#include "clang/Tooling/Refactoring.h"
	#include "llvm/Support/Path.h"
	#include "llvm/Support/Signals.h"
	#include <vector>

	using namespace clang::ast_matchers;
	using namespace clang::driver;
	using namespace clang::tooling;
	using namespace llvm;

	namespace clang {
	namespace tidy {
	namespace {

	/// \brief A combined ASTConsumer that forwards calls to two different
	/// consumers.
	///
	/// FIXME: This currently forwards just enough methods for the static analyzer
	/// and the \c MatchFinder's consumer to work; expand this to all methods of
	/// ASTConsumer and put it into a common location.
	class CombiningASTConsumer : public ASTConsumer {
	public:
	CombiningASTConsumer(ASTConsumer Consumer1, ASTConsumer Consumer2)
	: Consumer1(Consumer1), Consumer2(Consumer2) {}

	virtual void Initialize(ASTContext &Context) LLVM_OVERRIDE {
	Consumer1->Initialize(Context);
	Consumer2->Initialize(Context);
	}
	virtual bool HandleTopLevelDecl(DeclGroupRef D) LLVM_OVERRIDE {
	return Consumer1->HandleTopLevelDecl(D) && Consumer2->HandleTopLevelDecl(D);
	}
	virtual void HandleTopLevelDeclInObjCContainer(DeclGroupRef D) LLVM_OVERRIDE {
	Consumer1->HandleTopLevelDeclInObjCContainer(D);
	Consumer2->HandleTopLevelDeclInObjCContainer(D);
	}
	virtual void HandleTranslationUnit(ASTContext &Context) LLVM_OVERRIDE {
	Consumer1->HandleTranslationUnit(Context);
	Consumer2->HandleTranslationUnit(Context);
	}

	private:
	llvm::OwningPtr<ASTConsumer> Consumer1;
	llvm::OwningPtr<ASTConsumer> Consumer2;
	};

	/// \brief Action that runs clang-tidy and static analyzer checks.
	///
	/// FIXME: Note that this inherits from \c AnalysisAction as this is the only
	/// way we can currently get to AnalysisAction::CreateASTConsumer. Ideally
	/// we'd want to build a more generic way to use \c FrontendAction based
	/// checkers in clang-tidy, but that needs some preparation work first.
	class ClangTidyAction : public ento::AnalysisAction {
	public:
	ClangTidyAction(StringRef CheckRegexString,
	SmallVectorImpl<ClangTidyCheck *> &Checks,
	ClangTidyContext &Context, MatchFinder &Finder)
	: CheckRegexString(CheckRegexString), Checks(Checks), Context(Context),
	Finder(Finder) {}

	private:
	clang::ASTConsumer *CreateASTConsumer(clang::CompilerInstance &Compiler,
	StringRef File) LLVM_OVERRIDE {
	AnalyzerOptionsRef Options = Compiler.getAnalyzerOpts();
	llvm::Regex CheckRegex(CheckRegexString);

	// Always add all core checkers if any other static analyzer checks are
	// enabled. This is currently necessary, as other path sensitive checks rely
	// on the core checkers.
	if (CheckRegex.match("clang-analyzer-"))
	Options->CheckersControlList.push_back(std::make_pair("core", true));

	// Run our regex against all possible static analyzer checkers.
	// Note that debug checkers print values / run programs to visualize the CFG
	// and are thus not applicable to clang-tidy in general.
	#define GET_CHECKERS
	#define CHECKER(FULLNAME, CLASS, DESCFILE, HELPTEXT, GROUPINDEX, HIDDEN) \
	if (!StringRef(FULLNAME).startswith("core") && \
	!StringRef(FULLNAME).startswith("debug") && \
	CheckRegex.match("clang-analyzer-" FULLNAME)) \
	Options->CheckersControlList.push_back(std::make_pair(FULLNAME, true));
	#include "../../../lib/StaticAnalyzer/Checkers/Checkers.inc"
	#undef CHECKER
	#undef GET_CHECKERS

	Options->AnalysisStoreOpt = RegionStoreModel;
	Options->AnalysisDiagOpt = PD_TEXT;
	Options->AnalyzeNestedBlocks = true;
	Options->eagerlyAssumeBinOpBifurcation = true;
	return new CombiningASTConsumer(
	Finder.newASTConsumer(),
	ento::AnalysisAction::CreateASTConsumer(Compiler, File));
	}

	virtual bool BeginSourceFileAction(CompilerInstance &Compiler,
	llvm::StringRef Filename) LLVM_OVERRIDE {
	if (!ento::AnalysisAction::BeginSourceFileAction(Compiler, Filename))
	return false;
	Context.setSourceManager(&Compiler.getSourceManager());
	for (SmallVectorImpl<ClangTidyCheck *>::iterator I = Checks.begin(),
	E = Checks.end();
	I != E; ++I)
	(*I)->registerPPCallbacks(Compiler);
	return true;
	}

	std::string CheckRegexString;
	SmallVectorImpl<ClangTidyCheck *> &Checks;
	ClangTidyContext &Context;
	MatchFinder &Finder;
	};

	class ClangTidyActionFactory : public FrontendActionFactory {
	public:
	ClangTidyActionFactory(StringRef CheckRegexString, ClangTidyContext &Context)
	: CheckRegexString(CheckRegexString), Context(Context) {
	ClangTidyCheckFactories CheckFactories;
	for (ClangTidyModuleRegistry::iterator I = ClangTidyModuleRegistry::begin(),
	E = ClangTidyModuleRegistry::end();
	I != E; ++I) {
	OwningPtr<ClangTidyModule> Module(I->instantiate());
	Module->addCheckFactories(CheckFactories);
	}

	SmallVector<ClangTidyCheck *, 16> Checks;
	CheckFactories.createChecks(CheckRegexString, Checks);

	for (SmallVectorImpl<ClangTidyCheck *>::iterator I = Checks.begin(),
	E = Checks.end();
	I != E; ++I) {
	(*I)->setContext(&Context);
	(*I)->registerMatchers(&Finder);
	}
	}

	virtual FrontendAction *create() {
	return new ClangTidyAction(CheckRegexString, Checks, Context, Finder);
	}

	private:
	std::string CheckRegexString;
	SmallVector<ClangTidyCheck *, 8> Checks;
	ClangTidyContext &Context;
	MatchFinder Finder;
	};

	} // namespace

	ClangTidyMessage::ClangTidyMessage(StringRef Message) : Message(Message) {}

	ClangTidyMessage::ClangTidyMessage(StringRef Message,
	const SourceManager &Sources,
	SourceLocation Loc)
	: Message(Message) {
	FilePath = Sources.getFilename(Loc);
	FileOffset = Sources.getFileOffset(Loc);
	}

	ClangTidyError::ClangTidyError(const ClangTidyMessage &Message)
	: Message(Message) {}

	DiagnosticBuilder ClangTidyContext::Diag(SourceLocation Loc,
	StringRef Message) {
	return DiagEngine->Report(
	Loc, DiagEngine->getCustomDiagID(DiagnosticsEngine::Warning, Message));
	}

	void ClangTidyContext::setDiagnosticsEngine(DiagnosticsEngine *Engine) {
	DiagEngine = Engine;
	}

	void ClangTidyContext::setSourceManager(SourceManager *SourceMgr) {
	DiagEngine->setSourceManager(SourceMgr);
	}

	/// \brief Store a \c ClangTidyError.
	void ClangTidyContext::storeError(const ClangTidyError &Error) {
	Errors->push_back(Error);
	}

	void ClangTidyCheck::run(const ast_matchers::MatchFinder::MatchResult &Result) {
	Context->setSourceManager(Result.SourceManager);
	check(Result);
	}

	FrontendActionFactory *createClangTidyActionFactory(StringRef CheckRegexString,
	ClangTidyContext &Context) {
	return new ClangTidyActionFactory(CheckRegexString, Context);
	}

	void runClangTidy(StringRef CheckRegexString,
	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);
	ClangTidyDiagnosticConsumer DiagConsumer(Context);

	Tool.setDiagnosticConsumer(&DiagConsumer);
	Tool.run(createClangTidyActionFactory(CheckRegexString, Context));
	}

	static void reportDiagnostic(const ClangTidyMessage &Message,
	SourceManager &SourceMgr,
	DiagnosticsEngine::Level Level,
	DiagnosticsEngine &Diags) {
	SourceLocation Loc;
	if (!Message.FilePath.empty()) {
	const FileEntry *File =
	SourceMgr.getFileManager().getFile(Message.FilePath);
	FileID ID = SourceMgr.createFileID(File, SourceLocation(), SrcMgr::C_User);
	Loc = SourceMgr.getLocForStartOfFile(ID);
	Loc = Loc.getLocWithOffset(Message.FileOffset);
	}
	Diags.Report(Loc, Diags.getCustomDiagID(Level, Message.Message));
	}

	void handleErrors(SmallVectorImpl<ClangTidyError> &Errors, bool Fix) {
	FileManager Files((FileSystemOptions()));
	IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts = new DiagnosticOptions();
	DiagnosticConsumer *DiagPrinter =
	new TextDiagnosticPrinter(llvm::outs(), &*DiagOpts);
	DiagnosticsEngine Diags(IntrusiveRefCntPtr<DiagnosticIDs>(new DiagnosticIDs),
	&*DiagOpts, DiagPrinter);
	DiagPrinter->BeginSourceFile(LangOptions());
	SourceManager SourceMgr(Diags, Files);
	Rewriter Rewrite(SourceMgr, LangOptions());
	for (SmallVectorImpl<ClangTidyError>::iterator I = Errors.begin(),
	E = Errors.end();
	I != E; ++I) {
	reportDiagnostic(I->Message, SourceMgr, DiagnosticsEngine::Warning, Diags);
	for (unsigned i = 0, e = I->Notes.size(); i != e; ++i) {
	reportDiagnostic(I->Notes[i], SourceMgr, DiagnosticsEngine::Note, Diags);
	}
	tooling::applyAllReplacements(I->Fix, Rewrite);
	}
	// FIXME: Run clang-format on changes.
	if (Fix)
	Rewrite.overwriteChangedFiles();
	}

	} // namespace tidy
	} // namespace clang