This is an archive of the discontinued LLVM Phabricator instance.

Differential D67827

[clangd] Simplify name qualification in DefineInline
AbandonedPublic

Authored by ilya-biryukov on Sep 20 2019, 4:22 AM.

Details

Reviewers
None
Summary

By using new helpers from FindTarget.h

Diff Detail

Revision Contents

PathSize
clang-tools-extra/
clangd/
refactor/
tweaks/
317 lines
unittests/
12 lines

Diff 221000

clang-tools-extra/clangd/refactor/tweaks/DefineInline.cpp

Show First 20 Lines • Show All 42 Lines • ▼ Show 20 Lines
#include "llvm/ADT/DenseSet.h" #include "llvm/ADT/DenseSet.h"
#include "llvm/ADT/Optional.h" #include "llvm/ADT/Optional.h"
#include "llvm/ADT/STLExtras.h" #include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/StringRef.h" #include "llvm/ADT/StringRef.h"
#include "llvm/Support/Casting.h" #include "llvm/Support/Casting.h"
#include "llvm/Support/Error.h" #include "llvm/Support/Error.h"
#include "llvm/Support/Signals.h" #include "llvm/Support/Signals.h"
#include "llvm/Support/raw_ostream.h" #include "llvm/Support/raw_ostream.h"
#include "FindTarget.h"
#include <cstddef> #include <cstddef>
#include <set> #include <set>
#include <string> #include <string>
#include <unordered_map> #include <unordered_map>
#include <vector> #include <vector>
namespace clang { namespace clang {
namespace clangd { namespace clangd {
Show All 29 Linesconst FunctionDecl *getSelectedFunction(const SelectionTree::Node *SelNode) {
if (AstNode.get<CompoundStmt>() && if (AstNode.get<CompoundStmt>() &&
SelNode->Selected == SelectionTree::Complete) { SelNode->Selected == SelectionTree::Complete) {
if (const SelectionTree::Node *P = SelNode->Parent) if (const SelectionTree::Node *P = SelNode->Parent)
return P->ASTNode.get<FunctionDecl>(); return P->ASTNode.get<FunctionDecl>();
} }
return nullptr; return nullptr;
} }
// There are three types of spellings that needs to be qualified in a function
// body:
// - Types: Foo -> ns::Foo
// - DeclRefExpr: ns2::foo() -> ns1::ns2::foo();
// - UsingDecls:
// using ns2::foo -> using ns1::ns2::foo
// using namespace ns2 -> using namespace ns1::ns2
// using ns3 = ns2 -> using ns3 = ns1::ns2
//
// Goes over all DeclRefExprs, TypeLocs, and Using{,Directive}Decls inside a
// function body to generate replacements that will fully qualify those. So that
// body can be moved into an arbitrary file.
// We perform the qualification by qualyfying the last type/decl in a
// (un)qualified name. e.g:
// namespace a { namespace b { class Bar{}; void foo(); } }
// b::Bar x; -> a::b::Bar x;
// foo(); -> a::b::foo();
// Currently there is no way to know whether a given TypeLoc is the last one or
// not, therefore we generate replacements for all the TypeLocs we see in a
// given name and pick only the longest one.
// FIXME: Instead of fully qualyfying we should try deducing visible scopes at
// target location and generate minimal edits.
class QualifyingVisitor : public RecursiveASTVisitor<QualifyingVisitor> {
public:
QualifyingVisitor(const FunctionDecl *FD)
: LangOpts(FD->getASTContext().getLangOpts()),
SM(FD->getASTContext().getSourceManager()),
BodyBegin(SM.getFileOffset(FD->getBody()->getBeginLoc())) {
TraverseStmt(FD->getBody());
}
// We override traversals for DeclRefExprs and TypeLocs to generate an edit
// only for the last Type/Decl in a written name. Also it enables us to catch
// current range of the name as written, since the last Type/Decl doesn't
// contain that information.
bool TraverseDeclRefExpr(DeclRefExpr *DRE) {
maybeUpdateCurrentRange(DRE->getSourceRange());
return RecursiveASTVisitor<QualifyingVisitor>::TraverseDeclRefExpr(DRE);
}
bool TraverseTypeLoc(TypeLoc TL) {
maybeUpdateCurrentRange(TL.getSourceRange());
return RecursiveASTVisitor<QualifyingVisitor>::TraverseTypeLoc(TL);
}
// Generates a replacement that will qualify templated name and arguments.
bool VisitTemplateSpecializationTypeLoc(TemplateSpecializationTypeLoc TSTL) {
std::string Qualified;
llvm::raw_string_ostream OS(Qualified);
QualType Ty = TSTL.getType();
if (Ty->isDependentType()) {
// We don't have a decl if type is dependent, use the TemplateDecl
// instead.
const TemplateDecl *TD =
TSTL.getTypePtr()->getTemplateName().getAsTemplateDecl();
TD->printQualifiedName(OS);
// FIXME: For some reason this prints types as written in source code,
// instead of fully qualified version,
// i.e: a::Bar<Bar<T>> instead of a::Bar<a::Bar<T>>
printTemplateArgumentList(OS, TSTL.getTypePtr()->template_arguments(),
TD->getASTContext().getPrintingPolicy());
} else if (const auto *CTSD =
llvm::dyn_cast<ClassTemplateSpecializationDecl>(
TSTL.getType()->getAsTagDecl())) {
CTSD->printQualifiedName(OS);
printTemplateArgumentList(OS, CTSD->getTemplateArgs().asArray(),
CTSD->getASTContext().getPrintingPolicy());
}
OS.flush();
maybeUpdateReplacement(Qualified);
return true;
}
// Qualifies TagTypes, we are not interested in other TypeLocs since they
// can't have nested name specifiers.
bool VisitTagTypeLoc(TagTypeLoc TTL) {
const TagDecl *TD = TTL.getDecl();
if (index::isFunctionLocalSymbol(TD))
return true;
// FIXME: Instead of fully qualifying, try to drop visible scopes.
maybeUpdateReplacement(TD->getQualifiedNameAsString());
return true;
}
bool VisitDeclRefExpr(DeclRefExpr *DRE) {
NamedDecl *ND = DRE->getFoundDecl();
// UsingShadowDecls are considered local, but we might need to qualify them
// if the UsingDecl is not inside function body.
if (auto USD = llvm::dyn_cast<UsingShadowDecl>(ND))
ND = USD->getTargetDecl();
// No need to re-write local symbols.
if (index::isFunctionLocalSymbol(ND))
return true;
std::string Qualified;
// For templates, in addition to decl name, also print the argument list.
if (auto *VTSD = llvm::dyn_cast<VarTemplateSpecializationDecl>(ND)) {
llvm::raw_string_ostream OS(Qualified);
VTSD->printQualifiedName(OS);
printTemplateArgumentList(OS, VTSD->getTemplateArgs().asArray(),
ND->getASTContext().getPrintingPolicy());
} else if (auto *FTD = llvm::dyn_cast<FunctionTemplateDecl>(ND)) {
llvm::raw_string_ostream OS(Qualified);
FTD->printQualifiedName(OS);
printTemplateArgumentList(OS,
llvm::dyn_cast<FunctionDecl>(DRE->getDecl())
->getTemplateSpecializationArgs()
->asArray(),
ND->getASTContext().getPrintingPolicy());
} else {
Qualified = ND->getQualifiedNameAsString();
}
maybeUpdateReplacement(Qualified);
return true;
}
// For using decls, we chose the first shadow decls. This should not make
// any difference, since all of the shadow decls should have the same
// fully-qualified name.
bool VisitUsingDecl(UsingDecl *UD) {
flushCurrentReplacement();
maybeUpdateCurrentRange(
SourceRange(UD->getQualifierLoc().getBeginLoc(), UD->getEndLoc()));
maybeUpdateReplacement(
UD->shadow_begin()->getTargetDecl()->getQualifiedNameAsString());
return true;
}
// Using-directives are "special" NamedDecls, they span the whole
// declaration and their names are not directly useful, we need to peek
// into underlying NamespaceDecl for qualified name and start location.
bool VisitUsingDirectiveDecl(UsingDirectiveDecl *UDD) {
flushCurrentReplacement();
SourceRange RepRange;
if (auto NNSL = UDD->getQualifierLoc())
RepRange.setBegin(NNSL.getBeginLoc());
else
RepRange.setBegin(UDD->getIdentLocation());
RepRange.setEnd(UDD->getEndLoc());
maybeUpdateCurrentRange(RepRange);
maybeUpdateReplacement(
UDD->getNominatedNamespaceAsWritten()->getQualifiedNameAsString());
return true;
}
// Qualifies namespace alias decls of the form:
// using newns = ns2 -> using newns = ns1::ns2
bool VisitNamespaceAliasDecl(NamespaceAliasDecl *NAD) {
flushCurrentReplacement();
SourceRange RepRange;
if (auto NNSL = NAD->getQualifierLoc())
RepRange.setBegin(NNSL.getBeginLoc());
else
RepRange.setBegin(NAD->getTargetNameLoc());
RepRange.setEnd(NAD->getEndLoc());
maybeUpdateCurrentRange(RepRange);
maybeUpdateReplacement(
NAD->getAliasedNamespace()->getQualifiedNameAsString());
return true;
}
tooling::Replacements getReplacements() {
// flush the last replacement.
flushCurrentReplacement();
return Reps;
}
private:
// Updates the CurrentRange to NewRange if it is not overlapping with
// CurrentRange. Also flushes the replacement for CurrentRange before updating
// it.
void maybeUpdateCurrentRange(SourceRange NewRange) {
if (NewRange.isInvalid())
return;
if (CurrentChange &&
SM.isBeforeInSLocAddrSpace(
NewRange.getBegin(),
// We use EndLoc+1 since CurrentChange also owns the token
// starting at EndLoc.
CurrentChange->Range.getEnd().getLocWithOffset(1))) {
return;
}
flushCurrentReplacement();
CurrentChange.emplace();
CurrentChange->Range = NewRange;
}
// Changes CurReplacement to contain RepText if it is longer.
void maybeUpdateReplacement(llvm::StringRef RepText) {
assert(CurrentChange && "Updating non-existing replacement");
if (CurrentChange->Text.size() > RepText.size())
return;
CurrentChange->Text = RepText;
}
// Adds current replacement, the longest one for the current range, to the
// Reps.
void flushCurrentReplacement() {
if (!CurrentChange || CurrentChange->Text.empty())
return;
SourceLocation Begin = CurrentChange->Range.getBegin();
SourceLocation End = Lexer::getLocForEndOfToken(
CurrentChange->Range.getEnd(), 0, SM, LangOpts);
unsigned int BeginOff = SM.getFileOffset(Begin) - BodyBegin;
unsigned int EndOff = SM.getFileOffset(End) - BodyBegin;
const tooling::Replacement Replacement("", BeginOff, EndOff - BeginOff,
CurrentChange->Text);
CurrentChange.reset();
if (auto Err = Reps.add(Replacement)) {
handleAllErrors(std::move(Err), [&](const llvm::ErrorInfoBase &EI) {
std::string ErrMsg;
llvm::raw_string_ostream OS(ErrMsg);
EI.log(OS);
elog("Failed to add replacement:{0}", ErrMsg);
});
}
}
const LangOptions LangOpts;
const SourceManager &SM;
// Used as reference points for replacements.
const unsigned int BodyBegin;
tooling::Replacements Reps;
struct Change {
SourceRange Range; // to be replaced in the original source.
std::string Text; // to replace the range.
};
// Change to apply for ast node currently being visited.
llvm::Optional<Change> CurrentChange;
};
// Runs clang indexing api to get a list of declarations referenced inside // Runs clang indexing api to get a list of declarations referenced inside
// function decl. Skips local symbols. // function decl. Skips local symbols.
llvm::DenseSet<const Decl *> getNonLocalDeclRefs(const FunctionDecl *FD, llvm::DenseSet<const Decl *> getNonLocalDeclRefs(const FunctionDecl *FD,
ParsedAST &AST) { ParsedAST &AST) {
class DeclRecorder : public index::IndexDataConsumer { class DeclRecorder : public index::IndexDataConsumer {
public: public:
bool handleDeclOccurence(const Decl *D, index::SymbolRoleSet Roles, bool handleDeclOccurence(const Decl *D, index::SymbolRoleSet Roles,
ArrayRef<index::SymbolRelation> Relations, ArrayRef<index::SymbolRelation> Relations,
▲ Show 20 Lines • Show All 60 Lines • ▼ Show 20 Lines else if (const auto *FD = llvm::dyn_cast<FieldDecl>(D))
Parent = FD->getParent(); Parent = FD->getParent();
if (Parent != Class) if (Parent != Class)
return false; return false;
} }
return true; return true;
} }
// Rewrites body of FD to fully-qualify all of the decls inside. // Rewrites body of FD to fully-qualify all of the decls inside.
// There are three types of spellings that needs to be qualified in a function
// body:
// - Types: Foo -> ns::Foo
// - DeclRefExpr: ns2::foo() -> ns1::ns2::foo();
// - UsingDecls:
// using ns2::foo -> using ns1::ns2::foo
// using namespace ns2 -> using namespace ns1::ns2
// using ns3 = ns2 -> using ns3 = ns1::ns2
//
// Go over all references inside a function body and generate replacements to
// fully qualify those. After that, the body can be moved into an arbitrary
// file. We perform the qualification by qualyfying the last type/decl in a
// (un)qualified name. e.g:
// namespace a { namespace b { class Bar{}; void foo(); } }
// b::Bar x; -> a::b::Bar x;
// foo(); -> a::b::foo();
// FIXME: Instead of fully qualyfying we should try deducing visible scopes at
// target location and generate minimal edits.
llvm::Expected<std::string> qualifyAllDecls(const FunctionDecl *FD) { llvm::Expected<std::string> qualifyAllDecls(const FunctionDecl *FD) {
auto &Ctx = FD->getASTContext();
auto &SM = Ctx.getSourceManager();
// Compute replacements to qualify all reference in the funciton body.
tooling::Replacements Replacements;
findExplicitReferences(FD->getBody(), [&](ReferenceLoc R) {
assert(R.NameLoc.isValid());
// Only update unqualified references.
if (R.Qualifier || R.Targets.empty())
return;
// No need to turn `foo.x` into `foo.Class::x`.
if (R.MemberExprBase)
return;
// Make sure we have a location to add the qualifier.
if (!R.NameLoc.isFileID() || SM.getFileID(R.NameLoc) != SM.getMainFileID())
return;
if (index::isFunctionLocalSymbol(R.Targets.front()))
return;
std::string Qualifier;
llvm::raw_string_ostream OS(Qualifier);
R.Targets.front()->printQualifier(OS);
OS.flush();
if (Qualifier.empty())
return;
if (auto Err = Replacements.add(
tooling::Replacement(SM, R.NameLoc, /*Length*/ 0, Qualifier)))
elog("Failed to add qualifier: {0}", std::move(Err));
});
auto NewFile = tooling::applyAllReplacements(
SM.getBufferData(SM.getMainFileID()), Replacements);
if (!NewFile)
return NewFile.takeError();
// We need to return the new function body, extract it from the whole file.
SourceRange OrigFuncRange = FD->getBody()->getSourceRange(); SourceRange OrigFuncRange = FD->getBody()->getSourceRange();
// toSourceCode expects an halfOpenRange, but FuncBody is closed. // toSourceCode expects an halfOpenRange, but FuncBody is closed.
OrigFuncRange.setEnd(OrigFuncRange.getEnd().getLocWithOffset(1)); OrigFuncRange.setEnd(OrigFuncRange.getEnd().getLocWithOffset(1));
// applyAllReplacements expects a null terminated string, therefore we make a assert(isValidFileRange(SM, OrigFuncRange));
// copy here. unsigned ShiftedBegin = Replacements.getShiftedCodePosition(
std::string OrigFuncBody = SM.getFileOffset(OrigFuncRange.getBegin()));
toSourceCode(FD->getASTContext().getSourceManager(), OrigFuncRange); assert(ShiftedBegin == SM.getFileOffset(OrigFuncRange.getBegin()) &&
"expected no changes before start of function body");
return tooling::applyAllReplacements(OrigFuncBody, unsigned ShiftedEnd = Replacements.getShiftedCodePosition(
QualifyingVisitor(FD).getReplacements()); SM.getFileOffset(OrigFuncRange.getEnd()));
return NewFile->substr(ShiftedBegin, ShiftedEnd - ShiftedBegin);
} }
// Returns the canonical declaration for the given FunctionDecl. This will // Returns the canonical declaration for the given FunctionDecl. This will
// usually be the first declaration in current translation unit with the // usually be the first declaration in current translation unit with the
// exception of template specialization. For those we return the previous // exception of template specialization. For those we return the previous
// declaration instead of the first one, since it will be template decl itself // declaration instead of the first one, since it will be template decl itself
// rather then declaration of specialization. // rather then declaration of specialization.
const FunctionDecl *choseCanonical(const FunctionDecl *FD) { const FunctionDecl *choseCanonical(const FunctionDecl *FD) {
▲ Show 20 Lines • Show All 128 Lines • Show Last 20 Lines

clang-tools-extra/clangd/unittests/TweakTests.cpp

Show First 20 Lines • Show All 987 Lines • ▼ Show 20 Lines public:
void bar(); void bar();
}; };
template <typename T> T bar; template <typename T> T bar;
template <typename T> void aux() {} template <typename T> void aux() {}
} }
void foo() /*Comment -_-*/ { void foo() /*Comment -_-*/ {
using namespace a; using namespace a;
a::bar<a::Bar<int> >.bar(); a::bar<a::Bar<int>>.bar();
a::aux<a::Bar<int> >(); a::aux<a::Bar<int>>();
} }
)cpp"); )cpp");
} }
TEST(DefineInline, TransformMembers) { TEST(DefineInline, TransformMembers) {
llvm::StringLiteral ID = "DefineInline"; llvm::StringLiteral ID = "DefineInline";
▲ Show 20 Lines • Show All 56 Lines • ▼ Show 20 LinesTEST(DefineInline, TransformDependentTypes) {
using namespace a; using namespace a;
template <typename T> template <typename T>
void foo() /*Comment -_-*/ ; void foo() /*Comment -_-*/ ;
template <typename T> template <typename T>
void f^oo() { void f^oo() {
Bar<T> B; Bar<T> B;
// FIXME: This should be a::Bar<a::Bar<T> >
Bar<Bar<T>> q; Bar<Bar<T>> q;
} }
)cpp", )cpp",
R"cpp( R"cpp(
namespace a { namespace a {
template <typename T> class Bar {}; template <typename T> class Bar {};
} }
using namespace a; using namespace a;
template <typename T> template <typename T>
void foo() /*Comment -_-*/ { void foo() /*Comment -_-*/ {
a::Bar<T> B; a::Bar<T> B;
// FIXME: This should be a::Bar<a::Bar<T> > a::Bar<a::Bar<T>> q;
a::Bar<Bar<T> > q;
} }
)cpp"); )cpp");
} }
TEST(DefineInline, TransformFunctionTempls) { TEST(DefineInline, TransformFunctionTempls) {
llvm::StringLiteral ID = "DefineInline"; llvm::StringLiteral ID = "DefineInline";
▲ Show 20 Lines • Show All 120 Lines • ▼ Show 20 LinesTEST(DefineInline, TransformTypeLocs) {
} }
using namespace a; using namespace a;
using namespace b; using namespace b;
using namespace c; using namespace c;
void foo() /*Comment -_-*/ { void foo() /*Comment -_-*/ {
a::Bar<int> B; a::Bar<int> B;
a::b::Foo foo; a::b::Foo foo;
a::Bar<a::Bar<int> >::Baz<a::Bar<int> > q; a::Bar<a::Bar<int>>::Baz<a::Bar<int>> q;
} }
)cpp"); )cpp");
} }
TEST(DefineInline, TransformDeclRefs) { TEST(DefineInline, TransformDeclRefs) {
llvm::StringLiteral ID = "DefineInline"; llvm::StringLiteral ID = "DefineInline";
▲ Show 20 Lines • Show All 52 Lines • ▼ Show 20 LinesTEST(DefineInline, TransformDeclRefs) {
using namespace a; using namespace a;
using namespace b; using namespace b;
using namespace c; using namespace c;
void foo() /*Comment -_-*/ { void foo() /*Comment -_-*/ {
a::Bar<int> B; a::Bar<int> B;
B.foo(); B.foo();
a::bar(); a::bar();
a::Bar<a::Bar<int> >::bar(); a::Bar<a::Bar<int>>::bar();
a::Bar<int>::bar(); a::Bar<int>::bar();
B.x = a::Bar<int>::y; B.x = a::Bar<int>::y;
a::Bar<int>::y = 3; a::Bar<int>::y = 3;
a::bar(); a::bar();
a::b::c::test(); a::b::c::test();
} }
)cpp"); )cpp");
} }
} // namespace } // namespace
} // namespace clangd } // namespace clangd
} // namespace clang } // namespace clang