This is an archive of the discontinued LLVM Phabricator instance.

Differential D29460

[change-namespace] fix unscoped enum constant references.
ClosedPublic

Authored by ioeric on Feb 2 2017, 9:37 AM.

Details

Reviewers
bkramer
Commits
rG0325a77c5b59: [change-namespace] fix unscoped enum constant references.
rCTE293909: [change-namespace] fix unscoped enum constant references.
rL293909: [change-namespace] fix unscoped enum constant references.

Diff Detail

Event Timeline

ioeric created this revision.Feb 2 2017, 9:37 AM
Harbormaster completed remote builds in B3558: Diff 86835.Feb 2 2017, 9:37 AM
ioeric retitled this revision from [change-namespace] fi unscoped enum const^Ct references. to [change-namespace] fix unscoped enum constant references..Feb 2 2017, 9:42 AM
bkramer accepted this revision.Feb 2 2017, 9:50 AM

lg

This revision is now accepted and ready to land.Feb 2 2017, 9:50 AM
Closed by commit rL293909: [change-namespace] fix unscoped enum constant references. (authored by ioeric). · Explain WhyFeb 2 2017, 9:51 AM
This revision was automatically updated to reflect the committed changes.

Revision Contents

PathSize
change-namespace/
30 lines
unittests/
change-namespace/
201 lines

Diff 86835

change-namespace/ChangeNamespace.cpp

Show First 20 Lines • Show All 276 Lines • ▼ Show 20 Linesbool isDeclVisibleAtLocation(const SourceManager &SM, const Decl *D,
const DeclContext *DeclCtx, SourceLocation Loc) { const DeclContext *DeclCtx, SourceLocation Loc) {
SourceLocation DeclLoc = SM.getSpellingLoc(D->getLocation()); SourceLocation DeclLoc = SM.getSpellingLoc(D->getLocation());
Loc = SM.getSpellingLoc(Loc); Loc = SM.getSpellingLoc(Loc);
return SM.isBeforeInTranslationUnit(DeclLoc, Loc) && return SM.isBeforeInTranslationUnit(DeclLoc, Loc) &&
(SM.getFileID(DeclLoc) == SM.getFileID(Loc) && (SM.getFileID(DeclLoc) == SM.getFileID(Loc) &&
isNestedDeclContext(DeclCtx, D->getDeclContext())); isNestedDeclContext(DeclCtx, D->getDeclContext()));
} }
AST_MATCHER(EnumDecl, isScoped) {
return Node.isScoped();
}
} // anonymous namespace } // anonymous namespace
ChangeNamespaceTool::ChangeNamespaceTool( ChangeNamespaceTool::ChangeNamespaceTool(
llvm::StringRef OldNs, llvm::StringRef NewNs, llvm::StringRef FilePattern, llvm::StringRef OldNs, llvm::StringRef NewNs, llvm::StringRef FilePattern,
std::map<std::string, tooling::Replacements> *FileToReplacements, std::map<std::string, tooling::Replacements> *FileToReplacements,
llvm::StringRef FallbackStyle) llvm::StringRef FallbackStyle)
: FallbackStyle(FallbackStyle), FileToReplacements(*FileToReplacements), : FallbackStyle(FallbackStyle), FileToReplacements(*FileToReplacements),
OldNamespace(OldNs.ltrim(':')), NewNamespace(NewNs.ltrim(':')), OldNamespace(OldNs.ltrim(':')), NewNamespace(NewNs.ltrim(':')),
▲ Show 20 Lines • Show All 156 Lines • ▼ Show 20 Linesvoid ChangeNamespaceTool::registerMatchers(ast_matchers::MatchFinder *Finder) {
auto GlobalVarMatcher = varDecl( auto GlobalVarMatcher = varDecl(
hasGlobalStorage(), hasParent(namespaceDecl()), hasGlobalStorage(), hasParent(namespaceDecl()),
unless(anyOf(IsInMovedNs, hasAncestor(namespaceDecl(isAnonymous()))))); unless(anyOf(IsInMovedNs, hasAncestor(namespaceDecl(isAnonymous())))));
Finder->addMatcher(declRefExpr(IsInMovedNs, hasAncestor(decl().bind("dc")), Finder->addMatcher(declRefExpr(IsInMovedNs, hasAncestor(decl().bind("dc")),
to(GlobalVarMatcher.bind("var_decl"))) to(GlobalVarMatcher.bind("var_decl")))
.bind("var_ref"), .bind("var_ref"),
this); this);
// Handle unscoped enum constant.
auto UnscopedEnumMatcher = enumConstantDecl(hasParent(enumDecl(
hasParent(namespaceDecl()),
unless(anyOf(isScoped(), IsInMovedNs, hasAncestor(cxxRecordDecl()),
hasAncestor(namespaceDecl(isAnonymous())))))));
Finder->addMatcher(
declRefExpr(IsInMovedNs, hasAncestor(decl().bind("dc")),
to(UnscopedEnumMatcher.bind("enum_const_decl")))
.bind("enum_const_ref"),
this);
} }
void ChangeNamespaceTool::run( void ChangeNamespaceTool::run(
const ast_matchers::MatchFinder::MatchResult &Result) { const ast_matchers::MatchFinder::MatchResult &Result) {
if (const auto *Using = Result.Nodes.getNodeAs<UsingDecl>("using")) { if (const auto *Using = Result.Nodes.getNodeAs<UsingDecl>("using")) {
UsingDecls.insert(Using); UsingDecls.insert(Using);
} else if (const auto *UsingNamespace = } else if (const auto *UsingNamespace =
Result.Nodes.getNodeAs<UsingDirectiveDecl>( Result.Nodes.getNodeAs<UsingDirectiveDecl>(
▲ Show 20 Lines • Show All 48 Lines • ▼ Show 20 Lines if (const auto *Using = Result.Nodes.getNodeAs<UsingDecl>("using")) {
const auto *Var = Result.Nodes.getNodeAs<VarDecl>("var_decl"); const auto *Var = Result.Nodes.getNodeAs<VarDecl>("var_decl");
assert(Var); assert(Var);
if (Var->getCanonicalDecl()->isStaticDataMember()) if (Var->getCanonicalDecl()->isStaticDataMember())
return; return;
const auto *Context = Result.Nodes.getNodeAs<Decl>("dc"); const auto *Context = Result.Nodes.getNodeAs<Decl>("dc");
assert(Context && "Empty decl context."); assert(Context && "Empty decl context.");
fixDeclRefExpr(Result, Context->getDeclContext(), fixDeclRefExpr(Result, Context->getDeclContext(),
llvm::cast<NamedDecl>(Var), VarRef); llvm::cast<NamedDecl>(Var), VarRef);
} else if (const auto *EnumConstRef =
Result.Nodes.getNodeAs<DeclRefExpr>("enum_const_ref")) {
// Do not rename the reference if it is already scoped by the EnumDecl name.
if (EnumConstRef->hasQualifier() &&
EnumConstRef->getQualifier()->getAsType()->isEnumeralType())
return;
const auto *EnumConstDecl =
Result.Nodes.getNodeAs<EnumConstantDecl>("enum_const_decl");
assert(EnumConstDecl);
const auto *Context = Result.Nodes.getNodeAs<Decl>("dc");
assert(Context && "Empty decl context.");
// FIXME: this would qualify "ns::VALUE" as "ns::EnumValue::VALUE". Fix it
// if it turns out to be an issue.
fixDeclRefExpr(Result, Context->getDeclContext(),
llvm::cast<NamedDecl>(EnumConstDecl), EnumConstRef);
} else if (const auto *FuncRef = } else if (const auto *FuncRef =
Result.Nodes.getNodeAs<DeclRefExpr>("func_ref")) { Result.Nodes.getNodeAs<DeclRefExpr>("func_ref")) {
// If this reference has been processed as a function call, we do not // If this reference has been processed as a function call, we do not
// process it again. // process it again.
if (ProcessedFuncRefs.count(FuncRef)) if (ProcessedFuncRefs.count(FuncRef))
return; return;
ProcessedFuncRefs.insert(FuncRef); ProcessedFuncRefs.insert(FuncRef);
const auto *Func = Result.Nodes.getNodeAs<FunctionDecl>("func_decl"); const auto *Func = Result.Nodes.getNodeAs<FunctionDecl>("func_decl");
▲ Show 20 Lines • Show All 410 Lines • Show Last 20 Lines

unittests/change-namespace/ChangeNamespaceTests.cpp

Show First 20 Lines • Show All 1,768 Lines • ▼ Show 20 Lines std::string Expected = "class G {};\n"
" G g; Y y; A a; nc::C c;\n" " G g; Y y; A a; nc::C c;\n"
"};\n" "};\n"
"} // namespace\n" "} // namespace\n"
"} // namespace na\n" "} // namespace na\n"
"} // namespace ny\n"; "} // namespace ny\n";
EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code)); EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
} }
TEST_F(ChangeNamespaceTest, SimpleMoveEnum) {
std::string Code = "namespace na {\n"
"namespace nb {\n"
"enum class X { X1, X2 };\n"
"enum Y { Y1, Y2 };\n"
"} // namespace nb\n"
"} // namespace na\n";
std::string Expected = "\n\nnamespace x {\n"
"namespace y {\n"
"enum class X { X1, X2 };\n"
"enum Y { Y1, Y2 };\n"
"} // namespace y\n"
"} // namespace x\n";
EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
}
TEST_F(ChangeNamespaceTest, ReferencesToEnums) {
std::string Code = "enum Glob { G1, G2 };\n"
"namespace na {\n"
"enum class X { X1 };\n"
"enum Y { Y1, Y2 };\n"
"namespace nb {\n"
"void f() {\n"
" Glob g1 = Glob::G1;\n"
" Glob g2 = G2;\n"
" X x1 = X::X1;\n"
" Y y1 = Y::Y1;\n"
" Y y2 = Y2;\n"
"}\n"
"} // namespace nb\n"
"} // namespace na\n";
std::string Expected = "enum Glob { G1, G2 };\n"
"namespace na {\n"
"enum class X { X1 };\n"
"enum Y { Y1, Y2 };\n"
"\n"
"} // namespace na\n"
"namespace x {\n"
"namespace y {\n"
"void f() {\n"
" Glob g1 = Glob::G1;\n"
" Glob g2 = G2;\n"
" ::na::X x1 = ::na::X::X1;\n"
" ::na::Y y1 = ::na::Y::Y1;\n"
" ::na::Y y2 = ::na::Y::Y2;\n"
"}\n"
"} // namespace y\n"
"} // namespace x\n";
EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
}
TEST_F(ChangeNamespaceTest, NoRedundantEnumUpdate) {
std::string Code = "namespace ns {\n"
"enum class X { X1 };\n"
"enum Y { Y1, Y2 };\n"
"} // namespace ns\n"
"namespace na {\n"
"namespace nb {\n"
"void f() {\n"
" ns::X x1 = ns::X::X1;\n"
" ns::Y y1 = ns::Y::Y1;\n"
" ns::Y y2 = ns::Y2;\n"
"}\n"
"} // namespace nb\n"
"} // namespace na\n";
std::string Expected = "namespace ns {\n"
"enum class X { X1 };\n"
"enum Y { Y1, Y2 };\n"
"} // namespace ns\n"
"\n"
"namespace x {\n"
"namespace y {\n"
"void f() {\n"
" ns::X x1 = ns::X::X1;\n"
" ns::Y y1 = ns::Y::Y1;\n"
// FIXME: this is redundant
" ns::Y y2 = ::ns::Y::Y2;\n"
"}\n"
"} // namespace y\n"
"} // namespace x\n";
;
EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
}
TEST_F(ChangeNamespaceTest, EnumsAndUsingShadows) {
std::string Code = "namespace ns {\n"
"enum class X { X1 };\n"
"enum Y { Y1, Y2, Y3 };\n"
"} // namespace ns\n"
"using ns::X;\n"
"using ns::Y;\n"
"using ns::Y::Y2;\n"
"using ns::Y::Y3;\n"
"namespace na {\n"
"namespace nb {\n"
"void f() {\n"
" X x1 = X::X1;\n"
" Y y1 = Y::Y1;\n"
" Y y2 = Y2;\n"
" Y y3 = Y3;\n"
"}\n"
"} // namespace nb\n"
"} // namespace na\n";
std::string Expected = "namespace ns {\n"
"enum class X { X1 };\n"
"enum Y { Y1, Y2, Y3 };\n"
"} // namespace ns\n"
"using ns::X;\n"
"using ns::Y;\n"
"using ns::Y::Y2;\n"
"using ns::Y::Y3;\n"
"\n"
"namespace x {\n"
"namespace y {\n"
"void f() {\n"
" X x1 = X::X1;\n"
" Y y1 = Y::Y1;\n"
" Y y2 = Y2;\n"
" Y y3 = Y3;\n"
"}\n"
"} // namespace y\n"
"} // namespace x\n";
EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
}
TEST_F(ChangeNamespaceTest, EnumsAndAliases) {
std::string Code = "namespace ns {\n"
"enum class X { X1 };\n"
"enum Y { Y1, Y2, Y3 };\n"
"} // namespace ns\n"
"typedef ns::X TX;\n"
"typedef ns::Y TY;\n"
"using UX = ns::X;\n"
"using UY = ns::Y;\n"
"namespace na {\n"
"namespace nb {\n"
"void f() {\n"
" ns::X x1 = ns::X::X1;\n"
" TX tx1 = TX::X1;\n"
" UX ux1 = UX::X1;\n"
" ns::Y y1 = ns::Y::Y1;\n"
" TY ty1 = TY::Y1;\n"
" UY uy1 = UY::Y1;\n"
"}\n"
"} // namespace nb\n"
"} // namespace na\n";
std::string Expected = "namespace ns {\n"
"enum class X { X1 };\n"
"enum Y { Y1, Y2, Y3 };\n"
"} // namespace ns\n"
"typedef ns::X TX;\n"
"typedef ns::Y TY;\n"
"using UX = ns::X;\n"
"using UY = ns::Y;\n"
"\n"
"namespace x {\n"
"namespace y {\n"
"void f() {\n"
" ns::X x1 = ns::X::X1;\n"
" TX tx1 = TX::X1;\n"
" UX ux1 = UX::X1;\n"
" ns::Y y1 = ns::Y::Y1;\n"
" TY ty1 = TY::Y1;\n"
" UY uy1 = UY::Y1;\n"
"}\n"
"} // namespace y\n"
"} // namespace x\n";
EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
}
TEST_F(ChangeNamespaceTest, EnumInClass) {
std::string Code = "namespace na {\n"
"struct X { enum E { E1 }; };\n"
"namespace nb {\n"
"void f() {\n"
" X::E e = X::E1;\n"
" X::E ee = X::E::E1;\n"
"}\n"
"} // namespace nb\n"
"} // namespace na\n";
std::string Expected = "namespace na {\n"
"struct X { enum E { E1 }; };\n"
"\n"
"} // namespace na\n"
"namespace x {\n"
"namespace y {\n"
"void f() {\n"
" ::na::X::E e = ::na::X::E1;\n"
" ::na::X::E ee = ::na::X::E::E1;\n"
"}\n"
"} // namespace y\n"
"} // namespace x\n";
EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
}
} // anonymous namespace } // anonymous namespace
} // namespace change_namespace } // namespace change_namespace
} // namespace clang } // namespace clang