[libTooling] Change `access` stencil to recognize use of `operator*`.

[ymandel]

Summary

Currently, access doesn't recognize a dereferenced smart pointer. So,
access(e, "field") where e = *x, yields:

• x->field, for normal-pointer x,
• (*x).field, for smart-pointer x.

This patch normalizes handling of smart pointer to match normal pointer, when
the smart pointer type supports ->.

[ymandel]

cleanup tweaks

[ymandel]

add comments and simplify.

clang/lib/Tooling/Transformer/Stencil.cpp

const auto QuacksLikeASmartPointer = cxxRecordDecl(
                               returns(qualType(pointsTo(type()))))),
       hasMethod(cxxMethodDecl(hasOverloadedOperatorName("*"),
                               returns(qualType(references(type()))))));
   const auto SmartPointer = qualType(hasDeclaration(
       cxxRecordDecl(anyOf(KnownSmartPointer, QuacksLikeASmartPointer))));
   return match(SmartPointer, Ty, Context).size() > 0;
 }
 
+// Identifies use of `operator*` on smart pointers, and returns the underlying
+// smart-pointer expression; otherwise, returns null.
+static const Expr *isSmartDereference(const Expr &E, ASTContext &Context) {
+  using namespace ::clang::ast_matchers;
+
+  const auto HasOverloadedArrow = cxxRecordDecl(hasMethod(cxxMethodDecl(
+      hasOverloadedOperatorName("->"), returns(qualType(pointsTo(type()))))));
+  // Verify it is a smart pointer by finding `operator->` in the class
+  // declaration.
+  auto Deref = cxxOperatorCallExpr(
+      hasOverloadedOperatorName("*"), hasUnaryOperand(expr().bind("arg")),
+      callee(cxxMethodDecl(ofClass(HasOverloadedArrow))));
+  return selectFirst<Expr>("arg", match(Deref, E, Context));
+}
+
 namespace {
 // An arbitrary fragment of code within a stencil.
 class RawTextStencil : public StencilInterface {
   std::string Text;
 
 public:
   explicit RawTextStencil(std::string T) : Text(std::move(T)) {}
 
if (!E->isImplicitCXXThis()) {
         // expression.
         if (const auto *OpCall = dyn_cast<clang::CXXOperatorCallExpr>(E)) {
           if (OpCall->getOperator() == clang::OO_Arrow &&
               OpCall->getNumArgs() == 1) {
             E = OpCall->getArg(0);
           }
         }
         S = tooling::buildArrow(*E, *Match.Context);
+      } else if (const auto *Operand = isSmartDereference(*E, *Match.Context)) {
+        // `buildDot` already handles the built-in dereference operator, so we
+        // only need to catch overloaded `operator*`.
+        S = tooling::buildArrow(*Operand, *Match.Context);
       } else {
         S = tooling::buildDot(*E, *Match.Context);
       }
       if (S.hasValue())
         *Result += *S;
       else
         return llvm::make_error<StringError>(
             errc::invalid_argument,

clang/unittests/Tooling/StencilTest.cpp

 }
 
 TEST_F(StencilTest, AccessOpSmartPointerDereference) {
   StringRef Snippet = R"cc(
     Smart x;
     *x;
   )cc";
   StringRef Id = "id";
-  testExpr(Id, Snippet, access(Id, "field"), "(*x).field");
+  testExpr(Id, Snippet, access(Id, "field"), "x->field");
 }
 
 TEST_F(StencilTest, AccessOpSmartPointerMemberCall) {
   StringRef Snippet = R"cc(
     Smart x;
     x->Field;
   )cc";
   StringRef Id = "id";