nils.hoelscher
/
llvm-for-llvmta
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
llvm-for-llvmta/tools/clang/unittests/Rename/RenameFunctionTest.cpp

574 lines
14 KiB
C++
Raw Permalink Blame History

//===-- RenameFunctionTest.cpp - unit tests for renaming functions --------===//
//
// 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
//
//===----------------------------------------------------------------------===//
#include "ClangRenameTest.h"
namespace clang {
namespace clang_rename {
namespace test {
namespace {
class RenameFunctionTest : public ClangRenameTest {
public:
RenameFunctionTest() {
AppendToHeader(R"(
struct A {
static bool Foo();
static bool Spam();
};
struct B {
static void Same();
static bool Foo();
static int Eric(int x);
};
void Same(int x);
int Eric(int x);
namespace base {
void Same();
void ToNanoSeconds();
void ToInt64NanoSeconds();
})");
}
};
TEST_F(RenameFunctionTest, RefactorsAFoo) {
std::string Before = R"(
void f() {
A::Foo();
::A::Foo();
})";
std::string Expected = R"(
void f() {
A::Bar();
::A::Bar();
})";
std::string After = runClangRenameOnCode(Before, "A::Foo", "A::Bar");
CompareSnippets(Expected, After);
}
TEST_F(RenameFunctionTest, RefactorsNonCallingAFoo) {
std::string Before = R"(
bool g(bool (*func)()) {
return func();
}
void f() {
auto *ref1 = A::Foo;
auto *ref2 = ::A::Foo;
g(A::Foo);
})";
std::string Expected = R"(
bool g(bool (*func)()) {
return func();
}
void f() {
auto *ref1 = A::Bar;
auto *ref2 = ::A::Bar;
g(A::Bar);
})";
std::string After = runClangRenameOnCode(Before, "A::Foo", "A::Bar");
CompareSnippets(Expected, After);
}
TEST_F(RenameFunctionTest, RefactorsEric) {
std::string Before = R"(
void f() {
if (Eric(3)==4) ::Eric(2);
})";
std::string Expected = R"(
void f() {
if (Larry(3)==4) ::Larry(2);
})";
std::string After = runClangRenameOnCode(Before, "Eric", "Larry");
CompareSnippets(Expected, After);
}
TEST_F(RenameFunctionTest, RefactorsNonCallingEric) {
std::string Before = R"(
int g(int (*func)(int)) {
return func(1);
}
void f() {
auto *ref = ::Eric;
g(Eric);
})";
std::string Expected = R"(
int g(int (*func)(int)) {
return func(1);
}
void f() {
auto *ref = ::Larry;
g(Larry);
})";
std::string After = runClangRenameOnCode(Before, "Eric", "Larry");
CompareSnippets(Expected, After);
}
TEST_F(RenameFunctionTest, DoesNotRefactorBFoo) {
std::string Before = R"(
void f() {
B::Foo();
})";
std::string After = runClangRenameOnCode(Before, "A::Foo", "A::Bar");
CompareSnippets(Before, After);
}
TEST_F(RenameFunctionTest, DoesNotRefactorBEric) {
std::string Before = R"(
void f() {
B::Eric(2);
})";
std::string After = runClangRenameOnCode(Before, "Eric", "Larry");
CompareSnippets(Before, After);
}
TEST_F(RenameFunctionTest, DoesNotRefactorCEric) {
std::string Before = R"(
namespace C { int Eric(int x); }
void f() {
if (C::Eric(3)==4) ::C::Eric(2);
})";
std::string Expected = R"(
namespace C { int Eric(int x); }
void f() {
if (C::Eric(3)==4) ::C::Eric(2);
})";
std::string After = runClangRenameOnCode(Before, "Eric", "Larry");
CompareSnippets(Expected, After);
}
TEST_F(RenameFunctionTest, DoesNotRefactorEricInNamespaceC) {
std::string Before = R"(
namespace C {
int Eric(int x);
void f() {
if (Eric(3)==4) Eric(2);
}
} // namespace C)";
std::string After = runClangRenameOnCode(Before, "Eric", "Larry");
CompareSnippets(Before, After);
}
TEST_F(RenameFunctionTest, NamespaceQualified) {
std::string Before = R"(
void f() {
base::ToNanoSeconds();
::base::ToNanoSeconds();
}
void g() {
using base::ToNanoSeconds;
base::ToNanoSeconds();
::base::ToNanoSeconds();
ToNanoSeconds();
}
namespace foo {
namespace base {
void ToNanoSeconds();
void f() {
base::ToNanoSeconds();
}
}
void f() {
::base::ToNanoSeconds();
}
})";
std::string Expected = R"(
void f() {
base::ToInt64NanoSeconds();
::base::ToInt64NanoSeconds();
}
void g() {
using base::ToInt64NanoSeconds;
base::ToInt64NanoSeconds();
::base::ToInt64NanoSeconds();
base::ToInt64NanoSeconds();
}
namespace foo {
namespace base {
void ToNanoSeconds();
void f() {
base::ToNanoSeconds();
}
}
void f() {
::base::ToInt64NanoSeconds();
}
})";
std::string After = runClangRenameOnCode(Before, "base::ToNanoSeconds",
"base::ToInt64NanoSeconds");
CompareSnippets(Expected, After);
}
TEST_F(RenameFunctionTest, RenameFunctionDecls) {
std::string Before = R"(
namespace na {
void X();
void X() {}
})";
std::string Expected = R"(
namespace na {
void Y();
void Y() {}
})";
std::string After = runClangRenameOnCode(Before, "na::X", "na::Y");
CompareSnippets(Expected, After);
}
TEST_F(RenameFunctionTest, RenameTemplateFunctions) {
std::string Before = R"(
namespace na {
template<typename T> T X();
}
namespace na { void f() { X<int>(); } }
namespace nb { void g() { na::X <int>(); } }
)";
std::string Expected = R"(
namespace na {
template<typename T> T Y();
}
namespace na { void f() { nb::Y<int>(); } }
namespace nb { void g() { Y<int>(); } }
)";
std::string After = runClangRenameOnCode(Before, "na::X", "nb::Y");
CompareSnippets(Expected, After);
}
TEST_F(RenameFunctionTest, RenameOutOfLineFunctionDecls) {
std::string Before = R"(
namespace na {
void X();
}
void na::X() {}
)";
std::string Expected = R"(
namespace na {
void Y();
}
void na::Y() {}
)";
std::string After = runClangRenameOnCode(Before, "na::X", "na::Y");
CompareSnippets(Expected, After);
}
TEST_F(RenameFunctionTest, NewNamespaceWithoutLeadingDotDot) {
std::string Before = R"(
namespace old_ns {
void X();
void X() {}
}
// Assume that the reference is in another file.
void f() { old_ns::X(); }
namespace old_ns { void g() { X(); } }
namespace new_ns { void h() { ::old_ns::X(); } }
)";
std::string Expected = R"(
namespace old_ns {
void Y();
void Y() {}
}
// Assume that the reference is in another file.
void f() { new_ns::Y(); }
namespace old_ns { void g() { new_ns::Y(); } }
namespace new_ns { void h() { Y(); } }
)";
std::string After = runClangRenameOnCode(Before, "::old_ns::X", "new_ns::Y");
CompareSnippets(Expected, After);
}
TEST_F(RenameFunctionTest, NewNamespaceWithLeadingDotDot) {
std::string Before = R"(
namespace old_ns {
void X();
void X() {}
}
// Assume that the reference is in another file.
void f() { old_ns::X(); }
namespace old_ns { void g() { X(); } }
namespace new_ns { void h() { ::old_ns::X(); } }
)";
std::string Expected = R"(
namespace old_ns {
void Y();
void Y() {}
}
// Assume that the reference is in another file.
void f() { ::new_ns::Y(); }
namespace old_ns { void g() { ::new_ns::Y(); } }
namespace new_ns { void h() { Y(); } }
)";
std::string After =
runClangRenameOnCode(Before, "::old_ns::X", "::new_ns::Y");
CompareSnippets(Expected, After);
}
TEST_F(RenameFunctionTest, DontRenameSymbolsDefinedInAnonymousNamespace) {
std::string Before = R"(
namespace old_ns {
class X {};
namespace {
void X();
void X() {}
void f() { X(); }
}
}
)";
std::string Expected = R"(
namespace old_ns {
class Y {};
namespace {
void X();
void X() {}
void f() { X(); }
}
}
)";
std::string After =
runClangRenameOnCode(Before, "::old_ns::X", "::old_ns::Y");
CompareSnippets(Expected, After);
}
TEST_F(RenameFunctionTest, NewNestedNamespace) {
std::string Before = R"(
namespace old_ns {
void X();
void X() {}
}
// Assume that the reference is in another file.
namespace old_ns {
void f() { X(); }
}
)";
std::string Expected = R"(
namespace old_ns {
void X();
void X() {}
}
// Assume that the reference is in another file.
namespace old_ns {
void f() { older_ns::X(); }
}
)";
std::string After =
runClangRenameOnCode(Before, "::old_ns::X", "::old_ns::older_ns::X");
CompareSnippets(Expected, After);
}
TEST_F(RenameFunctionTest, MoveFromGlobalToNamespaceWithoutLeadingDotDot) {
std::string Before = R"(
void X();
void X() {}
// Assume that the reference is in another file.
namespace some_ns {
void f() { X(); }
}
)";
std::string Expected = R"(
void X();
void X() {}
// Assume that the reference is in another file.
namespace some_ns {
void f() { ns::X(); }
}
)";
std::string After =
runClangRenameOnCode(Before, "::X", "ns::X");
CompareSnippets(Expected, After);
}
TEST_F(RenameFunctionTest, MoveFromGlobalToNamespaceWithLeadingDotDot) {
std::string Before = R"(
void Y() {}
// Assume that the reference is in another file.
namespace some_ns {
void f() { Y(); }
}
)";
std::string Expected = R"(
void Y() {}
// Assume that the reference is in another file.
namespace some_ns {
void f() { ::ns::Y(); }
}
)";
std::string After =
runClangRenameOnCode(Before, "::Y", "::ns::Y");
CompareSnippets(Expected, After);
}
// FIXME: the rename of overloaded operator is not fully supported yet.
TEST_F(RenameFunctionTest, DISABLED_DoNotRenameOverloadedOperatorCalls) {
std::string Before = R"(
namespace old_ns {
class T { public: int x; };
bool operator==(const T& lhs, const T& rhs) {
return lhs.x == rhs.x;
}
} // namespace old_ns
// Assume that the reference is in another file.
bool f() {
auto eq = old_ns::operator==;
old_ns::T t1, t2;
old_ns::operator==(t1, t2);
return t1 == t2;
}
)";
std::string Expected = R"(
namespace old_ns {
class T { public: int x; };
bool operator==(const T& lhs, const T& rhs) {
return lhs.x == rhs.x;
}
} // namespace old_ns
// Assume that the reference is in another file.
bool f() {
auto eq = new_ns::operator==;
old_ns::T t1, t2;
new_ns::operator==(t1, t2);
return t1 == t2;
}
)";
std::string After =
runClangRenameOnCode(Before, "old_ns::operator==", "new_ns::operator==");
CompareSnippets(Expected, After);
}
TEST_F(RenameFunctionTest, FunctionRefAsTemplate) {
std::string Before = R"(
void X();
// Assume that the reference is in another file.
namespace some_ns {
template <void (*Func)(void)>
class TIterator {};
template <void (*Func)(void)>
class T {
public:
typedef TIterator<Func> IterType;
using TI = TIterator<Func>;
void g() {
Func();
auto func = Func;
TIterator<Func> iter;
}
};
void f() { T<X> tx; tx.g(); }
} // namespace some_ns
)";
std::string Expected = R"(
void X();
// Assume that the reference is in another file.
namespace some_ns {
template <void (*Func)(void)>
class TIterator {};
template <void (*Func)(void)>
class T {
public:
typedef TIterator<Func> IterType;
using TI = TIterator<Func>;
void g() {
Func();
auto func = Func;
TIterator<Func> iter;
}
};
void f() { T<ns::X> tx; tx.g(); }
} // namespace some_ns
)";
std::string After = runClangRenameOnCode(Before, "::X", "ns::X");
CompareSnippets(Expected, After);
}
TEST_F(RenameFunctionTest, RenameFunctionInUsingDecl) {
std::string Before = R"(
using base::ToNanoSeconds;
namespace old_ns {
using base::ToNanoSeconds;
void f() {
using base::ToNanoSeconds;
}
}
)";
std::string Expected = R"(
using base::ToInt64NanoSeconds;
namespace old_ns {
using base::ToInt64NanoSeconds;
void f() {
using base::ToInt64NanoSeconds;
}
}
)";
std::string After = runClangRenameOnCode(Before, "base::ToNanoSeconds",
"base::ToInt64NanoSeconds");
CompareSnippets(Expected, After);
}
// FIXME: Fix the complex the case where the symbol being renamed is located in
// `std::function<decltype<renamed_symbol>>`.
TEST_F(ClangRenameTest, DISABLED_ReferencesInLambdaFunctionParameters) {
std::string Before = R"(
template <class T>
class function;
template <class R, class... ArgTypes>
class function<R(ArgTypes...)> {
public:
template <typename Functor>
function(Functor f) {}
function() {}
R operator()(ArgTypes...) const {}
};
namespace ns {
void Old() {}
void f() {
function<decltype(Old)> func;
}
} // namespace ns)";
std::string Expected = R"(
template <class T>
class function;
template <class R, class... ArgTypes>
class function<R(ArgTypes...)> {
public:
template <typename Functor>
function(Functor f) {}
function() {}
R operator()(ArgTypes...) const {}
};
namespace ns {
void New() {}
void f() {
function<decltype(::new_ns::New)> func;
}
} // namespace ns)";
std::string After = runClangRenameOnCode(Before, "ns::Old", "::new_ns::New");
CompareSnippets(Expected, After);
}
} // anonymous namespace
} // namespace test
} // namespace clang_rename
} // namesdpace clang
Reference in New Issue View Git Blame Copy Permalink