Home | History | Annotate | Download | only in Dynamic 
      1 //===- unittest/ASTMatchers/Dynamic/ParserTest.cpp - Parser unit tests -===//
      2 //
      3 //                     The LLVM Compiler Infrastructure
      4 //
      5 // This file is distributed under the University of Illinois Open Source
      6 // License. See LICENSE.TXT for details.
      7 //
      8 //===-------------------------------------------------------------------===//
      9 
     10 #include "../ASTMatchersTest.h"
     11 #include "clang/ASTMatchers/Dynamic/Parser.h"
     12 #include "clang/ASTMatchers/Dynamic/Registry.h"
     13 #include "llvm/ADT/Optional.h"
     14 #include "llvm/ADT/StringMap.h"
     15 #include "gtest/gtest.h"
     16 #include <string>
     17 #include <vector>
     18 
     19 namespace clang {
     20 namespace ast_matchers {
     21 namespace dynamic {
     22 namespace {
     23 
     24 class MockSema : public Parser::Sema {
     25 public:
     26   ~MockSema() override {}
     27 
     28   uint64_t expectMatcher(StringRef MatcherName) {
     29     // Optimizations on the matcher framework make simple matchers like
     30     // 'stmt()' to be all the same matcher.
     31     // Use a more complex expression to prevent that.
     32     ast_matchers::internal::Matcher<Stmt> M = stmt(stmt(), stmt());
     33     ExpectedMatchers.insert(std::make_pair(MatcherName, M));
     34     return M.getID().second;
     35   }
     36 
     37   void parse(StringRef Code) {
     38     Diagnostics Error;
     39     VariantValue Value;
     40     Parser::parseExpression(Code, this, &Value, &Error);
     41     Values.push_back(Value);
     42     Errors.push_back(Error.toStringFull());
     43   }
     44 
     45   llvm::Optional<MatcherCtor>
     46   lookupMatcherCtor(StringRef MatcherName) override {
     47     const ExpectedMatchersTy::value_type *Matcher =
     48         &*ExpectedMatchers.find(MatcherName);
     49     return reinterpret_cast<MatcherCtor>(Matcher);
     50   }
     51 
     52   VariantMatcher actOnMatcherExpression(MatcherCtor Ctor,
     53                                         SourceRange NameRange,
     54                                         StringRef BindID,
     55                                         ArrayRef<ParserValue> Args,
     56                                         Diagnostics *Error) override {
     57     const ExpectedMatchersTy::value_type *Matcher =
     58         reinterpret_cast<const ExpectedMatchersTy::value_type *>(Ctor);
     59     MatcherInfo ToStore = { Matcher->first, NameRange, Args, BindID };
     60     Matchers.push_back(ToStore);
     61     return VariantMatcher::SingleMatcher(Matcher->second);
     62   }
     63 
     64   struct MatcherInfo {
     65     StringRef MatcherName;
     66     SourceRange NameRange;
     67     std::vector<ParserValue> Args;
     68     std::string BoundID;
     69   };
     70 
     71   std::vector<std::string> Errors;
     72   std::vector<VariantValue> Values;
     73   std::vector<MatcherInfo> Matchers;
     74   typedef std::map<std::string, ast_matchers::internal::Matcher<Stmt> >
     75   ExpectedMatchersTy;
     76   ExpectedMatchersTy ExpectedMatchers;
     77 };
     78 
     79 TEST(ParserTest, ParseUnsigned) {
     80   MockSema Sema;
     81   Sema.parse("0");
     82   Sema.parse("123");
     83   Sema.parse("0x1f");
     84   Sema.parse("12345678901");
     85   Sema.parse("1a1");
     86   EXPECT_EQ(5U, Sema.Values.size());
     87   EXPECT_EQ(0U, Sema.Values[0].getUnsigned());
     88   EXPECT_EQ(123U, Sema.Values[1].getUnsigned());
     89   EXPECT_EQ(31U, Sema.Values[2].getUnsigned());
     90   EXPECT_EQ("1:1: Error parsing unsigned token: <12345678901>", Sema.Errors[3]);
     91   EXPECT_EQ("1:1: Error parsing unsigned token: <1a1>", Sema.Errors[4]);
     92 }
     93 
     94 TEST(ParserTest, ParseString) {
     95   MockSema Sema;
     96   Sema.parse("\"Foo\"");
     97   Sema.parse("\"\"");
     98   Sema.parse("\"Baz");
     99   EXPECT_EQ(3ULL, Sema.Values.size());
    100   EXPECT_EQ("Foo", Sema.Values[0].getString());
    101   EXPECT_EQ("", Sema.Values[1].getString());
    102   EXPECT_EQ("1:1: Error parsing string token: <\"Baz>", Sema.Errors[2]);
    103 }
    104 
    105 bool matchesRange(SourceRange Range, unsigned StartLine,
    106                   unsigned EndLine, unsigned StartColumn, unsigned EndColumn) {
    107   EXPECT_EQ(StartLine, Range.Start.Line);
    108   EXPECT_EQ(EndLine, Range.End.Line);
    109   EXPECT_EQ(StartColumn, Range.Start.Column);
    110   EXPECT_EQ(EndColumn, Range.End.Column);
    111   return Range.Start.Line == StartLine && Range.End.Line == EndLine &&
    112          Range.Start.Column == StartColumn && Range.End.Column == EndColumn;
    113 }
    114 
    115 llvm::Optional<DynTypedMatcher> getSingleMatcher(const VariantValue &Value) {
    116   llvm::Optional<DynTypedMatcher> Result =
    117       Value.getMatcher().getSingleMatcher();
    118   EXPECT_TRUE(Result.hasValue());
    119   return Result;
    120 }
    121 
    122 TEST(ParserTest, ParseMatcher) {
    123   MockSema Sema;
    124   const uint64_t ExpectedFoo = Sema.expectMatcher("Foo");
    125   const uint64_t ExpectedBar = Sema.expectMatcher("Bar");
    126   const uint64_t ExpectedBaz = Sema.expectMatcher("Baz");
    127   Sema.parse(" Foo ( Bar ( 17), Baz( \n \"B A,Z\") ) .bind( \"Yo!\") ");
    128   for (size_t i = 0, e = Sema.Errors.size(); i != e; ++i) {
    129     EXPECT_EQ("", Sema.Errors[i]);
    130   }
    131 
    132   EXPECT_NE(ExpectedFoo, ExpectedBar);
    133   EXPECT_NE(ExpectedFoo, ExpectedBaz);
    134   EXPECT_NE(ExpectedBar, ExpectedBaz);
    135 
    136   EXPECT_EQ(1ULL, Sema.Values.size());
    137   EXPECT_EQ(ExpectedFoo, getSingleMatcher(Sema.Values[0])->getID().second);
    138 
    139   EXPECT_EQ(3ULL, Sema.Matchers.size());
    140   const MockSema::MatcherInfo Bar = Sema.Matchers[0];
    141   EXPECT_EQ("Bar", Bar.MatcherName);
    142   EXPECT_TRUE(matchesRange(Bar.NameRange, 1, 1, 8, 17));
    143   EXPECT_EQ(1ULL, Bar.Args.size());
    144   EXPECT_EQ(17U, Bar.Args[0].Value.getUnsigned());
    145 
    146   const MockSema::MatcherInfo Baz = Sema.Matchers[1];
    147   EXPECT_EQ("Baz", Baz.MatcherName);
    148   EXPECT_TRUE(matchesRange(Baz.NameRange, 1, 2, 19, 10));
    149   EXPECT_EQ(1ULL, Baz.Args.size());
    150   EXPECT_EQ("B A,Z", Baz.Args[0].Value.getString());
    151 
    152   const MockSema::MatcherInfo Foo = Sema.Matchers[2];
    153   EXPECT_EQ("Foo", Foo.MatcherName);
    154   EXPECT_TRUE(matchesRange(Foo.NameRange, 1, 2, 2, 12));
    155   EXPECT_EQ(2ULL, Foo.Args.size());
    156   EXPECT_EQ(ExpectedBar, getSingleMatcher(Foo.Args[0].Value)->getID().second);
    157   EXPECT_EQ(ExpectedBaz, getSingleMatcher(Foo.Args[1].Value)->getID().second);
    158   EXPECT_EQ("Yo!", Foo.BoundID);
    159 }
    160 
    161 using ast_matchers::internal::Matcher;
    162 
    163 Parser::NamedValueMap getTestNamedValues() {
    164   Parser::NamedValueMap Values;
    165   Values["nameX"] = llvm::StringRef("x");
    166   Values["hasParamA"] =
    167       VariantMatcher::SingleMatcher(hasParameter(0, hasName("a")));
    168   return Values;
    169 }
    170 
    171 TEST(ParserTest, FullParserTest) {
    172   Diagnostics Error;
    173   llvm::Optional<DynTypedMatcher> VarDecl(Parser::parseMatcherExpression(
    174       "varDecl(hasInitializer(binaryOperator(hasLHS(integerLiteral()),"
    175       "                                      hasOperatorName(\"+\"))))",
    176       &Error));
    177   EXPECT_EQ("", Error.toStringFull());
    178   Matcher<Decl> M = VarDecl->unconditionalConvertTo<Decl>();
    179   EXPECT_TRUE(matches("int x = 1 + false;", M));
    180   EXPECT_FALSE(matches("int x = true + 1;", M));
    181   EXPECT_FALSE(matches("int x = 1 - false;", M));
    182   EXPECT_FALSE(matches("int x = true - 1;", M));
    183 
    184   llvm::Optional<DynTypedMatcher> HasParameter(Parser::parseMatcherExpression(
    185       "functionDecl(hasParameter(1, hasName(\"x\")))", &Error));
    186   EXPECT_EQ("", Error.toStringFull());
    187   M = HasParameter->unconditionalConvertTo<Decl>();
    188 
    189   EXPECT_TRUE(matches("void f(int a, int x);", M));
    190   EXPECT_FALSE(matches("void f(int x, int a);", M));
    191 
    192   // Test named values.
    193   auto NamedValues = getTestNamedValues();
    194   llvm::Optional<DynTypedMatcher> HasParameterWithNamedValues(
    195       Parser::parseMatcherExpression(
    196           "functionDecl(hasParamA, hasParameter(1, hasName(nameX)))",
    197           nullptr, &NamedValues, &Error));
    198   EXPECT_EQ("", Error.toStringFull());
    199   M = HasParameterWithNamedValues->unconditionalConvertTo<Decl>();
    200 
    201   EXPECT_TRUE(matches("void f(int a, int x);", M));
    202   EXPECT_FALSE(matches("void f(int x, int a);", M));
    203 
    204 
    205   EXPECT_TRUE(!Parser::parseMatcherExpression(
    206                    "hasInitializer(\n    binaryOperator(hasLHS(\"A\")))",
    207                    &Error).hasValue());
    208   EXPECT_EQ("1:1: Error parsing argument 1 for matcher hasInitializer.\n"
    209             "2:5: Error parsing argument 1 for matcher binaryOperator.\n"
    210             "2:20: Error building matcher hasLHS.\n"
    211             "2:27: Incorrect type for arg 1. "
    212             "(Expected = Matcher<Expr>) != (Actual = String)",
    213             Error.toStringFull());
    214 }
    215 
    216 std::string ParseWithError(StringRef Code) {
    217   Diagnostics Error;
    218   VariantValue Value;
    219   Parser::parseExpression(Code, &Value, &Error);
    220   return Error.toStringFull();
    221 }
    222 
    223 std::string ParseMatcherWithError(StringRef Code) {
    224   Diagnostics Error;
    225   Parser::parseMatcherExpression(Code, &Error);
    226   return Error.toStringFull();
    227 }
    228 
    229 TEST(ParserTest, Errors) {
    230   EXPECT_EQ(
    231       "1:5: Error parsing matcher. Found token <123> while looking for '('.",
    232       ParseWithError("Foo 123"));
    233   EXPECT_EQ(
    234       "1:1: Matcher not found: Foo\n"
    235       "1:9: Error parsing matcher. Found token <123> while looking for ','.",
    236       ParseWithError("Foo(\"A\" 123)"));
    237   EXPECT_EQ(
    238       "1:1: Error parsing argument 1 for matcher stmt.\n"
    239       "1:6: Value not found: someValue",
    240       ParseWithError("stmt(someValue)"));
    241   EXPECT_EQ(
    242       "1:1: Matcher not found: Foo\n"
    243       "1:4: Error parsing matcher. Found end-of-code while looking for ')'.",
    244       ParseWithError("Foo("));
    245   EXPECT_EQ("1:1: End of code found while looking for token.",
    246             ParseWithError(""));
    247   EXPECT_EQ("Input value is not a matcher expression.",
    248             ParseMatcherWithError("\"A\""));
    249   EXPECT_EQ("1:1: Matcher not found: Foo\n"
    250             "1:1: Error parsing argument 1 for matcher Foo.\n"
    251             "1:5: Invalid token <(> found when looking for a value.",
    252             ParseWithError("Foo(("));
    253   EXPECT_EQ("1:7: Expected end of code.", ParseWithError("expr()a"));
    254   EXPECT_EQ("1:11: Malformed bind() expression.",
    255             ParseWithError("isArrow().biind"));
    256   EXPECT_EQ("1:15: Malformed bind() expression.",
    257             ParseWithError("isArrow().bind"));
    258   EXPECT_EQ("1:16: Malformed bind() expression.",
    259             ParseWithError("isArrow().bind(foo"));
    260   EXPECT_EQ("1:21: Malformed bind() expression.",
    261             ParseWithError("isArrow().bind(\"foo\""));
    262   EXPECT_EQ("1:1: Error building matcher isArrow.\n"
    263             "1:1: Matcher does not support binding.",
    264             ParseWithError("isArrow().bind(\"foo\")"));
    265   EXPECT_EQ("Input value has unresolved overloaded type: "
    266             "Matcher<DoStmt|ForStmt|WhileStmt|CXXForRangeStmt|FunctionDecl>",
    267             ParseMatcherWithError("hasBody(stmt())"));
    268 }
    269 
    270 TEST(ParserTest, OverloadErrors) {
    271   EXPECT_EQ("1:1: Error building matcher callee.\n"
    272             "1:8: Candidate 1: Incorrect type for arg 1. "
    273             "(Expected = Matcher<Stmt>) != (Actual = String)\n"
    274             "1:8: Candidate 2: Incorrect type for arg 1. "
    275             "(Expected = Matcher<Decl>) != (Actual = String)",
    276             ParseWithError("callee(\"A\")"));
    277 }
    278 
    279 TEST(ParserTest, CompletionRegistry) {
    280   std::vector<MatcherCompletion> Comps =
    281       Parser::completeExpression("while", 5);
    282   ASSERT_EQ(1u, Comps.size());
    283   EXPECT_EQ("Stmt(", Comps[0].TypedText);
    284   EXPECT_EQ("Matcher<Stmt> whileStmt(Matcher<WhileStmt>...)",
    285             Comps[0].MatcherDecl);
    286 
    287   Comps = Parser::completeExpression("whileStmt().", 12);
    288   ASSERT_EQ(1u, Comps.size());
    289   EXPECT_EQ("bind(\"", Comps[0].TypedText);
    290   EXPECT_EQ("bind", Comps[0].MatcherDecl);
    291 }
    292 
    293 TEST(ParserTest, CompletionNamedValues) {
    294   // Can complete non-matcher types.
    295   auto NamedValues = getTestNamedValues();
    296   StringRef Code = "functionDecl(hasName(";
    297   std::vector<MatcherCompletion> Comps =
    298       Parser::completeExpression(Code, Code.size(), nullptr, &NamedValues);
    299   ASSERT_EQ(1u, Comps.size());
    300   EXPECT_EQ("nameX", Comps[0].TypedText);
    301   EXPECT_EQ("String nameX", Comps[0].MatcherDecl);
    302 
    303   // Can complete if there are names in the expression.
    304   Code = "cxxMethodDecl(hasName(nameX), ";
    305   Comps = Parser::completeExpression(Code, Code.size(), nullptr, &NamedValues);
    306   EXPECT_LT(0u, Comps.size());
    307 
    308   // Can complete names and registry together.
    309   Code = "cxxMethodDecl(hasP";
    310   Comps = Parser::completeExpression(Code, Code.size(), nullptr, &NamedValues);
    311   ASSERT_EQ(3u, Comps.size());
    312   EXPECT_EQ("aramA", Comps[0].TypedText);
    313   EXPECT_EQ("Matcher<FunctionDecl> hasParamA", Comps[0].MatcherDecl);
    314 
    315   EXPECT_EQ("arameter(", Comps[1].TypedText);
    316   EXPECT_EQ(
    317       "Matcher<FunctionDecl> hasParameter(unsigned, Matcher<ParmVarDecl>)",
    318       Comps[1].MatcherDecl);
    319 
    320   EXPECT_EQ("arent(", Comps[2].TypedText);
    321   EXPECT_EQ(
    322       "Matcher<Decl> "
    323       "hasParent(Matcher<NestedNameSpecifierLoc|TypeLoc|Decl|...>)",
    324       Comps[2].MatcherDecl);
    325 }
    326 
    327 }  // end anonymous namespace
    328 }  // end namespace dynamic
    329 }  // end namespace ast_matchers
    330 }  // end namespace clang
    331