forked from OSchip/llvm-project
731 lines
27 KiB
C++
731 lines
27 KiB
C++
//===--- tools/extra/clang-tidy/ClangTidyDiagnosticConsumer.cpp ----------=== //
|
|
//
|
|
// 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
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
///
|
|
/// \file This file implements ClangTidyDiagnosticConsumer, ClangTidyContext
|
|
/// and ClangTidyError classes.
|
|
///
|
|
/// 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 "ClangTidyDiagnosticConsumer.h"
|
|
#include "ClangTidyOptions.h"
|
|
#include "GlobList.h"
|
|
#include "clang/AST/ASTDiagnostic.h"
|
|
#include "clang/AST/Attr.h"
|
|
#include "clang/Basic/Diagnostic.h"
|
|
#include "clang/Basic/DiagnosticOptions.h"
|
|
#include "clang/Frontend/DiagnosticRenderer.h"
|
|
#include "clang/Tooling/Core/Diagnostic.h"
|
|
#include "llvm/ADT/STLExtras.h"
|
|
#include "llvm/ADT/SmallString.h"
|
|
#include "llvm/Support/Regex.h"
|
|
#include <tuple>
|
|
#include <vector>
|
|
using namespace clang;
|
|
using namespace tidy;
|
|
|
|
namespace {
|
|
class ClangTidyDiagnosticRenderer : public DiagnosticRenderer {
|
|
public:
|
|
ClangTidyDiagnosticRenderer(const LangOptions &LangOpts,
|
|
DiagnosticOptions *DiagOpts,
|
|
ClangTidyError &Error)
|
|
: DiagnosticRenderer(LangOpts, DiagOpts), Error(Error) {}
|
|
|
|
protected:
|
|
void emitDiagnosticMessage(FullSourceLoc Loc, PresumedLoc PLoc,
|
|
DiagnosticsEngine::Level Level, StringRef Message,
|
|
ArrayRef<CharSourceRange> Ranges,
|
|
DiagOrStoredDiag Info) override {
|
|
// Remove check name from the message.
|
|
// FIXME: Remove this once there's a better way to pass check names than
|
|
// appending the check name to the message in ClangTidyContext::diag and
|
|
// using getCustomDiagID.
|
|
std::string CheckNameInMessage = " [" + Error.DiagnosticName + "]";
|
|
if (Message.endswith(CheckNameInMessage))
|
|
Message = Message.substr(0, Message.size() - CheckNameInMessage.size());
|
|
|
|
auto TidyMessage =
|
|
Loc.isValid()
|
|
? tooling::DiagnosticMessage(Message, Loc.getManager(), Loc)
|
|
: tooling::DiagnosticMessage(Message);
|
|
if (Level == DiagnosticsEngine::Note) {
|
|
Error.Notes.push_back(TidyMessage);
|
|
return;
|
|
}
|
|
assert(Error.Message.Message.empty() && "Overwriting a diagnostic message");
|
|
Error.Message = TidyMessage;
|
|
for (const CharSourceRange &SourceRange : Ranges) {
|
|
Error.Ranges.emplace_back(Loc.getManager(), SourceRange);
|
|
}
|
|
}
|
|
|
|
void emitDiagnosticLoc(FullSourceLoc Loc, PresumedLoc PLoc,
|
|
DiagnosticsEngine::Level Level,
|
|
ArrayRef<CharSourceRange> Ranges) override {}
|
|
|
|
void emitCodeContext(FullSourceLoc Loc, DiagnosticsEngine::Level Level,
|
|
SmallVectorImpl<CharSourceRange> &Ranges,
|
|
ArrayRef<FixItHint> Hints) override {
|
|
assert(Loc.isValid());
|
|
tooling::DiagnosticMessage *DiagWithFix =
|
|
Level == DiagnosticsEngine::Note ? &Error.Notes.back() : &Error.Message;
|
|
|
|
for (const auto &FixIt : Hints) {
|
|
CharSourceRange Range = FixIt.RemoveRange;
|
|
assert(Range.getBegin().isValid() && Range.getEnd().isValid() &&
|
|
"Invalid range in the fix-it hint.");
|
|
assert(Range.getBegin().isFileID() && Range.getEnd().isFileID() &&
|
|
"Only file locations supported in fix-it hints.");
|
|
|
|
tooling::Replacement Replacement(Loc.getManager(), Range,
|
|
FixIt.CodeToInsert);
|
|
llvm::Error Err =
|
|
DiagWithFix->Fix[Replacement.getFilePath()].add(Replacement);
|
|
// FIXME: better error handling (at least, don't let other replacements be
|
|
// applied).
|
|
if (Err) {
|
|
llvm::errs() << "Fix conflicts with existing fix! "
|
|
<< llvm::toString(std::move(Err)) << "\n";
|
|
assert(false && "Fix conflicts with existing fix!");
|
|
}
|
|
}
|
|
}
|
|
|
|
void emitIncludeLocation(FullSourceLoc Loc, PresumedLoc PLoc) override {}
|
|
|
|
void emitImportLocation(FullSourceLoc Loc, PresumedLoc PLoc,
|
|
StringRef ModuleName) override {}
|
|
|
|
void emitBuildingModuleLocation(FullSourceLoc Loc, PresumedLoc PLoc,
|
|
StringRef ModuleName) override {}
|
|
|
|
void endDiagnostic(DiagOrStoredDiag D,
|
|
DiagnosticsEngine::Level Level) override {
|
|
assert(!Error.Message.Message.empty() && "Message has not been set");
|
|
}
|
|
|
|
private:
|
|
ClangTidyError &Error;
|
|
};
|
|
} // end anonymous namespace
|
|
|
|
ClangTidyError::ClangTidyError(StringRef CheckName,
|
|
ClangTidyError::Level DiagLevel,
|
|
StringRef BuildDirectory, bool IsWarningAsError)
|
|
: tooling::Diagnostic(CheckName, DiagLevel, BuildDirectory),
|
|
IsWarningAsError(IsWarningAsError) {}
|
|
|
|
class ClangTidyContext::CachedGlobList {
|
|
public:
|
|
CachedGlobList(StringRef Globs) : Globs(Globs) {}
|
|
|
|
bool contains(StringRef S) {
|
|
switch (auto &Result = Cache[S]) {
|
|
case Yes:
|
|
return true;
|
|
case No:
|
|
return false;
|
|
case None:
|
|
Result = Globs.contains(S) ? Yes : No;
|
|
return Result == Yes;
|
|
}
|
|
llvm_unreachable("invalid enum");
|
|
}
|
|
|
|
private:
|
|
GlobList Globs;
|
|
enum Tristate { None, Yes, No };
|
|
llvm::StringMap<Tristate> Cache;
|
|
};
|
|
|
|
ClangTidyContext::ClangTidyContext(
|
|
std::unique_ptr<ClangTidyOptionsProvider> OptionsProvider,
|
|
bool AllowEnablingAnalyzerAlphaCheckers)
|
|
: DiagEngine(nullptr), OptionsProvider(std::move(OptionsProvider)),
|
|
Profile(false),
|
|
AllowEnablingAnalyzerAlphaCheckers(AllowEnablingAnalyzerAlphaCheckers) {
|
|
// Before the first translation unit we can get errors related to command-line
|
|
// parsing, use empty string for the file name in this case.
|
|
setCurrentFile("");
|
|
}
|
|
|
|
ClangTidyContext::~ClangTidyContext() = default;
|
|
|
|
DiagnosticBuilder ClangTidyContext::diag(
|
|
StringRef CheckName, SourceLocation Loc, StringRef Description,
|
|
DiagnosticIDs::Level Level /* = DiagnosticIDs::Warning*/) {
|
|
assert(Loc.isValid());
|
|
unsigned ID = DiagEngine->getDiagnosticIDs()->getCustomDiagID(
|
|
Level, (Description + " [" + CheckName + "]").str());
|
|
CheckNamesByDiagnosticID.try_emplace(ID, CheckName);
|
|
return DiagEngine->Report(Loc, ID);
|
|
}
|
|
|
|
void ClangTidyContext::setSourceManager(SourceManager *SourceMgr) {
|
|
DiagEngine->setSourceManager(SourceMgr);
|
|
}
|
|
|
|
void ClangTidyContext::setCurrentFile(StringRef File) {
|
|
CurrentFile = std::string(File);
|
|
CurrentOptions = getOptionsForFile(CurrentFile);
|
|
CheckFilter = std::make_unique<CachedGlobList>(*getOptions().Checks);
|
|
WarningAsErrorFilter =
|
|
std::make_unique<CachedGlobList>(*getOptions().WarningsAsErrors);
|
|
}
|
|
|
|
void ClangTidyContext::setASTContext(ASTContext *Context) {
|
|
DiagEngine->SetArgToStringFn(&FormatASTNodeDiagnosticArgument, Context);
|
|
LangOpts = Context->getLangOpts();
|
|
}
|
|
|
|
const ClangTidyGlobalOptions &ClangTidyContext::getGlobalOptions() const {
|
|
return OptionsProvider->getGlobalOptions();
|
|
}
|
|
|
|
const ClangTidyOptions &ClangTidyContext::getOptions() const {
|
|
return CurrentOptions;
|
|
}
|
|
|
|
ClangTidyOptions ClangTidyContext::getOptionsForFile(StringRef File) const {
|
|
// Merge options on top of getDefaults() as a safeguard against options with
|
|
// unset values.
|
|
return ClangTidyOptions::getDefaults().mergeWith(
|
|
OptionsProvider->getOptions(File));
|
|
}
|
|
|
|
void ClangTidyContext::setEnableProfiling(bool P) { Profile = P; }
|
|
|
|
void ClangTidyContext::setProfileStoragePrefix(StringRef Prefix) {
|
|
ProfilePrefix = std::string(Prefix);
|
|
}
|
|
|
|
llvm::Optional<ClangTidyProfiling::StorageParams>
|
|
ClangTidyContext::getProfileStorageParams() const {
|
|
if (ProfilePrefix.empty())
|
|
return llvm::None;
|
|
|
|
return ClangTidyProfiling::StorageParams(ProfilePrefix, CurrentFile);
|
|
}
|
|
|
|
bool ClangTidyContext::isCheckEnabled(StringRef CheckName) const {
|
|
assert(CheckFilter != nullptr);
|
|
return CheckFilter->contains(CheckName);
|
|
}
|
|
|
|
bool ClangTidyContext::treatAsError(StringRef CheckName) const {
|
|
assert(WarningAsErrorFilter != nullptr);
|
|
return WarningAsErrorFilter->contains(CheckName);
|
|
}
|
|
|
|
std::string ClangTidyContext::getCheckName(unsigned DiagnosticID) const {
|
|
std::string ClangWarningOption = std::string(
|
|
DiagEngine->getDiagnosticIDs()->getWarningOptionForDiag(DiagnosticID));
|
|
if (!ClangWarningOption.empty())
|
|
return "clang-diagnostic-" + ClangWarningOption;
|
|
llvm::DenseMap<unsigned, std::string>::const_iterator I =
|
|
CheckNamesByDiagnosticID.find(DiagnosticID);
|
|
if (I != CheckNamesByDiagnosticID.end())
|
|
return I->second;
|
|
return "";
|
|
}
|
|
|
|
ClangTidyDiagnosticConsumer::ClangTidyDiagnosticConsumer(
|
|
ClangTidyContext &Ctx, DiagnosticsEngine *ExternalDiagEngine,
|
|
bool RemoveIncompatibleErrors)
|
|
: Context(Ctx), ExternalDiagEngine(ExternalDiagEngine),
|
|
RemoveIncompatibleErrors(RemoveIncompatibleErrors),
|
|
LastErrorRelatesToUserCode(false), LastErrorPassesLineFilter(false),
|
|
LastErrorWasIgnored(false) {}
|
|
|
|
void ClangTidyDiagnosticConsumer::finalizeLastError() {
|
|
if (!Errors.empty()) {
|
|
ClangTidyError &Error = Errors.back();
|
|
if (!Context.isCheckEnabled(Error.DiagnosticName) &&
|
|
Error.DiagLevel != ClangTidyError::Error) {
|
|
++Context.Stats.ErrorsIgnoredCheckFilter;
|
|
Errors.pop_back();
|
|
} else if (!LastErrorRelatesToUserCode) {
|
|
++Context.Stats.ErrorsIgnoredNonUserCode;
|
|
Errors.pop_back();
|
|
} else if (!LastErrorPassesLineFilter) {
|
|
++Context.Stats.ErrorsIgnoredLineFilter;
|
|
Errors.pop_back();
|
|
} else {
|
|
++Context.Stats.ErrorsDisplayed;
|
|
}
|
|
}
|
|
LastErrorRelatesToUserCode = false;
|
|
LastErrorPassesLineFilter = false;
|
|
}
|
|
|
|
static bool IsNOLINTFound(StringRef NolintDirectiveText, StringRef Line,
|
|
unsigned DiagID, const ClangTidyContext &Context) {
|
|
const size_t NolintIndex = Line.find(NolintDirectiveText);
|
|
if (NolintIndex == StringRef::npos)
|
|
return false;
|
|
|
|
size_t BracketIndex = NolintIndex + NolintDirectiveText.size();
|
|
// Check if the specific checks are specified in brackets.
|
|
if (BracketIndex < Line.size() && Line[BracketIndex] == '(') {
|
|
++BracketIndex;
|
|
const size_t BracketEndIndex = Line.find(')', BracketIndex);
|
|
if (BracketEndIndex != StringRef::npos) {
|
|
StringRef ChecksStr =
|
|
Line.substr(BracketIndex, BracketEndIndex - BracketIndex);
|
|
// Allow disabling all the checks with "*".
|
|
if (ChecksStr != "*") {
|
|
std::string CheckName = Context.getCheckName(DiagID);
|
|
// Allow specifying a few check names, delimited with comma.
|
|
SmallVector<StringRef, 1> Checks;
|
|
ChecksStr.split(Checks, ',', -1, false);
|
|
llvm::transform(Checks, Checks.begin(),
|
|
[](StringRef S) { return S.trim(); });
|
|
return llvm::find(Checks, CheckName) != Checks.end();
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
static llvm::Optional<StringRef> getBuffer(const SourceManager &SM, FileID File,
|
|
bool AllowIO) {
|
|
// This is similar to the implementation of SourceManager::getBufferData(),
|
|
// but uses ContentCache::getRawBuffer() rather than getBuffer() if
|
|
// AllowIO=false, to avoid triggering file I/O if the file contents aren't
|
|
// already mapped.
|
|
bool CharDataInvalid = false;
|
|
const SrcMgr::SLocEntry &Entry = SM.getSLocEntry(File, &CharDataInvalid);
|
|
if (CharDataInvalid || !Entry.isFile())
|
|
return llvm::None;
|
|
const SrcMgr::ContentCache *Cache = Entry.getFile().getContentCache();
|
|
const llvm::MemoryBuffer *Buffer =
|
|
AllowIO ? Cache->getBuffer(SM.getDiagnostics(), SM.getFileManager(),
|
|
SourceLocation(), &CharDataInvalid)
|
|
: Cache->getRawBuffer();
|
|
if (!Buffer || CharDataInvalid)
|
|
return llvm::None;
|
|
return Buffer->getBuffer();
|
|
}
|
|
|
|
static bool LineIsMarkedWithNOLINT(const SourceManager &SM, SourceLocation Loc,
|
|
unsigned DiagID,
|
|
const ClangTidyContext &Context,
|
|
bool AllowIO) {
|
|
FileID File;
|
|
unsigned Offset;
|
|
std::tie(File, Offset) = SM.getDecomposedSpellingLoc(Loc);
|
|
llvm::Optional<StringRef> Buffer = getBuffer(SM, File, AllowIO);
|
|
if (!Buffer)
|
|
return false;
|
|
|
|
// Check if there's a NOLINT on this line.
|
|
StringRef RestOfLine = Buffer->substr(Offset).split('\n').first;
|
|
if (IsNOLINTFound("NOLINT", RestOfLine, DiagID, Context))
|
|
return true;
|
|
|
|
// Check if there's a NOLINTNEXTLINE on the previous line.
|
|
StringRef PrevLine =
|
|
Buffer->substr(0, Offset).rsplit('\n').first.rsplit('\n').second;
|
|
return IsNOLINTFound("NOLINTNEXTLINE", PrevLine, DiagID, Context);
|
|
}
|
|
|
|
static bool LineIsMarkedWithNOLINTinMacro(const SourceManager &SM,
|
|
SourceLocation Loc, unsigned DiagID,
|
|
const ClangTidyContext &Context,
|
|
bool AllowIO) {
|
|
while (true) {
|
|
if (LineIsMarkedWithNOLINT(SM, Loc, DiagID, Context, AllowIO))
|
|
return true;
|
|
if (!Loc.isMacroID())
|
|
return false;
|
|
Loc = SM.getImmediateExpansionRange(Loc).getBegin();
|
|
}
|
|
return false;
|
|
}
|
|
|
|
namespace clang {
|
|
namespace tidy {
|
|
|
|
bool shouldSuppressDiagnostic(DiagnosticsEngine::Level DiagLevel,
|
|
const Diagnostic &Info, ClangTidyContext &Context,
|
|
bool AllowIO) {
|
|
return Info.getLocation().isValid() &&
|
|
DiagLevel != DiagnosticsEngine::Error &&
|
|
DiagLevel != DiagnosticsEngine::Fatal &&
|
|
LineIsMarkedWithNOLINTinMacro(Info.getSourceManager(),
|
|
Info.getLocation(), Info.getID(),
|
|
Context, AllowIO);
|
|
}
|
|
|
|
} // namespace tidy
|
|
} // namespace clang
|
|
|
|
void ClangTidyDiagnosticConsumer::HandleDiagnostic(
|
|
DiagnosticsEngine::Level DiagLevel, const Diagnostic &Info) {
|
|
if (LastErrorWasIgnored && DiagLevel == DiagnosticsEngine::Note)
|
|
return;
|
|
|
|
if (shouldSuppressDiagnostic(DiagLevel, Info, Context)) {
|
|
++Context.Stats.ErrorsIgnoredNOLINT;
|
|
// Ignored a warning, should ignore related notes as well
|
|
LastErrorWasIgnored = true;
|
|
return;
|
|
}
|
|
|
|
LastErrorWasIgnored = false;
|
|
// Count warnings/errors.
|
|
DiagnosticConsumer::HandleDiagnostic(DiagLevel, Info);
|
|
|
|
if (DiagLevel == DiagnosticsEngine::Note) {
|
|
assert(!Errors.empty() &&
|
|
"A diagnostic note can only be appended to a message.");
|
|
} else {
|
|
finalizeLastError();
|
|
std::string CheckName = Context.getCheckName(Info.getID());
|
|
if (CheckName.empty()) {
|
|
// This is a compiler diagnostic without a warning option. Assign check
|
|
// name based on its level.
|
|
switch (DiagLevel) {
|
|
case DiagnosticsEngine::Error:
|
|
case DiagnosticsEngine::Fatal:
|
|
CheckName = "clang-diagnostic-error";
|
|
break;
|
|
case DiagnosticsEngine::Warning:
|
|
CheckName = "clang-diagnostic-warning";
|
|
break;
|
|
default:
|
|
CheckName = "clang-diagnostic-unknown";
|
|
break;
|
|
}
|
|
}
|
|
|
|
ClangTidyError::Level Level = ClangTidyError::Warning;
|
|
if (DiagLevel == DiagnosticsEngine::Error ||
|
|
DiagLevel == DiagnosticsEngine::Fatal) {
|
|
// Force reporting of Clang errors regardless of filters and non-user
|
|
// code.
|
|
Level = ClangTidyError::Error;
|
|
LastErrorRelatesToUserCode = true;
|
|
LastErrorPassesLineFilter = true;
|
|
}
|
|
bool IsWarningAsError = DiagLevel == DiagnosticsEngine::Warning &&
|
|
Context.treatAsError(CheckName);
|
|
Errors.emplace_back(CheckName, Level, Context.getCurrentBuildDirectory(),
|
|
IsWarningAsError);
|
|
}
|
|
|
|
if (ExternalDiagEngine) {
|
|
// If there is an external diagnostics engine, like in the
|
|
// ClangTidyPluginAction case, forward the diagnostics to it.
|
|
forwardDiagnostic(Info);
|
|
} else {
|
|
ClangTidyDiagnosticRenderer Converter(
|
|
Context.getLangOpts(), &Context.DiagEngine->getDiagnosticOptions(),
|
|
Errors.back());
|
|
SmallString<100> Message;
|
|
Info.FormatDiagnostic(Message);
|
|
FullSourceLoc Loc;
|
|
if (Info.getLocation().isValid() && Info.hasSourceManager())
|
|
Loc = FullSourceLoc(Info.getLocation(), Info.getSourceManager());
|
|
Converter.emitDiagnostic(Loc, DiagLevel, Message, Info.getRanges(),
|
|
Info.getFixItHints());
|
|
}
|
|
|
|
if (Info.hasSourceManager())
|
|
checkFilters(Info.getLocation(), Info.getSourceManager());
|
|
}
|
|
|
|
bool ClangTidyDiagnosticConsumer::passesLineFilter(StringRef FileName,
|
|
unsigned LineNumber) const {
|
|
if (Context.getGlobalOptions().LineFilter.empty())
|
|
return true;
|
|
for (const FileFilter &Filter : Context.getGlobalOptions().LineFilter) {
|
|
if (FileName.endswith(Filter.Name)) {
|
|
if (Filter.LineRanges.empty())
|
|
return true;
|
|
for (const FileFilter::LineRange &Range : Filter.LineRanges) {
|
|
if (Range.first <= LineNumber && LineNumber <= Range.second)
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void ClangTidyDiagnosticConsumer::forwardDiagnostic(const Diagnostic &Info) {
|
|
// Acquire a diagnostic ID also in the external diagnostics engine.
|
|
auto DiagLevelAndFormatString =
|
|
Context.getDiagLevelAndFormatString(Info.getID(), Info.getLocation());
|
|
unsigned ExternalID = ExternalDiagEngine->getDiagnosticIDs()->getCustomDiagID(
|
|
DiagLevelAndFormatString.first, DiagLevelAndFormatString.second);
|
|
|
|
// Forward the details.
|
|
auto Builder = ExternalDiagEngine->Report(Info.getLocation(), ExternalID);
|
|
for (auto Hint : Info.getFixItHints())
|
|
Builder << Hint;
|
|
for (auto Range : Info.getRanges())
|
|
Builder << Range;
|
|
for (unsigned Index = 0; Index < Info.getNumArgs(); ++Index) {
|
|
DiagnosticsEngine::ArgumentKind Kind = Info.getArgKind(Index);
|
|
switch (Kind) {
|
|
case clang::DiagnosticsEngine::ak_std_string:
|
|
Builder << Info.getArgStdStr(Index);
|
|
break;
|
|
case clang::DiagnosticsEngine::ak_c_string:
|
|
Builder << Info.getArgCStr(Index);
|
|
break;
|
|
case clang::DiagnosticsEngine::ak_sint:
|
|
Builder << Info.getArgSInt(Index);
|
|
break;
|
|
case clang::DiagnosticsEngine::ak_uint:
|
|
Builder << Info.getArgUInt(Index);
|
|
break;
|
|
case clang::DiagnosticsEngine::ak_tokenkind:
|
|
Builder << static_cast<tok::TokenKind>(Info.getRawArg(Index));
|
|
break;
|
|
case clang::DiagnosticsEngine::ak_identifierinfo:
|
|
Builder << Info.getArgIdentifier(Index);
|
|
break;
|
|
case clang::DiagnosticsEngine::ak_qual:
|
|
Builder << Qualifiers::fromOpaqueValue(Info.getRawArg(Index));
|
|
break;
|
|
case clang::DiagnosticsEngine::ak_qualtype:
|
|
Builder << QualType::getFromOpaquePtr((void *)Info.getRawArg(Index));
|
|
break;
|
|
case clang::DiagnosticsEngine::ak_declarationname:
|
|
Builder << DeclarationName::getFromOpaqueInteger(Info.getRawArg(Index));
|
|
break;
|
|
case clang::DiagnosticsEngine::ak_nameddecl:
|
|
Builder << reinterpret_cast<const NamedDecl *>(Info.getRawArg(Index));
|
|
break;
|
|
case clang::DiagnosticsEngine::ak_nestednamespec:
|
|
Builder << reinterpret_cast<NestedNameSpecifier *>(Info.getRawArg(Index));
|
|
break;
|
|
case clang::DiagnosticsEngine::ak_declcontext:
|
|
Builder << reinterpret_cast<DeclContext *>(Info.getRawArg(Index));
|
|
break;
|
|
case clang::DiagnosticsEngine::ak_qualtype_pair:
|
|
assert(false); // This one is not passed around.
|
|
break;
|
|
case clang::DiagnosticsEngine::ak_attr:
|
|
Builder << reinterpret_cast<Attr *>(Info.getRawArg(Index));
|
|
break;
|
|
case clang::DiagnosticsEngine::ak_addrspace:
|
|
Builder << static_cast<LangAS>(Info.getRawArg(Index));
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void ClangTidyDiagnosticConsumer::checkFilters(SourceLocation Location,
|
|
const SourceManager &Sources) {
|
|
// Invalid location may mean a diagnostic in a command line, don't skip these.
|
|
if (!Location.isValid()) {
|
|
LastErrorRelatesToUserCode = true;
|
|
LastErrorPassesLineFilter = true;
|
|
return;
|
|
}
|
|
|
|
if (!*Context.getOptions().SystemHeaders &&
|
|
Sources.isInSystemHeader(Location))
|
|
return;
|
|
|
|
// FIXME: We start with a conservative approach here, but the actual type of
|
|
// location needed depends on the check (in particular, where this check wants
|
|
// to apply fixes).
|
|
FileID FID = Sources.getDecomposedExpansionLoc(Location).first;
|
|
const FileEntry *File = Sources.getFileEntryForID(FID);
|
|
|
|
// -DMACRO definitions on the command line have locations in a virtual buffer
|
|
// that doesn't have a FileEntry. Don't skip these as well.
|
|
if (!File) {
|
|
LastErrorRelatesToUserCode = true;
|
|
LastErrorPassesLineFilter = true;
|
|
return;
|
|
}
|
|
|
|
StringRef FileName(File->getName());
|
|
LastErrorRelatesToUserCode = LastErrorRelatesToUserCode ||
|
|
Sources.isInMainFile(Location) ||
|
|
getHeaderFilter()->match(FileName);
|
|
|
|
unsigned LineNumber = Sources.getExpansionLineNumber(Location);
|
|
LastErrorPassesLineFilter =
|
|
LastErrorPassesLineFilter || passesLineFilter(FileName, LineNumber);
|
|
}
|
|
|
|
llvm::Regex *ClangTidyDiagnosticConsumer::getHeaderFilter() {
|
|
if (!HeaderFilter)
|
|
HeaderFilter =
|
|
std::make_unique<llvm::Regex>(*Context.getOptions().HeaderFilterRegex);
|
|
return HeaderFilter.get();
|
|
}
|
|
|
|
void ClangTidyDiagnosticConsumer::removeIncompatibleErrors() {
|
|
// Each error is modelled as the set of intervals in which it applies
|
|
// replacements. To detect overlapping replacements, we use a sweep line
|
|
// algorithm over these sets of intervals.
|
|
// An event here consists of the opening or closing of an interval. During the
|
|
// process, we maintain a counter with the amount of open intervals. If we
|
|
// find an endpoint of an interval and this counter is different from 0, it
|
|
// means that this interval overlaps with another one, so we set it as
|
|
// inapplicable.
|
|
struct Event {
|
|
// An event can be either the begin or the end of an interval.
|
|
enum EventType {
|
|
ET_Begin = 1,
|
|
ET_End = -1,
|
|
};
|
|
|
|
Event(unsigned Begin, unsigned End, EventType Type, unsigned ErrorId,
|
|
unsigned ErrorSize)
|
|
: Type(Type), ErrorId(ErrorId) {
|
|
// The events are going to be sorted by their position. In case of draw:
|
|
//
|
|
// * If an interval ends at the same position at which other interval
|
|
// begins, this is not an overlapping, so we want to remove the ending
|
|
// interval before adding the starting one: end events have higher
|
|
// priority than begin events.
|
|
//
|
|
// * If we have several begin points at the same position, we will mark as
|
|
// inapplicable the ones that we process later, so the first one has to
|
|
// be the one with the latest end point, because this one will contain
|
|
// all the other intervals. For the same reason, if we have several end
|
|
// points in the same position, the last one has to be the one with the
|
|
// earliest begin point. In both cases, we sort non-increasingly by the
|
|
// position of the complementary.
|
|
//
|
|
// * In case of two equal intervals, the one whose error is bigger can
|
|
// potentially contain the other one, so we want to process its begin
|
|
// points before and its end points later.
|
|
//
|
|
// * Finally, if we have two equal intervals whose errors have the same
|
|
// size, none of them will be strictly contained inside the other.
|
|
// Sorting by ErrorId will guarantee that the begin point of the first
|
|
// one will be processed before, disallowing the second one, and the
|
|
// end point of the first one will also be processed before,
|
|
// disallowing the first one.
|
|
if (Type == ET_Begin)
|
|
Priority = std::make_tuple(Begin, Type, -End, -ErrorSize, ErrorId);
|
|
else
|
|
Priority = std::make_tuple(End, Type, -Begin, ErrorSize, ErrorId);
|
|
}
|
|
|
|
bool operator<(const Event &Other) const {
|
|
return Priority < Other.Priority;
|
|
}
|
|
|
|
// Determines if this event is the begin or the end of an interval.
|
|
EventType Type;
|
|
// The index of the error to which the interval that generated this event
|
|
// belongs.
|
|
unsigned ErrorId;
|
|
// The events will be sorted based on this field.
|
|
std::tuple<unsigned, EventType, int, int, unsigned> Priority;
|
|
};
|
|
|
|
// Compute error sizes.
|
|
std::vector<int> Sizes;
|
|
std::vector<
|
|
std::pair<ClangTidyError *, llvm::StringMap<tooling::Replacements> *>>
|
|
ErrorFixes;
|
|
for (auto &Error : Errors) {
|
|
if (const auto *Fix = tooling::selectFirstFix(Error))
|
|
ErrorFixes.emplace_back(
|
|
&Error, const_cast<llvm::StringMap<tooling::Replacements> *>(Fix));
|
|
}
|
|
for (const auto &ErrorAndFix : ErrorFixes) {
|
|
int Size = 0;
|
|
for (const auto &FileAndReplaces : *ErrorAndFix.second) {
|
|
for (const auto &Replace : FileAndReplaces.second)
|
|
Size += Replace.getLength();
|
|
}
|
|
Sizes.push_back(Size);
|
|
}
|
|
|
|
// Build events from error intervals.
|
|
std::map<std::string, std::vector<Event>> FileEvents;
|
|
for (unsigned I = 0; I < ErrorFixes.size(); ++I) {
|
|
for (const auto &FileAndReplace : *ErrorFixes[I].second) {
|
|
for (const auto &Replace : FileAndReplace.second) {
|
|
unsigned Begin = Replace.getOffset();
|
|
unsigned End = Begin + Replace.getLength();
|
|
const std::string &FilePath = std::string(Replace.getFilePath());
|
|
// FIXME: Handle empty intervals, such as those from insertions.
|
|
if (Begin == End)
|
|
continue;
|
|
auto &Events = FileEvents[FilePath];
|
|
Events.emplace_back(Begin, End, Event::ET_Begin, I, Sizes[I]);
|
|
Events.emplace_back(Begin, End, Event::ET_End, I, Sizes[I]);
|
|
}
|
|
}
|
|
}
|
|
|
|
std::vector<bool> Apply(ErrorFixes.size(), true);
|
|
for (auto &FileAndEvents : FileEvents) {
|
|
std::vector<Event> &Events = FileAndEvents.second;
|
|
// Sweep.
|
|
llvm::sort(Events);
|
|
int OpenIntervals = 0;
|
|
for (const auto &Event : Events) {
|
|
if (Event.Type == Event::ET_End)
|
|
--OpenIntervals;
|
|
// This has to be checked after removing the interval from the count if it
|
|
// is an end event, or before adding it if it is a begin event.
|
|
if (OpenIntervals != 0)
|
|
Apply[Event.ErrorId] = false;
|
|
if (Event.Type == Event::ET_Begin)
|
|
++OpenIntervals;
|
|
}
|
|
assert(OpenIntervals == 0 && "Amount of begin/end points doesn't match");
|
|
}
|
|
|
|
for (unsigned I = 0; I < ErrorFixes.size(); ++I) {
|
|
if (!Apply[I]) {
|
|
ErrorFixes[I].second->clear();
|
|
ErrorFixes[I].first->Notes.emplace_back(
|
|
"this fix will not be applied because it overlaps with another fix");
|
|
}
|
|
}
|
|
}
|
|
|
|
namespace {
|
|
struct LessClangTidyError {
|
|
bool operator()(const ClangTidyError &LHS, const ClangTidyError &RHS) const {
|
|
const tooling::DiagnosticMessage &M1 = LHS.Message;
|
|
const tooling::DiagnosticMessage &M2 = RHS.Message;
|
|
|
|
return std::tie(M1.FilePath, M1.FileOffset, LHS.DiagnosticName,
|
|
M1.Message) <
|
|
std::tie(M2.FilePath, M2.FileOffset, RHS.DiagnosticName, M2.Message);
|
|
}
|
|
};
|
|
struct EqualClangTidyError {
|
|
bool operator()(const ClangTidyError &LHS, const ClangTidyError &RHS) const {
|
|
LessClangTidyError Less;
|
|
return !Less(LHS, RHS) && !Less(RHS, LHS);
|
|
}
|
|
};
|
|
} // end anonymous namespace
|
|
|
|
std::vector<ClangTidyError> ClangTidyDiagnosticConsumer::take() {
|
|
finalizeLastError();
|
|
|
|
llvm::sort(Errors, LessClangTidyError());
|
|
Errors.erase(std::unique(Errors.begin(), Errors.end(), EqualClangTidyError()),
|
|
Errors.end());
|
|
if (RemoveIncompatibleErrors)
|
|
removeIncompatibleErrors();
|
|
return std::move(Errors);
|
|
}
|