Widen `name` stencil to support `TypeLoc` nodes.

[SilensAngelusNex]

Fix typo in name's doc comment and add TypeLoc to the list of expected types in name's typeError.

[steveire]

Adding Yitzhak as a reviewer. I notice that at least the name of a cxxBaseSpecifier is not supported and I don't know if that (or lack of typeloc support) is desired in the Transformer design.

[ymandel]

Nice, thanks!

In D102185#2749279, @steveire wrote:

Adding Yitzhak as a reviewer. I notice that at least the name of a cxxBaseSpecifier is not supported and I don't know if that (or lack of typeloc support) is desired in the Transformer design.

No, not by design, but good question. I'd be happy to take a patch adding cxxBaseSpecifier support as well.

clang/lib/Tooling/Transformer/RangeSelector.cpp

234

Please use Loc instead of T->. I find it a bit confusing to see them both used.

[SilensAngelusNex]

T-> => Loc.

clang/include/clang/Tooling/Transformer/RangeSelector.h

 /// Selects a node, including trailing semicolon (always). Useful for selecting
 /// expression statements. \p ID is the node's binding in the match result.
 RangeSelector statement(std::string ID);
 
 /// Given a \c MemberExpr, selects the member token. \p ID is the node's
 /// binding in the match result.
 RangeSelector member(std::string ID);
 
-/// Given a node with a "name", (like \c NamedDecl, \c DeclRefExpr or \c
-/// CxxCtorInitializer) selects the name's token.  Only selects the final
-/// identifier of a qualified name, but not any qualifiers or template
+/// Given a node with a "name", (like \c NamedDecl, \c DeclRefExpr, \c
+/// CxxCtorInitializer, and \c TypeLoc) selects the name's token.  Only selects
+/// the final identifier of a qualified name, but not any qualifiers or template
 /// arguments.  For example, for `::foo::bar::baz` and `::foo::bar::baz<int>`,
 /// it selects only `baz`.
 ///
 /// \param ID is the node's binding in the match result.
 RangeSelector name(std::string ID);
 
 // Given a \c CallExpr (bound to \p ID), selects the arguments' source text (all
 // source between the call's parentheses).

clang/lib/Tooling/Transformer/RangeSelector.cpp

 //===--- RangeSelector.cpp - RangeSelector implementations ------*- C++ -*-===//
 //
 // 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 "clang/Tooling/Transformer/RangeSelector.h"
 #include "clang/AST/Expr.h"
+#include "clang/AST/TypeLoc.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "clang/Basic/SourceLocation.h"
 #include "clang/Lex/Lexer.h"
 #include "clang/Tooling/Transformer/SourceCode.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Errc.h"
 #include "llvm/Support/Error.h"
 #include <string>
if (const auto *E = Node.get<DeclRefExpr>()) {
       return CharSourceRange::getTokenRange(L, L);
     }
     if (const auto *I = Node.get<CXXCtorInitializer>()) {
       if (!I->isMemberInitializer() && I->isWritten())
         return missingPropertyError(ID, "name", "explicit member initializer");
       SourceLocation L = I->getMemberLocation();
       return CharSourceRange::getTokenRange(L, L);
     }
+    if (const auto *T = Node.get<TypeLoc>()) {
+      TypeLoc Loc = *T;
+      auto ET = Loc.getAs<ElaboratedTypeLoc>();
+      if (!ET.isNull()) {
+        Loc = ET.getNamedTypeLoc();
+      }
+      return CharSourceRange::getTokenRange(Loc.getSourceRange());
+    }
     return typeError(ID, Node.getNodeKind(),
-                     "DeclRefExpr, NamedDecl, CXXCtorInitializer");
+                     "DeclRefExpr, NamedDecl, CXXCtorInitializer, TypeLoc");
   };
 }
 
 namespace {
 // FIXME: make this available in the public API for users to easily create their
 // own selectors.
 
 // Creates a selector from a range-selection function \p Func, which selects a

clang/unittests/Tooling/RangeSelectorTest.cpp

public:
       int field;
     };
   )cc";
   const char *Init = "init";
   TestMatch Match = matchCode(Code, cxxCtorInitializer().bind(Init));
   EXPECT_THAT_EXPECTED(select(name(Init), Match), HasValue("field"));
 }
 
+TEST(RangeSelectorTest, NameOpTypeLoc) {
+  StringRef Code = R"cc(
+    namespace ns {
+    struct Foo {
+      Foo();
+      Foo(int);
+      Foo(int, int);
+    };
+    }  // namespace ns
+
+    ns::Foo a;
+    auto b = ns::Foo(3);
+    auto c = ns::Foo(1, 2);
+  )cc";
+  const char *CtorTy = "ctor_ty";
+  // Matches declaration of `a`
+  TestMatch MatchA = matchCode(
+      Code, varDecl(hasName("a"), hasTypeLoc(typeLoc().bind(CtorTy))));
+  EXPECT_THAT_EXPECTED(select(name(CtorTy), MatchA), HasValue("Foo"));
+  // Matches call of Foo(int)
+  TestMatch MatchB = matchCode(
+      Code, cxxFunctionalCastExpr(hasTypeLoc(typeLoc().bind(CtorTy))));
+  EXPECT_THAT_EXPECTED(select(name(CtorTy), MatchB), HasValue("Foo"));
+  // Matches call of Foo(int, int)
+  TestMatch MatchC = matchCode(
+      Code, cxxTemporaryObjectExpr(hasTypeLoc(typeLoc().bind(CtorTy))));
+  EXPECT_THAT_EXPECTED(select(name(CtorTy), MatchC), HasValue("Foo"));
+}
+
 TEST(RangeSelectorTest, NameOpErrors) {
   EXPECT_THAT_EXPECTED(selectFromTrivial(name("unbound_id")),
                        Failed<StringError>(withUnboundNodeMessage()));
   EXPECT_THAT_EXPECTED(selectFromAssorted(name("stmt")),
                        Failed<StringError>(withTypeErrorMessage("stmt")));
 }
 
 TEST(RangeSelectorTest, NameOpDeclRefError) {