Renaming blink method names inside gmock's EXPECT_CALL macro invocation.

tools/clang/rewrite_to_chrome_style/RewriteToChromeStyle.cpp

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 //
 // Changes Blink-style names to Chrome-style names. Currently transforms:
 //   fields:
 //     int m_operationCount => int operation_count_
 //   variables (including parameters):
 //     int mySuperVariable => int my_super_variable
 //   constants:
 //     const int maxThings => const int kMaxThings
 //   free functions and methods:
 //     void doThisThenThat() => void DoThisAndThat()
 
 #include <assert.h>
 #include <algorithm>
 #include <memory>
 #include <set>
 #include <string>
 
 #include "clang/AST/ASTContext.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "clang/ASTMatchers/ASTMatchers.h"
 #include "clang/ASTMatchers/ASTMatchersMacros.h"
 #include "clang/Basic/CharInfo.h"
 #include "clang/Basic/SourceManager.h"
+#include "clang/Frontend/CompilerInstance.h"
 #include "clang/Frontend/FrontendActions.h"
+#include "clang/Lex/MacroArgs.h"
 #include "clang/Lex/Lexer.h"
+#include "clang/Lex/PPCallbacks.h"
+#include "clang/Lex/Preprocessor.h"
 #include "clang/Tooling/CommonOptionsParser.h"
 #include "clang/Tooling/Refactoring.h"
 #include "clang/Tooling/Tooling.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/TargetSelect.h"
 
 #include "EditTracker.h"
 
 using namespace clang::ast_matchers;
 using clang::tooling::CommonOptionsParser;
 using clang::tooling::Replacement;
 using llvm::StringRef;
 
 namespace {
 
 const char kBlinkFieldPrefix[] = "m_";
 const char kBlinkStaticMemberPrefix[] = "s_";
 const char kGeneratedFileRegex[] = "^gen/|/gen/";
+const char kGMockMethodNamePrefix[] = "gmock_";
 
 template <typename MatcherType, typename NodeType>
 bool IsMatching(const MatcherType& matcher,
                 const NodeType& node,
                 clang::ASTContext& context) {
   return !match(matcher, node, context).empty();
 }
 
 const clang::ast_matchers::internal::
     VariadicDynCastAllOfMatcher<clang::Expr, clang::UnresolvedMemberExpr>
@@ skipping 15 matching lines @@
   return Node.isInstance();
 }
 
 AST_MATCHER_P(clang::FunctionTemplateDecl,
               templatedDecl,
               clang::ast_matchers::internal::Matcher<clang::FunctionDecl>,
               InnerMatcher) {
   return InnerMatcher.matches(*Node.getTemplatedDecl(), Finder, Builder);
 }
 
+// Matches a CXXMethodDecl of a method declared via MOCK_METHODx macro if such
+// method mocks a method matched by the InnerMatcher.  For example if "foo"
+// matcher matches "interfaceMethod", then mocksMethod(foo()) will match
+// "gmock_interfaceMethod" declared by MOCK_METHOD_x(interfaceMethod).
+AST_MATCHER_P(clang::CXXMethodDecl,
+              mocksMethod,
+              clang::ast_matchers::internal::Matcher<clang::CXXMethodDecl>,
+              InnerMatcher) {
+  if (!Node.getDeclName().isIdentifier())
+    return false;
+
+  llvm::StringRef method_name = Node.getName();
+  if (!method_name.startswith(kGMockMethodNamePrefix))
+    return false;
+
+  llvm::StringRef mocked_method_name =
+      method_name.substr(strlen(kGMockMethodNamePrefix));
+  for (const auto& potentially_mocked_method : Node.getParent()->methods()) {
+    if (!potentially_mocked_method->isVirtual())
+      continue;
+
+    clang::DeclarationName decl_name = potentially_mocked_method->getDeclName();
+    if (!decl_name.isIdentifier() ||
+        potentially_mocked_method->getName() != mocked_method_name)
+      continue;
+    if (potentially_mocked_method->getNumParams() != Node.getNumParams())

[dcheng, 2017/01/09 19:27:47]

It's too bad it's not easy to do something like use the list of overrides here
=)

[Łukasz Anforowicz, 2017/01/09 20:11:27]

Acknowledged.

+      continue;
+
+    if (InnerMatcher.matches(*potentially_mocked_method, Finder, Builder))
+      return true;
+  }
+
+  return false;
+}
+
 // If |InnerMatcher| matches |top|, then the returned matcher will match:
 // - |top::function|
 // - |top::Class::method|
 // - |top::internal::Class::method|
 AST_MATCHER_P(
     clang::NestedNameSpecifier,
     hasTopLevelPrefix,
     clang::ast_matchers::internal::Matcher<clang::NestedNameSpecifier>,
     InnerMatcher) {
   const clang::NestedNameSpecifier* NodeToMatch = &Node;
@@ skipping 694 matching lines @@
     StringRef actual_old_text = clang::Lexer::getSourceText(
         range, source_manager, context.getLangOpts());
     if (actual_old_text != expected_old_text)
       return false;
 
     if (replacement)
       *replacement = Replacement(source_manager, range, new_text);
     return true;
   }
 
+  virtual clang::SourceLocation GetTargetLoc(
+      const MatchFinder::MatchResult& result) {
+    return TargetNodeTraits<TargetNode>::GetLoc(GetTargetNode(result));
+  }
+
   void AddReplacement(const MatchFinder::MatchResult& result,
                       llvm::StringRef old_name,
                       std::string new_name) {
     if (old_name == new_name)
       return;
 
-    clang::SourceLocation loc =
-        TargetNodeTraits<TargetNode>::GetLoc(GetTargetNode(result));
+    clang::SourceLocation loc = GetTargetLoc(result);
+    if (loc.isInvalid())
+      return;
 
     Replacement replacement;
     if (!GenerateReplacement(result, loc, old_name, new_name, &replacement))
       return;
 
     replacements_->insert(std::move(replacement));
     edit_tracker_.Add(*result.SourceManager, loc, old_name, new_name);
   }
 
   const EditTracker& edit_tracker() const { return edit_tracker_; }
@@ skipping 62 matching lines @@
 using EnumConstantDeclRefRewriter =
     DeclRewriterBase<clang::EnumConstantDecl, clang::DeclRefExpr>;
 
 using UnresolvedLookupRewriter =
     DeclRewriterBase<clang::NamedDecl, clang::UnresolvedLookupExpr>;
 using UnresolvedMemberRewriter =
     DeclRewriterBase<clang::NamedDecl, clang::UnresolvedMemberExpr>;
 
 using UsingDeclRewriter = DeclRewriterBase<clang::UsingDecl, clang::NamedDecl>;
 
+class GMockMemberRewriter
+    : public DeclRewriterBase<clang::CXXMethodDecl, clang::MemberExpr> {
+ public:
+  using Base = DeclRewriterBase<clang::CXXMethodDecl, clang::MemberExpr>;
+
+  explicit GMockMemberRewriter(std::set<Replacement>* replacements)
+      : Base(replacements) {}
+
+  std::unique_ptr<clang::PPCallbacks> CreatePreprocessorCallbacks() {
+    return llvm::make_unique<GMockMemberRewriter::PPCallbacks>(this);
+  }
+
+  clang::SourceLocation GetTargetLoc(
+      const MatchFinder::MatchResult& result) override {
+    // Find location of the gmock_##MockedMethod identifier.
+    clang::SourceLocation target_loc = Base::GetTargetLoc(result);
+
+    // Find location of EXPECT_CALL macro invocation.
+    clang::SourceLocation macro_call_loc =
+        result.SourceManager->getExpansionLoc(target_loc);
+
+    // Map |macro_call_loc| to argument location (location of the method name
+    // that needs renaming).
+    auto it = expect_call_to_2nd_arg.find(macro_call_loc);
+    if (it == expect_call_to_2nd_arg.end())
+      return clang::SourceLocation();
+    return it->second;
+  }
+
+ private:
+  std::map<clang::SourceLocation, clang::SourceLocation> expect_call_to_2nd_arg;
+
+  // Called from PPCallbacks with the locations of EXPECT_CALL macro invocation:
+  // Example:
+  //   EXPECT_CALL(my_mock, myMethod(123, 456));
+  //   ^- expansion_loc     ^- actual_arg_loc
+  void RecordExpectCallMacroInvocation(clang::SourceLocation expansion_loc,
+                                       clang::SourceLocation second_arg_loc) {
+    expect_call_to_2nd_arg[expansion_loc] = second_arg_loc;
+  }
+
+  class PPCallbacks : public clang::PPCallbacks {
+   public:
+    PPCallbacks(GMockMemberRewriter* rewriter) : rewriter_(rewriter) {}

[dcheng, 2017/01/09 19:27:47]

Nit: explicit

[Łukasz Anforowicz, 2017/01/09 20:11:27]

Ooops.  Done.

+    ~PPCallbacks() override {}
+    void MacroExpands(const clang::Token& name,
+                      const clang::MacroDefinition& def,
+                      clang::SourceRange range,
+                      const clang::MacroArgs* args) override {
+      clang::IdentifierInfo* id = name.getIdentifierInfo();
+      if (!id)
+        return;
+
+      if (id->getName() != "EXPECT_CALL")
+        return;
+
+      if (def.getMacroInfo()->getNumArgs() != 2)
+        return;
+
+      // TODO(lukasza): Should check if def.getMacroInfo()->getDefinitionLoc()
+      // is in testing/gmock/include/gmock/gmock-spec-builders.h but I don't
+      // know how to get clang::SourceManager to call getFileName.
+
+      rewriter_->RecordExpectCallMacroInvocation(
+          name.getLocation(), args->getUnexpArgument(1)->getLocation());
+    }
+
+   private:
+    GMockMemberRewriter* rewriter_;
+  };
+};
+
 clang::DeclarationName GetUnresolvedName(
     const clang::UnresolvedMemberExpr& expr) {
   return expr.getMemberName();
 }
 
 clang::DeclarationName GetUnresolvedName(
     const clang::DependentScopeDeclRefExpr& expr) {
   return expr.getDeclName();
 }
 
@@ skipping 117 matching lines @@
 
 using UnresolvedUsingValueDeclRewriter =
     UnresolvedRewriterBase<clang::UnresolvedUsingValueDecl>;
 
 using DependentScopeDeclRefExprRewriter =
     UnresolvedRewriterBase<clang::DependentScopeDeclRefExpr>;
 
 using CXXDependentScopeMemberExprRewriter =
     UnresolvedRewriterBase<clang::CXXDependentScopeMemberExpr>;
 
+class SourceFileCallbacks : public clang::tooling::SourceFileCallbacks {
+ public:
+  SourceFileCallbacks() : source_counter_(0) {}
+  ~SourceFileCallbacks() override {}
+
+  void AddPPCallbacks(std::unique_ptr<clang::PPCallbacks> new_callbacks) {
+    if (!pp_callbacks_) {
+      pp_callbacks_ = std::move(new_callbacks);
+    } else {
+      pp_callbacks_ = llvm::make_unique<clang::PPChainedCallbacks>(
+          std::move(new_callbacks), std::move(pp_callbacks_));

[dcheng, 2017/01/09 19:27:47]

Do we need chaining support? It seems like we our code should be simple enough
that we don't need chaining.

[Łukasz Anforowicz, 2017/01/09 20:11:27]

Done.

+    }
+  }
+
+  // clang::tooling::SourceFileCallbacks override:
+  bool handleBeginSource(clang::CompilerInstance& compiler,
+                         llvm::StringRef Filename) override {
+    source_counter_++;
+    assert(source_counter_ == 1);  // We only have *one* pp_callbacks_.

[dcheng, 2017/01/09 19:27:47]

What happens if the tool is run on multiple files at once?

[Łukasz Anforowicz, 2017/01/09 20:11:27]

Fixed by creating a new PPCallbacks every time.

+
+    if (pp_callbacks_)
+      compiler.getPreprocessor().addPPCallbacks(std::move(pp_callbacks_));

[dcheng, 2017/01/09 19:27:47]

Similarly, I think we should be able to assert pp_callbacks_ here?

[Łukasz Anforowicz, 2017/01/09 20:11:27]

See above - we are now creating a new PPCallbacks every time.

+
+    return true;
+  }
+
+ private:
+  int source_counter_;
+  std::unique_ptr<clang::PPCallbacks> pp_callbacks_;
+};
+
 }  // namespace
 
 static llvm::cl::extrahelp common_help(CommonOptionsParser::HelpMessage);
 
 int main(int argc, const char* argv[]) {
   // TODO(dcheng): Clang tooling should do this itself.
   // http://llvm.org/bugs/show_bug.cgi?id=21627
   llvm::InitializeNativeTarget();
   llvm::InitializeNativeTargetAsmParser();
   llvm::cl::OptionCategory category(
@@ skipping 165 matching lines @@
           // same method.
           is_blink_method));
   MethodDeclRewriter method_decl_rewriter(&replacements);
   match_finder.addMatcher(method_decl_matcher, &method_decl_rewriter);
 
   // Method references in a non-member context ========
   // Given
   //   S s;
   //   s.g();
   //   void (S::*p)() = &S::g;
-  // matches |&S::g| but not |s.g()|.
+  // matches |&S::g| but not |s.g|.
   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);
 
   // Method references in a member context ========
   // Given
   //   S s;
   //   s.g();
   //   void (S::*p)() = &S::g;
-  // matches |s.g()| but not |&S::g|.
+  // matches |s.g| but not |&S::g|.
   auto method_member_matcher =
       id("expr", memberExpr(member(method_decl_matcher)));
 
   MethodMemberRewriter method_member_rewriter(&replacements);
   match_finder.addMatcher(method_member_matcher, &method_member_rewriter);
 
   // Initializers ========
   // Given
   //   struct S {
   //     int x;
@@ skipping 148 matching lines @@
   //   };
   // matches |T::foo| and |x.bar|.
   auto cxx_dependent_scope_member_expr_matcher =
       expr(id("expr", cxxDependentScopeMemberExpr(
                           hasMemberFromType(blink_qual_type_matcher))));
   CXXDependentScopeMemberExprRewriter cxx_dependent_scope_member_expr_rewriter(
       &replacements);
   match_finder.addMatcher(cxx_dependent_scope_member_expr_matcher,
                           &cxx_dependent_scope_member_expr_rewriter);
 
+  // GMock calls lookup ========
+  // Given
+  //   EXPECT_CALL(obj, myMethod(...))
+  // will match obj.gmock_myMethod(...) call generated by the macro
+  // (but only if it mocks a Blink method).
+  auto gmock_member_matcher =
+      id("expr", memberExpr(hasDeclaration(
+                     decl(cxxMethodDecl(mocksMethod(method_decl_matcher))))));
+  GMockMemberRewriter gmock_member_rewriter(&replacements);
+  match_finder.addMatcher(gmock_member_matcher, &gmock_member_rewriter);
+
+  // Run all the matchers.

[dcheng, 2017/01/09 19:27:47]

This comment seems a bit out-of-place, since it looks like it applies to the
part where we hook up the PPCallbacks.

[Łukasz Anforowicz, 2017/01/09 20:11:27]

I changed the comment - does it look better now?

+  SourceFileCallbacks source_file_callbacks;
+  source_file_callbacks.AddPPCallbacks(
+      gmock_member_rewriter.CreatePreprocessorCallbacks());
   std::unique_ptr<clang::tooling::FrontendActionFactory> factory =
-      clang::tooling::newFrontendActionFactory(&match_finder);
+      clang::tooling::newFrontendActionFactory(&match_finder,
+                                               &source_file_callbacks);
   int result = tool.run(factory.get());
   if (result != 0)
     return result;
 
   // Supplemental data for the Blink rename rebase helper.
   // TODO(dcheng): There's a lot of match rewriters missing from this list.
   llvm::outs() << "==== BEGIN TRACKED EDITS ====\n";
   field_decl_rewriter.edit_tracker().SerializeTo("var", llvm::outs());
   var_decl_rewriter.edit_tracker().SerializeTo("var", llvm::outs());
   enum_member_decl_rewriter.edit_tracker().SerializeTo("enu", llvm::outs());
   function_decl_rewriter.edit_tracker().SerializeTo("fun", llvm::outs());
   method_decl_rewriter.edit_tracker().SerializeTo("fun", llvm::outs());
   llvm::outs() << "==== END TRACKED EDITS ====\n";
 
   // Serialization format is documented in tools/clang/scripts/run_tool.py
   llvm::outs() << "==== BEGIN EDITS ====\n";
   for (const auto& r : replacements) {
     std::string replacement_text = r.getReplacementText().str();
     std::replace(replacement_text.begin(), replacement_text.end(), '\n', '\0');
     llvm::outs() << "r:::" << r.getFilePath() << ":::" << r.getOffset()
                  << ":::" << r.getLength() << ":::" << replacement_text << "\n";
   }
   llvm::outs() << "==== END EDITS ====\n";
 
   return 0;
 }