Renamed `apply` to `select` to avoid ADL conflict with `std::apply`

[gribozavr]

Summary

std::apply in C++14 and above is defined with two unrestricted arguments, and
it wins overload resolution in this case.

[ilya-biryukov]

Quick LGTM to unbreak our integrate!

[ilya-biryukov]

@ymandel, feel free to change the name to your liking if you don't like select.

clang/unittests/Tooling/RangeSelectorTest.cpp

template <typename M> TestMatch matchCode(StringRef Code, M Matcher) {
   // We expect a single, exact match.
   assert(Matches.size() != 0 && "no matches found");
   assert(Matches.size() == 1 && "too many matches");
 
   return TestMatch{std::move(ASTUnit), MatchResult(Matches[0], &Context)};
 }
 
 // Applies \p Selector to \p Match and, on success, returns the selected source.
-Expected<StringRef> apply(RangeSelector Selector, const TestMatch &Match) {
+Expected<StringRef> select(RangeSelector Selector, const TestMatch &Match) {
   Expected<CharSourceRange> Range = Selector(Match.Result);
   if (!Range)
     return Range.takeError();
   return fixit::internal::getText(*Range, *Match.Result.Context);
 }
 
 // Applies \p Selector to a trivial match with only a single bound node with id
 // "bound_node_id".  For use in testing unbound-node errors.
-Expected<CharSourceRange> applyToTrivial(const RangeSelector &Selector) {
+Expected<CharSourceRange> selectFromTrivial(const RangeSelector &Selector) {
   // We need to bind the result to something, or the match will fail. Use a
   // binding that is not used in the unbound node tests.
   TestMatch Match =
       matchCode("static int x = 0;", varDecl().bind("bound_node_id"));
   return Selector(Match.Result);
 }
 
 // Matches the message expected for unbound-node failures.
 testing::Matcher<StringError> withUnboundNodeMessage() {
   return testing::Property(
       &StringError::getMessage,
       AllOf(HasSubstr("unbound_id"), HasSubstr("not bound")));
 }
 
 // Applies \p Selector to code containing assorted node types, where the match
 // binds each one: a statement ("stmt"), a (non-member) ctor-initializer
 // ("init"), an expression ("expr") and a (nameless) declaration ("decl").  Used
 // to test failures caused by applying selectors to nodes of the wrong type.
-Expected<CharSourceRange> applyToAssorted(RangeSelector Selector) {
+Expected<CharSourceRange> selectFromAssorted(RangeSelector Selector) {
   StringRef Code = R"cc(
       struct A {};
       class F : public A {
        public:
         F(int) {}
       };
       void g() { F f(1); }
     )cc";

 // Matches the message expected for type-error failures.
 testing::Matcher<StringError> withTypeErrorMessage(StringRef NodeID) {
   return testing::Property(
       &StringError::getMessage,
       AllOf(HasSubstr(NodeID), HasSubstr("mismatched type")));
 }
 
 TEST(RangeSelectorTest, UnboundNode) {
-  EXPECT_THAT_EXPECTED(applyToTrivial(node("unbound_id")),
+  EXPECT_THAT_EXPECTED(selectFromTrivial(node("unbound_id")),
                        Failed<StringError>(withUnboundNodeMessage()));
 }
 
 TEST(RangeSelectorTest, RangeOp) {
   StringRef Code = R"cc(
     int f(int x, int y, int z) { return 3; }
     int g() { return f(/* comment */ 3, 7 /* comment */, 9); }
   )cc";
   StringRef Arg0 = "a0";
   StringRef Arg1 = "a1";
   StringRef Call = "call";
   auto Matcher = callExpr(hasArgument(0, expr().bind(Arg0)),
                           hasArgument(1, expr().bind(Arg1)))
                      .bind(Call);
   TestMatch Match = matchCode(Code, Matcher);
 
   // Node-id specific version:
-  EXPECT_THAT_EXPECTED(apply(range(Arg0, Arg1), Match), HasValue("3, 7"));
+  EXPECT_THAT_EXPECTED(select(range(Arg0, Arg1), Match), HasValue("3, 7"));
   // General version:
-  EXPECT_THAT_EXPECTED(apply(range(node(Arg0), node(Arg1)), Match),
+  EXPECT_THAT_EXPECTED(select(range(node(Arg0), node(Arg1)), Match),
                        HasValue("3, 7"));
 }
 
 TEST(RangeSelectorTest, NodeOpStatement) {
   StringRef Code = "int f() { return 3; }";
   StringRef ID = "id";
   TestMatch Match = matchCode(Code, returnStmt().bind(ID));
-  EXPECT_THAT_EXPECTED(apply(node(ID), Match), HasValue("return 3;"));
+  EXPECT_THAT_EXPECTED(select(node(ID), Match), HasValue("return 3;"));
 }
 
 TEST(RangeSelectorTest, NodeOpExpression) {
   StringRef Code = "int f() { return 3; }";
   StringRef ID = "id";
   TestMatch Match = matchCode(Code, expr().bind(ID));
-  EXPECT_THAT_EXPECTED(apply(node(ID), Match), HasValue("3"));
+  EXPECT_THAT_EXPECTED(select(node(ID), Match), HasValue("3"));
 }
 
 TEST(RangeSelectorTest, StatementOp) {
   StringRef Code = "int f() { return 3; }";
   StringRef ID = "id";
   TestMatch Match = matchCode(Code, expr().bind(ID));
-  EXPECT_THAT_EXPECTED(apply(statement(ID), Match), HasValue("3;"));
+  EXPECT_THAT_EXPECTED(select(statement(ID), Match), HasValue("3;"));
 }
 
 TEST(RangeSelectorTest, MemberOp) {
   StringRef Code = R"cc(
     struct S {
       int member;
     };
     int g() {
       S s;
       return s.member;
     }
   )cc";
   StringRef ID = "id";
   TestMatch Match = matchCode(Code, memberExpr().bind(ID));
-  EXPECT_THAT_EXPECTED(apply(member(ID), Match), HasValue("member"));
+  EXPECT_THAT_EXPECTED(select(member(ID), Match), HasValue("member"));
 }
 
 // Tests that member does not select any qualifiers on the member name.
 TEST(RangeSelectorTest, MemberOpQualified) {
   StringRef Code = R"cc(
     struct S {
       int member;
     };
     struct T : public S {
       int field;
     };
     int g() {
       T t;
       return t.S::member;
     }
   )cc";
   StringRef ID = "id";
   TestMatch Match = matchCode(Code, memberExpr().bind(ID));
-  EXPECT_THAT_EXPECTED(apply(member(ID), Match), HasValue("member"));
+  EXPECT_THAT_EXPECTED(select(member(ID), Match), HasValue("member"));
 }
 
 TEST(RangeSelectorTest, MemberOpTemplate) {
   StringRef Code = R"cc(
     struct S {
       template <typename T> T foo(T t);
     };
     int f(int x) {
       S s;
       return s.template foo<int>(3);
     }
   )cc";
 
   StringRef ID = "id";
   TestMatch Match = matchCode(Code, memberExpr().bind(ID));
-  EXPECT_THAT_EXPECTED(apply(member(ID), Match), HasValue("foo"));
+  EXPECT_THAT_EXPECTED(select(member(ID), Match), HasValue("foo"));
 }
 
 TEST(RangeSelectorTest, MemberOpOperator) {
   StringRef Code = R"cc(
     struct S {
       int operator*();
     };
     int f(int x) {
       S s;
       return s.operator *();
     }
   )cc";
 
   StringRef ID = "id";
   TestMatch Match = matchCode(Code, memberExpr().bind(ID));
-  EXPECT_THAT_EXPECTED(apply(member(ID), Match), HasValue("operator *"));
+  EXPECT_THAT_EXPECTED(select(member(ID), Match), HasValue("operator *"));
 }
 
 TEST(RangeSelectorTest, NameOpNamedDecl) {
   StringRef Code = R"cc(
     int myfun() {
       return 3;
     }
   )cc";
   StringRef ID = "id";
   TestMatch Match = matchCode(Code, functionDecl().bind(ID));
-  EXPECT_THAT_EXPECTED(apply(name(ID), Match), HasValue("myfun"));
+  EXPECT_THAT_EXPECTED(select(name(ID), Match), HasValue("myfun"));
 }
 
 TEST(RangeSelectorTest, NameOpDeclRef) {
   StringRef Code = R"cc(
     int foo(int x) {
       return x;
     }
     int g(int x) { return foo(x) * x; }
   )cc";
   StringRef Ref = "ref";
   TestMatch Match = matchCode(Code, declRefExpr(to(functionDecl())).bind(Ref));
-  EXPECT_THAT_EXPECTED(apply(name(Ref), Match), HasValue("foo"));
+  EXPECT_THAT_EXPECTED(select(name(Ref), Match), HasValue("foo"));
 }
 
 TEST(RangeSelectorTest, NameOpCtorInitializer) {
   StringRef Code = R"cc(
     class C {
      public:
       C() : field(3) {}
       int field;
     };
   )cc";
   StringRef Init = "init";
   TestMatch Match = matchCode(Code, cxxCtorInitializer().bind(Init));
-  EXPECT_THAT_EXPECTED(apply(name(Init), Match), HasValue("field"));
+  EXPECT_THAT_EXPECTED(select(name(Init), Match), HasValue("field"));
 }
 
 TEST(RangeSelectorTest, NameOpErrors) {
-  EXPECT_THAT_EXPECTED(applyToTrivial(name("unbound_id")),
+  EXPECT_THAT_EXPECTED(selectFromTrivial(name("unbound_id")),
                        Failed<StringError>(withUnboundNodeMessage()));
-  EXPECT_THAT_EXPECTED(applyToAssorted(name("stmt")),
+  EXPECT_THAT_EXPECTED(selectFromAssorted(name("stmt")),
                        Failed<StringError>(withTypeErrorMessage("stmt")));
 }
 
 TEST(RangeSelectorTest, NameOpDeclRefError) {
   StringRef Code = R"cc(
     struct S {
       int operator*();
     };
const StringRef Code = R"cc(
     };
     int f() {
       C x;
       return x.bar(3, 4);
     }
   )cc";
   StringRef ID = "id";
   TestMatch Match = matchCode(Code, callExpr().bind(ID));
-  EXPECT_THAT_EXPECTED(apply(callArgs(ID), Match), HasValue("3, 4"));
+  EXPECT_THAT_EXPECTED(select(callArgs(ID), Match), HasValue("3, 4"));
 }
 
 TEST(RangeSelectorTest, CallArgsOpNoArgs) {
   const StringRef Code = R"cc(
     struct C {
       int bar();
     };
     int f() {
       C x;
       return x.bar();
     }
   )cc";
   StringRef ID = "id";
   TestMatch Match = matchCode(Code, callExpr().bind(ID));
-  EXPECT_THAT_EXPECTED(apply(callArgs(ID), Match), HasValue(""));
+  EXPECT_THAT_EXPECTED(select(callArgs(ID), Match), HasValue(""));
 }
 
 TEST(RangeSelectorTest, CallArgsOpNoArgsWithComments) {
   const StringRef Code = R"cc(
     struct C {
       int bar();
     };
     int f() {
       C x;
       return x.bar(/*empty*/);
     }
   )cc";
   StringRef ID = "id";
   TestMatch Match = matchCode(Code, callExpr().bind(ID));
-  EXPECT_THAT_EXPECTED(apply(callArgs(ID), Match), HasValue("/*empty*/"));
+  EXPECT_THAT_EXPECTED(select(callArgs(ID), Match), HasValue("/*empty*/"));
 }
 
 // Tests that arguments are extracted correctly when a temporary (with parens)
 // is used.
 TEST(RangeSelectorTest, CallArgsOpWithParens) {
   const StringRef Code = R"cc(
     struct C {
       int bar(int, int) { return 3; }
     };
     int f() {
       C x;
       return C().bar(3, 4);
     }
   )cc";
   StringRef ID = "id";
   TestMatch Match =
       matchCode(Code, callExpr(callee(functionDecl(hasName("bar")))).bind(ID));
-  EXPECT_THAT_EXPECTED(apply(callArgs(ID), Match), HasValue("3, 4"));
+  EXPECT_THAT_EXPECTED(select(callArgs(ID), Match), HasValue("3, 4"));
 }
 
 TEST(RangeSelectorTest, CallArgsOpLeadingComments) {
   const StringRef Code = R"cc(
     struct C {
       int bar(int, int) { return 3; }
     };
     int f() {
       C x;
       return x.bar(/*leading*/ 3, 4);
     }
   )cc";
   StringRef ID = "id";
   TestMatch Match = matchCode(Code, callExpr().bind(ID));
-  EXPECT_THAT_EXPECTED(apply(callArgs(ID), Match),
+  EXPECT_THAT_EXPECTED(select(callArgs(ID), Match),
                        HasValue("/*leading*/ 3, 4"));
 }
 
 TEST(RangeSelectorTest, CallArgsOpTrailingComments) {
   const StringRef Code = R"cc(
     struct C {
       int bar(int, int) { return 3; }
     };
     int f() {
       C x;
       return x.bar(3 /*trailing*/, 4);
     }
   )cc";
   StringRef ID = "id";
   TestMatch Match = matchCode(Code, callExpr().bind(ID));
-  EXPECT_THAT_EXPECTED(apply(callArgs(ID), Match),
+  EXPECT_THAT_EXPECTED(select(callArgs(ID), Match),
                        HasValue("3 /*trailing*/, 4"));
 }
 
 TEST(RangeSelectorTest, CallArgsOpEolComments) {
   const StringRef Code = R"cc(
     struct C {
       int bar(int, int) { return 3; }
     };
     int f() {
       C x;
       return x.bar(  // Header
           1,           // foo
           2            // bar
       );
     }
   )cc";
   StringRef ID = "id";
   TestMatch Match = matchCode(Code, callExpr().bind(ID));
-  EXPECT_THAT_EXPECTED(apply(callArgs(ID), Match), HasValue(R"(  // Header
+  EXPECT_THAT_EXPECTED(select(callArgs(ID), Match), HasValue(R"(  // Header
           1,           // foo
           2            // bar
       )"));
 }
 
 TEST(RangeSelectorTest, CallArgsErrors) {
-  EXPECT_THAT_EXPECTED(applyToTrivial(callArgs("unbound_id")),
+  EXPECT_THAT_EXPECTED(selectFromTrivial(callArgs("unbound_id")),
                        Failed<StringError>(withUnboundNodeMessage()));
-  EXPECT_THAT_EXPECTED(applyToAssorted(callArgs("stmt")),
+  EXPECT_THAT_EXPECTED(selectFromAssorted(callArgs("stmt")),
                        Failed<StringError>(withTypeErrorMessage("stmt")));
 }
 
 TEST(RangeSelectorTest, StatementsOp) {
   StringRef Code = R"cc(
     void g();
     void f() { /* comment */ g(); /* comment */ g(); /* comment */ }
   )cc";
   StringRef ID = "id";
   TestMatch Match = matchCode(Code, compoundStmt().bind(ID));
   EXPECT_THAT_EXPECTED(
-      apply(statements(ID), Match),
+      select(statements(ID), Match),
       HasValue(" /* comment */ g(); /* comment */ g(); /* comment */ "));
 }
 
 TEST(RangeSelectorTest, StatementsOpEmptyList) {
   StringRef Code = "void f() {}";
   StringRef ID = "id";
   TestMatch Match = matchCode(Code, compoundStmt().bind(ID));
-  EXPECT_THAT_EXPECTED(apply(statements(ID), Match), HasValue(""));
+  EXPECT_THAT_EXPECTED(select(statements(ID), Match), HasValue(""));
 }
 
 TEST(RangeSelectorTest, StatementsOpErrors) {
-  EXPECT_THAT_EXPECTED(applyToTrivial(statements("unbound_id")),
+  EXPECT_THAT_EXPECTED(selectFromTrivial(statements("unbound_id")),
                        Failed<StringError>(withUnboundNodeMessage()));
-  EXPECT_THAT_EXPECTED(applyToAssorted(statements("decl")),
+  EXPECT_THAT_EXPECTED(selectFromAssorted(statements("decl")),
                        Failed<StringError>(withTypeErrorMessage("decl")));
 }
 
 TEST(RangeSelectorTest, ElementsOp) {
   StringRef Code = R"cc(
     void f() {
       int v[] = {/* comment */ 3, /* comment*/ 4 /* comment */};
       (void)v;
     }
   )cc";
   StringRef ID = "id";
   TestMatch Match = matchCode(Code, initListExpr().bind(ID));
   EXPECT_THAT_EXPECTED(
-      apply(initListElements(ID), Match),
+      select(initListElements(ID), Match),
       HasValue("/* comment */ 3, /* comment*/ 4 /* comment */"));
 }
 
 TEST(RangeSelectorTest, ElementsOpEmptyList) {
   StringRef Code = R"cc(
     void f() {
       int v[] = {};
       (void)v;
     }
   )cc";
   StringRef ID = "id";
   TestMatch Match = matchCode(Code, initListExpr().bind(ID));
-  EXPECT_THAT_EXPECTED(apply(initListElements(ID), Match), HasValue(""));
+  EXPECT_THAT_EXPECTED(select(initListElements(ID), Match), HasValue(""));
 }
 
 TEST(RangeSelectorTest, ElementsOpErrors) {
-  EXPECT_THAT_EXPECTED(applyToTrivial(initListElements("unbound_id")),
+  EXPECT_THAT_EXPECTED(selectFromTrivial(initListElements("unbound_id")),
                        Failed<StringError>(withUnboundNodeMessage()));
-  EXPECT_THAT_EXPECTED(applyToAssorted(initListElements("stmt")),
+  EXPECT_THAT_EXPECTED(selectFromAssorted(initListElements("stmt")),
                        Failed<StringError>(withTypeErrorMessage("stmt")));
 }
 
 // Tests case where the matched node is the complete expanded text.
 TEST(RangeSelectorTest, ExpansionOp) {
   StringRef Code = R"cc(
 #define BADDECL(E) int bad(int x) { return E; }
     BADDECL(x * x)
   )cc";
 
   StringRef Fun = "Fun";
   TestMatch Match = matchCode(Code, functionDecl(hasName("bad")).bind(Fun));
-  EXPECT_THAT_EXPECTED(apply(expansion(node(Fun)), Match),
+  EXPECT_THAT_EXPECTED(select(expansion(node(Fun)), Match),
                        HasValue("BADDECL(x * x)"));
 }
 
 // Tests case where the matched node is (only) part of the expanded text.
 TEST(RangeSelectorTest, ExpansionOpPartial) {
   StringRef Code = R"cc(
 #define BADDECL(E) int bad(int x) { return E; }
     BADDECL(x * x)
   )cc";
 
   StringRef Ret = "Ret";
   TestMatch Match = matchCode(Code, returnStmt().bind(Ret));
-  EXPECT_THAT_EXPECTED(apply(expansion(node(Ret)), Match),
+  EXPECT_THAT_EXPECTED(select(expansion(node(Ret)), Match),
                        HasValue("BADDECL(x * x)"));
 }
 
 } // namespace