//===- unittest/ASTMatchers/Dynamic/ParserTest.cpp - Parser unit tests -===//
//
// 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 "../ASTMatchersTest.h"
#include "clang/ASTMatchers/Dynamic/Parser.h"
#include "clang/ASTMatchers/Dynamic/Registry.h"
#include "llvm/ADT/Optional.h"
#include "gtest/gtest.h"
#include <string>
#include <vector>

namespace clang {
namespace ast_matchers {
namespace dynamic {
namespace {

class MockSema : public Parser::Sema {
public:
  ~MockSema() override {}

  uint64_t expectMatcher(StringRef MatcherName) {
    // Optimizations on the matcher framework make simple matchers like
    // 'stmt()' to be all the same matcher.
    // Use a more complex expression to prevent that.
    ast_matchers::internal::Matcher<Stmt> M = stmt(stmt(), stmt());
    ExpectedMatchers.insert(std::make_pair(std::string(MatcherName), M));
    return M.getID().second;
  }

  void parse(StringRef Code) {
    Diagnostics Error;
    VariantValue Value;
    Parser::parseExpression(Code, this, &Value, &Error);
    Values.push_back(Value);
    Errors.push_back(Error.toStringFull());
  }

  llvm::Optional<MatcherCtor>
  lookupMatcherCtor(StringRef MatcherName) override {
    const ExpectedMatchersTy::value_type *Matcher =
        &*ExpectedMatchers.find(std::string(MatcherName));
    return reinterpret_cast<MatcherCtor>(Matcher);
  }

  VariantMatcher actOnMatcherExpression(MatcherCtor Ctor,
                                        SourceRange NameRange,
                                        StringRef BindID,
                                        ArrayRef<ParserValue> Args,
                                        Diagnostics *Error) override {
    const ExpectedMatchersTy::value_type *Matcher =
        reinterpret_cast<const ExpectedMatchersTy::value_type *>(Ctor);
    MatcherInfo ToStore = {Matcher->first, NameRange, Args,
                           std::string(BindID)};
    Matchers.push_back(ToStore);
    return VariantMatcher::SingleMatcher(Matcher->second);
  }

  struct MatcherInfo {
    StringRef MatcherName;
    SourceRange NameRange;
    std::vector<ParserValue> Args;
    std::string BoundID;
  };

  std::vector<std::string> Errors;
  std::vector<VariantValue> Values;
  std::vector<MatcherInfo> Matchers;
  typedef std::map<std::string, ast_matchers::internal::Matcher<Stmt> >
  ExpectedMatchersTy;
  ExpectedMatchersTy ExpectedMatchers;
};

TEST(ParserTest, ParseBoolean) {
  MockSema Sema;
  Sema.parse("true");
  Sema.parse("false");
  EXPECT_EQ(2U, Sema.Values.size());
  EXPECT_TRUE(Sema.Values[0].getBoolean());
  EXPECT_FALSE(Sema.Values[1].getBoolean());
}

TEST(ParserTest, ParseDouble) {
  MockSema Sema;
  Sema.parse("1.0");
  Sema.parse("2.0f");
  Sema.parse("34.56e-78");
  Sema.parse("4.E+6");
  Sema.parse("1");
  EXPECT_EQ(5U, Sema.Values.size());
  EXPECT_EQ(1.0, Sema.Values[0].getDouble());
  EXPECT_EQ("1:1: Error parsing numeric literal: <2.0f>", Sema.Errors[1]);
  EXPECT_EQ(34.56e-78, Sema.Values[2].getDouble());
  EXPECT_EQ(4e+6, Sema.Values[3].getDouble());
  EXPECT_FALSE(Sema.Values[4].isDouble());
}

TEST(ParserTest, ParseUnsigned) {
  MockSema Sema;
  Sema.parse("0");
  Sema.parse("123");
  Sema.parse("0x1f");
  Sema.parse("12345678901");
  Sema.parse("1a1");
  EXPECT_EQ(5U, Sema.Values.size());
  EXPECT_EQ(0U, Sema.Values[0].getUnsigned());
  EXPECT_EQ(123U, Sema.Values[1].getUnsigned());
  EXPECT_EQ(31U, Sema.Values[2].getUnsigned());
  EXPECT_EQ("1:1: Error parsing numeric literal: <12345678901>", Sema.Errors[3]);
  EXPECT_EQ("1:1: Error parsing numeric literal: <1a1>", Sema.Errors[4]);
}

TEST(ParserTest, ParseString) {
  MockSema Sema;
  Sema.parse("\"Foo\"");
  Sema.parse("\"\"");
  Sema.parse("\"Baz");
  EXPECT_EQ(3ULL, Sema.Values.size());
  EXPECT_EQ("Foo", Sema.Values[0].getString());
  EXPECT_EQ("", Sema.Values[1].getString());
  EXPECT_EQ("1:1: Error parsing string token: <\"Baz>", Sema.Errors[2]);
}

bool matchesRange(SourceRange Range, unsigned StartLine,
                  unsigned EndLine, unsigned StartColumn, unsigned EndColumn) {
  EXPECT_EQ(StartLine, Range.Start.Line);
  EXPECT_EQ(EndLine, Range.End.Line);
  EXPECT_EQ(StartColumn, Range.Start.Column);
  EXPECT_EQ(EndColumn, Range.End.Column);
  return Range.Start.Line == StartLine && Range.End.Line == EndLine &&
         Range.Start.Column == StartColumn && Range.End.Column == EndColumn;
}

llvm::Optional<DynTypedMatcher> getSingleMatcher(const VariantValue &Value) {
  llvm::Optional<DynTypedMatcher> Result =
      Value.getMatcher().getSingleMatcher();
  EXPECT_TRUE(Result.hasValue());
  return Result;
}

TEST(ParserTest, ParseMatcher) {
  MockSema Sema;
  const uint64_t ExpectedFoo = Sema.expectMatcher("Foo");
  const uint64_t ExpectedBar = Sema.expectMatcher("Bar");
  const uint64_t ExpectedBaz = Sema.expectMatcher("Baz");
  Sema.parse(" Foo ( Bar ( 17), Baz( \n \"B A,Z\") ) .bind( \"Yo!\") ");
  for (const auto &E : Sema.Errors) {
    EXPECT_EQ("", E);
  }

  EXPECT_NE(ExpectedFoo, ExpectedBar);
  EXPECT_NE(ExpectedFoo, ExpectedBaz);
  EXPECT_NE(ExpectedBar, ExpectedBaz);

  EXPECT_EQ(1ULL, Sema.Values.size());
  EXPECT_EQ(ExpectedFoo, getSingleMatcher(Sema.Values[0])->getID().second);

  EXPECT_EQ(3ULL, Sema.Matchers.size());
  const MockSema::MatcherInfo Bar = Sema.Matchers[0];
  EXPECT_EQ("Bar", Bar.MatcherName);
  EXPECT_TRUE(matchesRange(Bar.NameRange, 1, 1, 8, 17));
  EXPECT_EQ(1ULL, Bar.Args.size());
  EXPECT_EQ(17U, Bar.Args[0].Value.getUnsigned());

  const MockSema::MatcherInfo Baz = Sema.Matchers[1];
  EXPECT_EQ("Baz", Baz.MatcherName);
  EXPECT_TRUE(matchesRange(Baz.NameRange, 1, 2, 19, 10));
  EXPECT_EQ(1ULL, Baz.Args.size());
  EXPECT_EQ("B A,Z", Baz.Args[0].Value.getString());

  const MockSema::MatcherInfo Foo = Sema.Matchers[2];
  EXPECT_EQ("Foo", Foo.MatcherName);
  EXPECT_TRUE(matchesRange(Foo.NameRange, 1, 2, 2, 12));
  EXPECT_EQ(2ULL, Foo.Args.size());
  EXPECT_EQ(ExpectedBar, getSingleMatcher(Foo.Args[0].Value)->getID().second);
  EXPECT_EQ(ExpectedBaz, getSingleMatcher(Foo.Args[1].Value)->getID().second);
  EXPECT_EQ("Yo!", Foo.BoundID);
}

TEST(ParserTest, ParseComment) {
  MockSema Sema;
  Sema.expectMatcher("Foo");
  Sema.parse(" Foo() # Bar() ");
  for (const auto &E : Sema.Errors) {
    EXPECT_EQ("", E);
  }

  EXPECT_EQ(1ULL, Sema.Matchers.size());

  Sema.parse("Foo(#) ");

  EXPECT_EQ("1:4: Error parsing matcher. Found end-of-code while looking for ')'.", Sema.Errors[1]);
}

using ast_matchers::internal::Matcher;

Parser::NamedValueMap getTestNamedValues() {
  Parser::NamedValueMap Values;
  Values["nameX"] = llvm::StringRef("x");
  Values["hasParamA"] = VariantMatcher::SingleMatcher(
      functionDecl(hasParameter(0, hasName("a"))));
  return Values;
}

TEST(ParserTest, FullParserTest) {
  Diagnostics Error;

  StringRef Code =
      "varDecl(hasInitializer(binaryOperator(hasLHS(integerLiteral()),"
      "                                      hasOperatorName(\"+\"))))";
  llvm::Optional<DynTypedMatcher> VarDecl(
      Parser::parseMatcherExpression(Code, &Error));
  EXPECT_EQ("", Error.toStringFull());
  Matcher<Decl> M = VarDecl->unconditionalConvertTo<Decl>();
  EXPECT_TRUE(matches("int x = 1 + false;", M));
  EXPECT_FALSE(matches("int x = true + 1;", M));
  EXPECT_FALSE(matches("int x = 1 - false;", M));
  EXPECT_FALSE(matches("int x = true - 1;", M));

  Code = "implicitCastExpr(hasCastKind(\"CK_IntegralToBoolean\"))";
  llvm::Optional<DynTypedMatcher> implicitIntBooleanCast(
      Parser::parseMatcherExpression(Code, nullptr, nullptr, &Error));
  EXPECT_EQ("", Error.toStringFull());
  Matcher<Stmt> MCastStmt =
      traverse(TK_AsIs, implicitIntBooleanCast->unconditionalConvertTo<Stmt>());
  EXPECT_TRUE(matches("bool X = 1;", MCastStmt));
  EXPECT_FALSE(matches("bool X = true;", MCastStmt));

  Code = "functionDecl(hasParameter(1, hasName(\"x\")))";
  llvm::Optional<DynTypedMatcher> HasParameter(
      Parser::parseMatcherExpression(Code, &Error));
  EXPECT_EQ("", Error.toStringFull());
  M = HasParameter->unconditionalConvertTo<Decl>();

  EXPECT_TRUE(matches("void f(int a, int x);", M));
  EXPECT_FALSE(matches("void f(int x, int a);", M));

  // Test named values.
  auto NamedValues = getTestNamedValues();

  Code = "functionDecl(hasParamA, hasParameter(1, hasName(nameX)))";
  llvm::Optional<DynTypedMatcher> HasParameterWithNamedValues(
      Parser::parseMatcherExpression(Code, nullptr, &NamedValues, &Error));
  EXPECT_EQ("", Error.toStringFull());
  M = HasParameterWithNamedValues->unconditionalConvertTo<Decl>();

  EXPECT_TRUE(matches("void f(int a, int x);", M));
  EXPECT_FALSE(matches("void f(int x, int a);", M));

  Code = "unaryExprOrTypeTraitExpr(ofKind(\"UETT_SizeOf\"))";
  llvm::Optional<DynTypedMatcher> UnaryExprSizeOf(
      Parser::parseMatcherExpression(Code, nullptr, nullptr, &Error));
  EXPECT_EQ("", Error.toStringFull());
  Matcher<Stmt> MStmt = UnaryExprSizeOf->unconditionalConvertTo<Stmt>();
  EXPECT_TRUE(matches("unsigned X = sizeof(int);", MStmt));
  EXPECT_FALSE(matches("unsigned X = alignof(int);", MStmt));

  Code =
      R"query(namedDecl(matchesName("^::[ABC]*$", "IgnoreCase | BasicRegex")))query";
  llvm::Optional<DynTypedMatcher> MatchesName(
      Parser::parseMatcherExpression(Code, nullptr, nullptr, &Error));
  EXPECT_EQ("", Error.toStringFull());
  M = MatchesName->unconditionalConvertTo<Decl>();
  EXPECT_TRUE(matches("unsigned AAACCBB;", M));
  EXPECT_TRUE(matches("unsigned aaaccbb;", M));

  Code = "hasInitializer(\n    binaryOperator(hasLHS(\"A\")))";
  EXPECT_TRUE(!Parser::parseMatcherExpression(Code, &Error).hasValue());
  EXPECT_EQ("1:1: Error parsing argument 1 for matcher hasInitializer.\n"
            "2:5: Error parsing argument 1 for matcher binaryOperator.\n"
            "2:20: Error building matcher hasLHS.\n"
            "2:27: Incorrect type for arg 1. "
            "(Expected = Matcher<Expr>) != (Actual = String)",
            Error.toStringFull());
}

TEST(ParserTest, VariadicMatchTest) {
  Diagnostics Error;

  StringRef Code =
      "stmt(objcMessageExpr(hasAnySelector(\"methodA\", \"methodB:\")))";
  llvm::Optional<DynTypedMatcher> OM(
      Parser::parseMatcherExpression(Code, &Error));
  EXPECT_EQ("", Error.toStringFull());
  auto M = OM->unconditionalConvertTo<Stmt>();
  EXPECT_TRUE(matchesObjC("@interface I @end "
                          "void foo(I* i) { [i methodA]; }", M));
}

std::string ParseWithError(StringRef Code) {
  Diagnostics Error;
  VariantValue Value;
  Parser::parseExpression(Code, &Value, &Error);
  return Error.toStringFull();
}

std::string ParseMatcherWithError(StringRef Code) {
  Diagnostics Error;
  Parser::parseMatcherExpression(Code, &Error);
  return Error.toStringFull();
}

TEST(ParserTest, Errors) {
  EXPECT_EQ(
      "1:5: Error parsing matcher. Found token <123> while looking for '('.",
      ParseWithError("Foo 123"));
  EXPECT_EQ(
      "1:1: Matcher not found: Foo\n"
      "1:9: Error parsing matcher. Found token <123> while looking for ','.",
      ParseWithError("Foo(\"A\" 123)"));
  EXPECT_EQ(
      "1:1: Error parsing argument 1 for matcher stmt.\n"
      "1:6: Value not found: someValue",
      ParseWithError("stmt(someValue)"));
  EXPECT_EQ(
      "1:1: Matcher not found: Foo\n"
      "1:4: Error parsing matcher. Found end-of-code while looking for ')'.",
      ParseWithError("Foo("));
  EXPECT_EQ("1:1: End of code found while looking for token.",
            ParseWithError(""));
  EXPECT_EQ("Input value is not a matcher expression.",
            ParseMatcherWithError("\"A\""));
  EXPECT_EQ("1:1: Matcher not found: Foo\n"
            "1:1: Error parsing argument 1 for matcher Foo.\n"
            "1:5: Invalid token <(> found when looking for a value.",
            ParseWithError("Foo(("));
  EXPECT_EQ("1:7: Expected end of code.", ParseWithError("expr()a"));
  EXPECT_EQ("1:11: Malformed bind() expression.",
            ParseWithError("isArrow().biind"));
  EXPECT_EQ("1:15: Malformed bind() expression.",
            ParseWithError("isArrow().bind"));
  EXPECT_EQ("1:16: Malformed bind() expression.",
            ParseWithError("isArrow().bind(foo"));
  EXPECT_EQ("1:21: Malformed bind() expression.",
            ParseWithError("isArrow().bind(\"foo\""));
  EXPECT_EQ("1:1: Error building matcher isArrow.\n"
            "1:1: Matcher does not support binding.",
            ParseWithError("isArrow().bind(\"foo\")"));
  EXPECT_EQ("Input value has unresolved overloaded type: "
            "Matcher<DoStmt|ForStmt|WhileStmt|CXXForRangeStmt|FunctionDecl>",
            ParseMatcherWithError("hasBody(stmt())"));
  EXPECT_EQ(
      "1:1: Error parsing argument 1 for matcher decl.\n"
      "1:6: Error building matcher hasAttr.\n"
      "1:14: Unknown value 'attr::Fnal' for arg 1; did you mean 'attr::Final'",
      ParseMatcherWithError(R"query(decl(hasAttr("attr::Fnal")))query"));
  EXPECT_EQ("1:1: Error parsing argument 1 for matcher decl.\n"
            "1:6: Error building matcher hasAttr.\n"
            "1:14: Unknown value 'Final' for arg 1; did you mean 'attr::Final'",
            ParseMatcherWithError(R"query(decl(hasAttr("Final")))query"));
  EXPECT_EQ("1:1: Error parsing argument 1 for matcher decl.\n"
            "1:6: Error building matcher hasAttr.\n"
            "1:14: Value not found: unrelated",
            ParseMatcherWithError(R"query(decl(hasAttr("unrelated")))query"));
  EXPECT_EQ(
      "1:1: Error parsing argument 1 for matcher namedDecl.\n"
      "1:11: Error building matcher matchesName.\n"
      "1:33: Unknown value 'Ignorecase' for arg 2; did you mean 'IgnoreCase'",
      ParseMatcherWithError(
          R"query(namedDecl(matchesName("[ABC]*", "Ignorecase")))query"));
  EXPECT_EQ(
      "1:1: Error parsing argument 1 for matcher namedDecl.\n"
      "1:11: Error building matcher matchesName.\n"
      "1:33: Value not found: IgnoreCase & BasicRegex",
      ParseMatcherWithError(
          R"query(namedDecl(matchesName("[ABC]*", "IgnoreCase & BasicRegex")))query"));
  EXPECT_EQ(
      "1:1: Error parsing argument 1 for matcher namedDecl.\n"
      "1:11: Error building matcher matchesName.\n"
      "1:33: Unknown value 'IgnoreCase | Basicregex' for arg 2; did you mean "
      "'IgnoreCase | BasicRegex'",
      ParseMatcherWithError(
          R"query(namedDecl(matchesName("[ABC]*", "IgnoreCase | Basicregex")))query"));
}

TEST(ParserTest, OverloadErrors) {
  EXPECT_EQ("1:1: Error building matcher callee.\n"
            "1:8: Candidate 1: Incorrect type for arg 1. "
            "(Expected = Matcher<Stmt>) != (Actual = String)\n"
            "1:8: Candidate 2: Incorrect type for arg 1. "
            "(Expected = Matcher<Decl>) != (Actual = String)",
            ParseWithError("callee(\"A\")"));
}

TEST(ParserTest, ParseMultiline) {
  StringRef Code;

  llvm::Optional<DynTypedMatcher> M;
  {
    Code = R"matcher(varDecl(
  hasName("foo")
  )
)matcher";
    Diagnostics Error;
    EXPECT_TRUE(Parser::parseMatcherExpression(Code, &Error).hasValue());
  }

  {
    Code = R"matcher(varDecl(
  # Internal comment
  hasName("foo") # Internal comment
# Internal comment
  )
)matcher";
    Diagnostics Error;
    EXPECT_TRUE(Parser::parseMatcherExpression(Code, &Error).hasValue());
  }

  {
    Code = R"matcher(decl().bind(
  "paramName")
)matcher";
    Diagnostics Error;
    EXPECT_TRUE(Parser::parseMatcherExpression(Code, &Error).hasValue());
  }

  {
    Code = R"matcher(decl().bind(
  "paramName"
  )
)matcher";
    Diagnostics Error;
    EXPECT_TRUE(Parser::parseMatcherExpression(Code, &Error).hasValue());
  }

  {
    Code = R"matcher(decl(decl()
, decl()))matcher";
    Diagnostics Error;
    EXPECT_TRUE(Parser::parseMatcherExpression(Code, &Error).hasValue());
  }

  {
    Code = R"matcher(decl(decl(),
decl()))matcher";
    Diagnostics Error;
    EXPECT_TRUE(Parser::parseMatcherExpression(Code, &Error).hasValue());
  }

  {
    Code = "namedDecl(hasName(\"n\"\n))";
    Diagnostics Error;
    EXPECT_TRUE(Parser::parseMatcherExpression(Code, &Error).hasValue());
  }

  {
    Diagnostics Error;

    auto NamedValues = getTestNamedValues();

    Code = R"matcher(hasParamA.bind
  ("paramName")
)matcher";
    M = Parser::parseMatcherExpression(Code, nullptr, &NamedValues, &Error);
    EXPECT_FALSE(M.hasValue());
    EXPECT_EQ("1:15: Malformed bind() expression.", Error.toStringFull());
  }

  {
    Diagnostics Error;

    auto NamedValues = getTestNamedValues();

    Code = R"matcher(hasParamA.
  bind("paramName")
)matcher";
    M = Parser::parseMatcherExpression(Code, nullptr, &NamedValues, &Error);
    EXPECT_FALSE(M.hasValue());
    EXPECT_EQ("1:11: Malformed bind() expression.", Error.toStringFull());
  }

  {
    Diagnostics Error;

    Code = R"matcher(varDecl
()
)matcher";
    M = Parser::parseMatcherExpression(Code, nullptr, nullptr, &Error);
    EXPECT_FALSE(M.hasValue());
    EXPECT_EQ("1:8: Error parsing matcher. Found token "
              "<NewLine> while looking for '('.",
              Error.toStringFull());
  }

  // Correct line/column numbers
  {
    Diagnostics Error;

    Code = R"matcher(varDecl(
  doesNotExist()
  )
)matcher";
    M = Parser::parseMatcherExpression(Code, nullptr, nullptr, &Error);
    EXPECT_FALSE(M.hasValue());
    StringRef Expected = R"error(1:1: Error parsing argument 1 for matcher varDecl.
2:3: Matcher not found: doesNotExist)error";
    EXPECT_EQ(Expected, Error.toStringFull());
  }
}

TEST(ParserTest, CompletionRegistry) {
  StringRef Code = "while";
  std::vector<MatcherCompletion> Comps = Parser::completeExpression(Code, 5);
  ASSERT_EQ(1u, Comps.size());
  EXPECT_EQ("Stmt(", Comps[0].TypedText);
  EXPECT_EQ("Matcher<Stmt> whileStmt(Matcher<WhileStmt>...)",
            Comps[0].MatcherDecl);

  Code = "whileStmt().";
  Comps = Parser::completeExpression(Code, 12);
  ASSERT_EQ(1u, Comps.size());
  EXPECT_EQ("bind(\"", Comps[0].TypedText);
  EXPECT_EQ("bind", Comps[0].MatcherDecl);
}

TEST(ParserTest, CompletionNamedValues) {
  // Can complete non-matcher types.
  auto NamedValues = getTestNamedValues();
  StringRef Code = "functionDecl(hasName(";
  std::vector<MatcherCompletion> Comps =
      Parser::completeExpression(Code, Code.size(), nullptr, &NamedValues);
  ASSERT_EQ(1u, Comps.size());
  EXPECT_EQ("nameX", Comps[0].TypedText);
  EXPECT_EQ("String nameX", Comps[0].MatcherDecl);

  // Can complete if there are names in the expression.
  Code = "cxxMethodDecl(hasName(nameX), ";
  Comps = Parser::completeExpression(Code, Code.size(), nullptr, &NamedValues);
  EXPECT_LT(0u, Comps.size());

  // Can complete names and registry together.
  Code = "functionDecl(hasP";
  Comps = Parser::completeExpression(Code, Code.size(), nullptr, &NamedValues);
  ASSERT_EQ(3u, Comps.size());

  EXPECT_EQ("arameter(", Comps[0].TypedText);
  EXPECT_EQ(
      "Matcher<FunctionDecl> hasParameter(unsigned, Matcher<ParmVarDecl>)",
      Comps[0].MatcherDecl);

  EXPECT_EQ("aramA", Comps[1].TypedText);
  EXPECT_EQ("Matcher<Decl> hasParamA", Comps[1].MatcherDecl);

  EXPECT_EQ("arent(", Comps[2].TypedText);
  EXPECT_EQ(
      "Matcher<Decl> "
      "hasParent(Matcher<NestedNameSpecifierLoc|TypeLoc|Decl|...>)",
      Comps[2].MatcherDecl);
}

TEST(ParserTest, ParseBindOnLet) {

  auto NamedValues = getTestNamedValues();

  Diagnostics Error;

  {
    StringRef Code = "hasParamA.bind(\"parmABinding\")";
    llvm::Optional<DynTypedMatcher> TopLevelLetBinding(
        Parser::parseMatcherExpression(Code, nullptr, &NamedValues, &Error));
    EXPECT_EQ("", Error.toStringFull());
    auto M = TopLevelLetBinding->unconditionalConvertTo<Decl>();

    EXPECT_TRUE(matchAndVerifyResultTrue(
        "void foo(int a);", M,
        std::make_unique<VerifyIdIsBoundTo<FunctionDecl>>("parmABinding")));
    EXPECT_TRUE(matchAndVerifyResultFalse(
        "void foo(int b);", M,
        std::make_unique<VerifyIdIsBoundTo<FunctionDecl>>("parmABinding")));
  }

  {
    StringRef Code = "functionDecl(hasParamA.bind(\"parmABinding\"))";
    llvm::Optional<DynTypedMatcher> NestedLetBinding(
        Parser::parseMatcherExpression(Code, nullptr, &NamedValues, &Error));
    EXPECT_EQ("", Error.toStringFull());
    auto M = NestedLetBinding->unconditionalConvertTo<Decl>();

    EXPECT_TRUE(matchAndVerifyResultTrue(
        "void foo(int a);", M,
        std::make_unique<VerifyIdIsBoundTo<FunctionDecl>>("parmABinding")));
    EXPECT_TRUE(matchAndVerifyResultFalse(
        "void foo(int b);", M,
        std::make_unique<VerifyIdIsBoundTo<FunctionDecl>>("parmABinding")));
  }
}

}  // end anonymous namespace
}  // end namespace dynamic
}  // end namespace ast_matchers
}  // end namespace clang