SourceRange DefnRefExpr::getSourceRange() const {
SourceRange R = getNameInfo().getSourceRange();
if (hasQualifier())
R.setBegin(getQualifierRange().getBegin());
return R;
}
static FixItHint removeArgument(const CallExpr *Call, unsigned Index) {
unsigned ArgCount = Call->getNumArgs();
const Expr *Arg = Call->getArg(Index);
SourceRange RemovalRange = Arg->getSourceRange();
if (ArgCount == 1)
return FixItHint::CreateRemoval(RemovalRange);
if (Index == 0)
RemovalRange.setEnd(
Call->getArg(Index + 1)->getLocStart().getLocWithOffset(-1));
else
RemovalRange.setBegin(
Call->getArg(Index - 1)->getLocEnd().getLocWithOffset(1));
return FixItHint::CreateRemoval(RemovalRange);
}
static FixItHint removeParameter(const FunctionDecl *Function, unsigned Index) {
const ParmVarDecl *Param = Function->getParamDecl(Index);
unsigned ParamCount = Function->getNumParams();
SourceRange RemovalRange = Param->getSourceRange();
if (ParamCount == 1)
return FixItHint::CreateRemoval(RemovalRange);
if (Index == 0)
RemovalRange.setEnd(
Function->getParamDecl(Index + 1)->getLocStart().getLocWithOffset(-1));
else
RemovalRange.setBegin(
Function->getParamDecl(Index - 1)->getLocEnd().getLocWithOffset(1));
return FixItHint::CreateRemoval(RemovalRange);
}
std::vector<FixItHint> Qt4_QStringFromArray::fixitInsertFromLatin1(CXXConstructExpr *ctorExpr)
{
vector<FixItHint> fixits;
SourceRange range;
Expr *arg = *(ctorExpr->arg_begin());
range.setBegin(arg->getLocStart());
range.setEnd(Lexer::getLocForEndOfToken(FixItUtils::biggestSourceLocationInStmt(sm(), ctorExpr), 0, sm(), lo()));
if (range.isInvalid()) {
emitWarning(ctorExpr->getLocStart(), "Internal error");
return {};
}
FixItUtils::insertParentMethodCall("QString::fromLatin1", range, fixits);
return fixits;
}
void RewriterASTConsumer::InclusionDirective(clang::SourceLocation HashLoc,
const clang::Token& IncludeTok,
clang::StringRef FileName,
bool IsAngled,
clang::CharSourceRange FilenameRange,
const clang::FileEntry* File,
clang::StringRef SearchPath,
clang::StringRef RelativePath,
const clang::Module* Imported)
{
if ("ParallelForEach.h" == FileName) {
SourceManager& SM = TheGpuRewriter.getSourceMgr();
SourceRange Range;
Range.setBegin(HashLoc);
Range.setEnd(SM.getSpellingLoc(FilenameRange.getEnd()));
TheGpuRewriter.RemoveText(Range);
}
}
void setBegin(SourceLocation L) { Range.setBegin(L); }
void setRange(SourceLocation B, SourceLocation E) {
Range.setBegin(B); Range.setEnd(E);
}
void setRange(SourceLocation L) { Range.setBegin(L); Range.setEnd(L); }
void IdentifierNamingCheck::check(const MatchFinder::MatchResult &Result) {
if (const auto *Decl =
Result.Nodes.getNodeAs<CXXConstructorDecl>("classRef")) {
if (Decl->isImplicit())
return;
addUsage(NamingCheckFailures, Decl->getParent(),
Decl->getNameInfo().getSourceRange());
for (const auto *Init : Decl->inits()) {
if (!Init->isWritten() || Init->isInClassMemberInitializer())
continue;
if (const auto *FD = Init->getAnyMember())
addUsage(NamingCheckFailures, FD,
SourceRange(Init->getMemberLocation()));
// Note: delegating constructors and base class initializers are handled
// via the "typeLoc" matcher.
}
return;
}
if (const auto *Decl =
Result.Nodes.getNodeAs<CXXDestructorDecl>("classRef")) {
if (Decl->isImplicit())
return;
SourceRange Range = Decl->getNameInfo().getSourceRange();
if (Range.getBegin().isInvalid())
return;
// The first token that will be found is the ~ (or the equivalent trigraph),
// we want instead to replace the next token, that will be the identifier.
Range.setBegin(CharSourceRange::getTokenRange(Range).getEnd());
addUsage(NamingCheckFailures, Decl->getParent(), Range);
return;
}
if (const auto *Loc = Result.Nodes.getNodeAs<TypeLoc>("typeLoc")) {
NamedDecl *Decl = nullptr;
if (const auto &Ref = Loc->getAs<TagTypeLoc>()) {
Decl = Ref.getDecl();
} else if (const auto &Ref = Loc->getAs<InjectedClassNameTypeLoc>()) {
Decl = Ref.getDecl();
} else if (const auto &Ref = Loc->getAs<UnresolvedUsingTypeLoc>()) {
Decl = Ref.getDecl();
} else if (const auto &Ref = Loc->getAs<TemplateTypeParmTypeLoc>()) {
Decl = Ref.getDecl();
}
if (Decl) {
addUsage(NamingCheckFailures, Decl, Loc->getSourceRange());
return;
}
if (const auto &Ref = Loc->getAs<TemplateSpecializationTypeLoc>()) {
const auto *Decl =
Ref.getTypePtr()->getTemplateName().getAsTemplateDecl();
SourceRange Range(Ref.getTemplateNameLoc(), Ref.getTemplateNameLoc());
if (const auto *ClassDecl = dyn_cast<TemplateDecl>(Decl)) {
if (const auto *TemplDecl = ClassDecl->getTemplatedDecl())
addUsage(NamingCheckFailures, TemplDecl, Range);
return;
}
}
if (const auto &Ref =
Loc->getAs<DependentTemplateSpecializationTypeLoc>()) {
if (const auto *Decl = Ref.getTypePtr()->getAsTagDecl())
addUsage(NamingCheckFailures, Decl, Loc->getSourceRange());
return;
}
}
if (const auto *Loc =
Result.Nodes.getNodeAs<NestedNameSpecifierLoc>("nestedNameLoc")) {
if (NestedNameSpecifier *Spec = Loc->getNestedNameSpecifier()) {
if (NamespaceDecl *Decl = Spec->getAsNamespace()) {
addUsage(NamingCheckFailures, Decl, Loc->getLocalSourceRange());
return;
}
}
}
if (const auto *Decl = Result.Nodes.getNodeAs<UsingDecl>("using")) {
for (const auto &Shadow : Decl->shadows()) {
addUsage(NamingCheckFailures, Shadow->getTargetDecl(),
Decl->getNameInfo().getSourceRange());
}
return;
}
if (const auto *DeclRef = Result.Nodes.getNodeAs<DeclRefExpr>("declRef")) {
SourceRange Range = DeclRef->getNameInfo().getSourceRange();
addUsage(NamingCheckFailures, DeclRef->getDecl(), Range,
Result.SourceManager);
return;
}
if (const auto *Decl = Result.Nodes.getNodeAs<NamedDecl>("decl")) {
if (!Decl->getIdentifier() || Decl->getName().empty() || Decl->isImplicit())
return;
// Fix type aliases in value declarations
if (const auto *Value = Result.Nodes.getNodeAs<ValueDecl>("decl")) {
if (const auto *Typedef =
Value->getType().getTypePtr()->getAs<TypedefType>()) {
addUsage(NamingCheckFailures, Typedef->getDecl(),
Value->getSourceRange());
}
}
// Fix type aliases in function declarations
if (const auto *Value = Result.Nodes.getNodeAs<FunctionDecl>("decl")) {
if (const auto *Typedef =
Value->getReturnType().getTypePtr()->getAs<TypedefType>()) {
addUsage(NamingCheckFailures, Typedef->getDecl(),
Value->getSourceRange());
}
for (unsigned i = 0; i < Value->getNumParams(); ++i) {
if (const auto *Typedef = Value->parameters()[i]
->getType()
.getTypePtr()
->getAs<TypedefType>()) {
addUsage(NamingCheckFailures, Typedef->getDecl(),
Value->getSourceRange());
}
}
}
// Ignore ClassTemplateSpecializationDecl which are creating duplicate
// replacements with CXXRecordDecl
if (isa<ClassTemplateSpecializationDecl>(Decl))
return;
StyleKind SK = findStyleKind(Decl, NamingStyles);
if (SK == SK_Invalid)
return;
if (!NamingStyles[SK])
return;
const NamingStyle &Style = *NamingStyles[SK];
StringRef Name = Decl->getName();
if (matchesStyle(Name, Style))
return;
std::string KindName = fixupWithCase(StyleNames[SK], CT_LowerCase);
std::replace(KindName.begin(), KindName.end(), '_', ' ');
std::string Fixup = fixupWithStyle(Name, Style);
if (StringRef(Fixup).equals(Name)) {
if (!IgnoreFailedSplit) {
DEBUG(llvm::dbgs()
<< Decl->getLocStart().printToString(*Result.SourceManager)
<< llvm::format(": unable to split words for %s '%s'\n",
KindName.c_str(), Name.str().c_str()));
}
} else {
NamingCheckFailure &Failure = NamingCheckFailures[NamingCheckId(
Decl->getLocation(), Decl->getNameAsString())];
SourceRange Range =
DeclarationNameInfo(Decl->getDeclName(), Decl->getLocation())
.getSourceRange();
Failure.Fixup = std::move(Fixup);
Failure.KindName = std::move(KindName);
addUsage(NamingCheckFailures, Decl, Range);
}
}
}
void IdentifierNamingCheck::check(const MatchFinder::MatchResult &Result) {
if (const auto *Decl =
Result.Nodes.getNodeAs<CXXConstructorDecl>("classRef")) {
if (Decl->isImplicit())
return;
addUsage(NamingCheckFailures, Decl->getParent(),
Decl->getNameInfo().getSourceRange(), Result.SourceManager);
return;
}
if (const auto *Decl =
Result.Nodes.getNodeAs<CXXDestructorDecl>("classRef")) {
if (Decl->isImplicit())
return;
SourceRange Range = Decl->getNameInfo().getSourceRange();
if (Range.getBegin().isInvalid())
return;
// The first token that will be found is the ~ (or the equivalent trigraph),
// we want instead to replace the next token, that will be the identifier.
Range.setBegin(CharSourceRange::getTokenRange(Range).getEnd());
addUsage(NamingCheckFailures, Decl->getParent(), Range,
Result.SourceManager);
return;
}
if (const auto *Loc = Result.Nodes.getNodeAs<TypeLoc>("typeLoc")) {
NamedDecl *Decl = nullptr;
if (const auto &Ref = Loc->getAs<TagTypeLoc>()) {
Decl = Ref.getDecl();
} else if (const auto &Ref = Loc->getAs<InjectedClassNameTypeLoc>()) {
Decl = Ref.getDecl();
} else if (const auto &Ref = Loc->getAs<UnresolvedUsingTypeLoc>()) {
Decl = Ref.getDecl();
} else if (const auto &Ref = Loc->getAs<TemplateTypeParmTypeLoc>()) {
Decl = Ref.getDecl();
}
if (Decl) {
addUsage(NamingCheckFailures, Decl, Loc->getSourceRange(),
Result.SourceManager);
return;
}
if (const auto &Ref = Loc->getAs<TemplateSpecializationTypeLoc>()) {
const auto *Decl =
Ref.getTypePtr()->getTemplateName().getAsTemplateDecl();
SourceRange Range(Ref.getTemplateNameLoc(), Ref.getTemplateNameLoc());
if (const auto *ClassDecl = dyn_cast<TemplateDecl>(Decl)) {
addUsage(NamingCheckFailures, ClassDecl->getTemplatedDecl(), Range,
Result.SourceManager);
return;
}
}
if (const auto &Ref =
Loc->getAs<DependentTemplateSpecializationTypeLoc>()) {
addUsage(NamingCheckFailures, Ref.getTypePtr()->getAsTagDecl(),
Loc->getSourceRange(), Result.SourceManager);
return;
}
}
if (const auto *Loc =
Result.Nodes.getNodeAs<NestedNameSpecifierLoc>("nestedNameLoc")) {
if (NestedNameSpecifier *Spec = Loc->getNestedNameSpecifier()) {
if (NamespaceDecl *Decl = Spec->getAsNamespace()) {
addUsage(NamingCheckFailures, Decl, Loc->getLocalSourceRange(),
Result.SourceManager);
return;
}
}
}
if (const auto *Decl = Result.Nodes.getNodeAs<UsingDecl>("using")) {
for (const auto &Shadow : Decl->shadows()) {
addUsage(NamingCheckFailures, Shadow->getTargetDecl(),
Decl->getNameInfo().getSourceRange(), Result.SourceManager);
}
return;
}
if (const auto *DeclRef = Result.Nodes.getNodeAs<DeclRefExpr>("declRef")) {
SourceRange Range = DeclRef->getNameInfo().getSourceRange();
addUsage(NamingCheckFailures, DeclRef->getDecl(), Range,
Result.SourceManager);
return;
}
if (const auto *Decl = Result.Nodes.getNodeAs<NamedDecl>("decl")) {
if (!Decl->getIdentifier() || Decl->getName().empty() || Decl->isImplicit())
return;
// Ignore ClassTemplateSpecializationDecl which are creating duplicate
// replacements with CXXRecordDecl
if (isa<ClassTemplateSpecializationDecl>(Decl))
return;
StyleKind SK = findStyleKind(Decl, NamingStyles);
if (SK == SK_Invalid)
return;
NamingStyle Style = NamingStyles[SK];
StringRef Name = Decl->getName();
if (matchesStyle(Name, Style))
return;
std::string KindName = fixupWithCase(StyleNames[SK], CT_LowerCase);
std::replace(KindName.begin(), KindName.end(), '_', ' ');
std::string Fixup = fixupWithStyle(Name, Style);
if (StringRef(Fixup).equals(Name)) {
if (!IgnoreFailedSplit) {
DEBUG(llvm::dbgs() << Decl->getLocStart().printToString(
*Result.SourceManager)
<< format(": unable to split words for %s '%s'\n",
KindName.c_str(), Name));
}
} else {
NamingCheckFailure &Failure = NamingCheckFailures[Decl];
SourceRange Range =
DeclarationNameInfo(Decl->getDeclName(), Decl->getLocation())
.getSourceRange();
Failure.Fixup = std::move(Fixup);
Failure.KindName = std::move(KindName);
addUsage(NamingCheckFailures, Decl, Range, Result.SourceManager);
}
}
}
