tools/clang/rewrite_to_chrome_style/RewriteToChromeStyle.cpp - Issue 1806903003: Don't rename references to functions that originate from template args.

Unified Diff: tools/clang/rewrite_to_chrome_style/RewriteToChromeStyle.cpp

Issue 1806903003: Don't rename references to functions that originate from template args. (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master

Patch Set: . Created 4 years, 9 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View side-by-side diff with in-line comments

Download patch

Index: tools/clang/rewrite_to_chrome_style/RewriteToChromeStyle.cpp

diff --git a/tools/clang/rewrite_to_chrome_style/RewriteToChromeStyle.cpp b/tools/clang/rewrite_to_chrome_style/RewriteToChromeStyle.cpp

index 1e22e9c0ce33cd15cb3b26fe6711bae7d2b115ab..a78935047cbd6ea44b2c60d3c87775f340f1b34a 100644

--- a/tools/clang/rewrite_to_chrome_style/RewriteToChromeStyle.cpp

+++ b/tools/clang/rewrite_to_chrome_style/RewriteToChromeStyle.cpp

@@ -48,18 +48,6 @@ using llvm::StringRef;

namespace {

-// Hack: prevent the custom isDefaulted() from conflicting with the one defined

-// in newer revisions of Clang.

-namespace internal_hack {

-// This is available in newer clang revisions... but alas, Chrome has not rolled

-// that far yet.

-AST_MATCHER(clang::FunctionDecl, isDefaulted) {

dcheng 2016/03/17 04:03:39 No longer needed, yay!

- return Node.isDefaulted();

-} // namespace internal_hack

const char kBlinkFieldPrefix[] = "m_";

const char kBlinkStaticMemberPrefix[] = "s_";

const char kGeneratedFileRegex[] = "^gen/|/gen/";

@@ -203,7 +191,6 @@ std::string CamelCaseToUnderscoreCase(StringRef input) {

std::string output;

bool needs_underscore = false;

bool was_lowercase = false;

- bool was_number = false;

dcheng 2016/03/17 04:03:39 These were giving me warnings.

bool was_uppercase = false;

bool first_char = true;

// Iterate in reverse to minimize the amount of backtracking.

@@ -211,7 +198,6 @@ std::string CamelCaseToUnderscoreCase(StringRef input) {

--i) {

char c = *i;

bool is_lowercase = clang::isLowercase(c);

- bool is_number = clang::isDigit(c);

bool is_uppercase = clang::isUppercase(c);

c = clang::toLowercase(c);

// Transitioning from upper to lower case requires an underscore. This is

@@ -230,7 +216,6 @@ std::string CamelCaseToUnderscoreCase(StringRef input) {

if (!first_char && was_lowercase && is_uppercase)

needs_underscore = true;

was_lowercase = is_lowercase;

- was_number = is_number;

was_uppercase = is_uppercase;

first_char = false;

}

@@ -400,78 +385,75 @@ bool GetNameForDecl(const clang::FunctionTemplateDecl& decl,

return GetNameForDecl(*templated_function, context, name);

}

-bool GetNameForDecl(const clang::UsingDecl& decl,

+bool GetNameForDecl(const clang::NamedDecl& decl,

const clang::ASTContext& context,

std::string& name) {

- assert(decl.shadow_size() > 0);

dcheng 2016/03/17 04:03:39 I did some refactoring in this area when trying to

- // If a using declaration's targeted declaration is a set of overloaded

- // functions, it can introduce multiple shadowed declarations. Just using the

- // first one is OK, since overloaded functions have the same name, by

- // definition.

- clang::NamedDecl* shadowed_name = decl.shadow_begin()->getTargetDecl();

// Note: CXXMethodDecl must be checked before FunctionDecl, because

// CXXMethodDecl is derived from FunctionDecl.

- if (auto* method = clang::dyn_cast<clang::CXXMethodDecl>(shadowed_name))

+ if (auto* method = clang::dyn_cast<clang::CXXMethodDecl>(&decl))

return GetNameForDecl(*method, context, name);

- if (auto* function = clang::dyn_cast<clang::FunctionDecl>(shadowed_name))

+ if (auto* function = clang::dyn_cast<clang::FunctionDecl>(&decl))

return GetNameForDecl(*function, context, name);

- if (auto* var = clang::dyn_cast<clang::VarDecl>(shadowed_name))

+ if (auto* var = clang::dyn_cast<clang::VarDecl>(&decl))

return GetNameForDecl(*var, context, name);

- if (auto* field = clang::dyn_cast<clang::FieldDecl>(shadowed_name))

+ if (auto* field = clang::dyn_cast<clang::FieldDecl>(&decl))

return GetNameForDecl(*field, context, name);

if (auto* function_template =

- clang::dyn_cast<clang::FunctionTemplateDecl>(shadowed_name))

+ clang::dyn_cast<clang::FunctionTemplateDecl>(&decl))

return GetNameForDecl(*function_template, context, name);

- if (auto* enumc = clang::dyn_cast<clang::EnumConstantDecl>(shadowed_name))

+ if (auto* enumc = clang::dyn_cast<clang::EnumConstantDecl>(&decl))

return GetNameForDecl(*enumc, context, name);

return false;

}

+bool GetNameForDecl(const clang::UsingDecl& decl,

+ const clang::ASTContext& context,

+ std::string& name) {

+ assert(decl.shadow_size() > 0);

+ // If a using declaration's targeted declaration is a set of overloaded

+ // functions, it can introduce multiple shadowed declarations. Just using the

+ // first one is OK, since overloaded functions have the same name, by

+ // definition.

+ return GetNameForDecl(*decl.shadow_begin()->getTargetDecl(), context, name);

template <typename Type>

struct TargetNodeTraits;

template <>

struct TargetNodeTraits<clang::NamedDecl> {

- static const char kName[];

static clang::SourceLocation GetLoc(const clang::NamedDecl& decl) {

return decl.getLocation();

}

- static const char* GetType() { return "NamedDecl"; }

+ static const char* GetName() { return "decl"; }

};

-const char TargetNodeTraits<clang::NamedDecl>::kName[] = "decl";

dcheng 2016/03/17 04:03:39 Ditto: these were incidental cleanups when I was t

template <>

struct TargetNodeTraits<clang::MemberExpr> {

- static const char kName[];

static clang::SourceLocation GetLoc(const clang::MemberExpr& expr) {

return expr.getMemberLoc();

}

- static const char* GetType() { return "MemberExpr"; }

+ static const char* GetName() { return "expr"; }

};

-const char TargetNodeTraits<clang::MemberExpr>::kName[] = "expr";

template <>

struct TargetNodeTraits<clang::DeclRefExpr> {

- static const char kName[];

static clang::SourceLocation GetLoc(const clang::DeclRefExpr& expr) {

return expr.getLocation();

}

- static const char* GetType() { return "DeclRefExpr"; }

+ static const char* GetName() { return "expr"; }

};

-const char TargetNodeTraits<clang::DeclRefExpr>::kName[] = "expr";

template <>

struct TargetNodeTraits<clang::CXXCtorInitializer> {

- static const char kName[];

static clang::SourceLocation GetLoc(const clang::CXXCtorInitializer& init) {

assert(init.isWritten());

return init.getSourceLocation();

}

- static const char* GetType() { return "CXXCtorInitializer"; }

+ static const char* GetName() { return "initializer"; }

};

-const char TargetNodeTraits<clang::CXXCtorInitializer>::kName[] = "initializer";

template <typename DeclNode, typename TargetNode>

class RewriterBase : public MatchFinder::MatchCallback {

@@ -506,7 +488,7 @@ class RewriterBase : public MatchFinder::MatchCallback {

return;

clang::SourceLocation loc = TargetNodeTraits<TargetNode>::GetLoc(

*result.Nodes.getNodeAs<TargetNode>(

- TargetNodeTraits<TargetNode>::kName));

+ TargetNodeTraits<TargetNode>::GetName()));

clang::CharSourceRange range = clang::CharSourceRange::getTokenRange(loc);

replacements_->emplace(*result.SourceManager, range, new_name);

replacement_names_.emplace(old_name.str(), std::move(new_name));

@@ -608,7 +590,7 @@ int main(int argc, const char* argv[]) {

// compiler, such as a synthesized copy constructor.

// This skips explicitly defaulted functions as well, but that's OK:

// there's nothing interesting to rewrite in those either.

- unless(hasAncestor(functionDecl(internal_hack::isDefaulted())))));

+ unless(hasAncestor(functionDecl(isDefaulted())))));

auto decl_ref_matcher = id("expr", declRefExpr(to(var_decl_matcher)));

auto enum_member_ref_matcher =

id("expr", declRefExpr(to(enum_member_decl_matcher)));

@@ -660,8 +642,10 @@ int main(int argc, const char* argv[]) {

// f();

// void (*p)() = &f;

// matches |f()| and |&f|.

- auto function_ref_matcher =

- id("expr", declRefExpr(to(function_decl_matcher)));

+ auto function_ref_matcher = id(

+ "expr", declRefExpr(to(function_decl_matcher),

+ // Ignore template substitutions

+ unless(hasAncestor(substNonTypeTemplateParmExpr()))));

FunctionRefRewriter function_ref_rewriter(&replacements);

match_finder.addMatcher(function_ref_matcher, &function_ref_rewriter);

@@ -685,7 +669,8 @@ int main(int argc, const char* argv[]) {

// Overloaded operators have special names and should never be

// renamed.

isOverloadedOperator(),

- // Similarly, constructors, destructors, and conversion functions

+ // Similarly, constructors, destructors, and conversion

+ // functions

// should not be considered for renaming.

cxxConstructorDecl(), cxxDestructorDecl(), cxxConversionDecl())),

// Check this last after excluding things, to avoid

@@ -701,7 +686,10 @@ int main(int argc, const char* argv[]) {

// s.g();

// void (S::*p)() = &S::g;

// matches |&S::g| but not |s.g()|.

- auto method_ref_matcher = id("expr", declRefExpr(to(method_decl_matcher)));

+ auto method_ref_matcher = id(

+ "expr", declRefExpr(to(method_decl_matcher),

+ // Ignore template substitutions.

+ unless(hasAncestor(substNonTypeTemplateParmExpr()))));

MethodRefRewriter method_ref_rewriter(&replacements);

match_finder.addMatcher(method_ref_matcher, &method_ref_rewriter);

« no previous file with comments | « no previous file | tools/clang/rewrite_to_chrome_style/tests/template-expected.cc » ('j') | no next file with comments »