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
19namespace clang {
20namespace ast_matchers {
21namespace dynamic {
22namespace {
23
24class MockSema : public Parser::Sema {
25public:
26  virtual ~MockSema() {}
27
28  uint64_t expectMatcher(StringRef MatcherName) {
29    ast_matchers::internal::Matcher<Stmt> M = stmt();
30    ExpectedMatchers.insert(std::make_pair(MatcherName, M));
31    return M.getID();
32  }
33
34  void parse(StringRef Code) {
35    Diagnostics Error;
36    VariantValue Value;
37    Parser::parseExpression(Code, this, &Value, &Error);
38    Values.push_back(Value);
39    Errors.push_back(Error.toStringFull());
40  }
41
42  llvm::Optional<MatcherCtor> lookupMatcherCtor(StringRef MatcherName) {
43    const ExpectedMatchersTy::value_type *Matcher =
44        &*ExpectedMatchers.find(MatcherName);
45    return reinterpret_cast<MatcherCtor>(Matcher);
46  }
47
48  VariantMatcher actOnMatcherExpression(MatcherCtor Ctor,
49                                        const SourceRange &NameRange,
50                                        StringRef BindID,
51                                        ArrayRef<ParserValue> Args,
52                                        Diagnostics *Error) {
53    const ExpectedMatchersTy::value_type *Matcher =
54        reinterpret_cast<const ExpectedMatchersTy::value_type *>(Ctor);
55    MatcherInfo ToStore = { Matcher->first, NameRange, Args, BindID };
56    Matchers.push_back(ToStore);
57    return VariantMatcher::SingleMatcher(Matcher->second);
58  }
59
60  struct MatcherInfo {
61    StringRef MatcherName;
62    SourceRange NameRange;
63    std::vector<ParserValue> Args;
64    std::string BoundID;
65  };
66
67  std::vector<std::string> Errors;
68  std::vector<VariantValue> Values;
69  std::vector<MatcherInfo> Matchers;
70  typedef std::map<std::string, ast_matchers::internal::Matcher<Stmt> >
71  ExpectedMatchersTy;
72  ExpectedMatchersTy ExpectedMatchers;
73};
74
75TEST(ParserTest, ParseUnsigned) {
76  MockSema Sema;
77  Sema.parse("0");
78  Sema.parse("123");
79  Sema.parse("0x1f");
80  Sema.parse("12345678901");
81  Sema.parse("1a1");
82  EXPECT_EQ(5U, Sema.Values.size());
83  EXPECT_EQ(0U, Sema.Values[0].getUnsigned());
84  EXPECT_EQ(123U, Sema.Values[1].getUnsigned());
85  EXPECT_EQ(31U, Sema.Values[2].getUnsigned());
86  EXPECT_EQ("1:1: Error parsing unsigned token: <12345678901>", Sema.Errors[3]);
87  EXPECT_EQ("1:1: Error parsing unsigned token: <1a1>", Sema.Errors[4]);
88}
89
90TEST(ParserTest, ParseString) {
91  MockSema Sema;
92  Sema.parse("\"Foo\"");
93  Sema.parse("\"\"");
94  Sema.parse("\"Baz");
95  EXPECT_EQ(3ULL, Sema.Values.size());
96  EXPECT_EQ("Foo", Sema.Values[0].getString());
97  EXPECT_EQ("", Sema.Values[1].getString());
98  EXPECT_EQ("1:1: Error parsing string token: <\"Baz>", Sema.Errors[2]);
99}
100
101bool matchesRange(const SourceRange &Range, unsigned StartLine,
102                  unsigned EndLine, unsigned StartColumn, unsigned EndColumn) {
103  EXPECT_EQ(StartLine, Range.Start.Line);
104  EXPECT_EQ(EndLine, Range.End.Line);
105  EXPECT_EQ(StartColumn, Range.Start.Column);
106  EXPECT_EQ(EndColumn, Range.End.Column);
107  return Range.Start.Line == StartLine && Range.End.Line == EndLine &&
108         Range.Start.Column == StartColumn && Range.End.Column == EndColumn;
109}
110
111llvm::Optional<DynTypedMatcher> getSingleMatcher(const VariantValue &Value) {
112  llvm::Optional<DynTypedMatcher> Result =
113      Value.getMatcher().getSingleMatcher();
114  EXPECT_TRUE(Result.hasValue());
115  return Result;
116}
117
118TEST(ParserTest, ParseMatcher) {
119  MockSema Sema;
120  const uint64_t ExpectedFoo = Sema.expectMatcher("Foo");
121  const uint64_t ExpectedBar = Sema.expectMatcher("Bar");
122  const uint64_t ExpectedBaz = Sema.expectMatcher("Baz");
123  Sema.parse(" Foo ( Bar ( 17), Baz( \n \"B A,Z\") ) .bind( \"Yo!\") ");
124  for (size_t i = 0, e = Sema.Errors.size(); i != e; ++i) {
125    EXPECT_EQ("", Sema.Errors[i]);
126  }
127
128  EXPECT_EQ(1ULL, Sema.Values.size());
129  EXPECT_EQ(ExpectedFoo, getSingleMatcher(Sema.Values[0])->getID());
130
131  EXPECT_EQ(3ULL, Sema.Matchers.size());
132  const MockSema::MatcherInfo Bar = Sema.Matchers[0];
133  EXPECT_EQ("Bar", Bar.MatcherName);
134  EXPECT_TRUE(matchesRange(Bar.NameRange, 1, 1, 8, 17));
135  EXPECT_EQ(1ULL, Bar.Args.size());
136  EXPECT_EQ(17U, Bar.Args[0].Value.getUnsigned());
137
138  const MockSema::MatcherInfo Baz = Sema.Matchers[1];
139  EXPECT_EQ("Baz", Baz.MatcherName);
140  EXPECT_TRUE(matchesRange(Baz.NameRange, 1, 2, 19, 10));
141  EXPECT_EQ(1ULL, Baz.Args.size());
142  EXPECT_EQ("B A,Z", Baz.Args[0].Value.getString());
143
144  const MockSema::MatcherInfo Foo = Sema.Matchers[2];
145  EXPECT_EQ("Foo", Foo.MatcherName);
146  EXPECT_TRUE(matchesRange(Foo.NameRange, 1, 2, 2, 12));
147  EXPECT_EQ(2ULL, Foo.Args.size());
148  EXPECT_EQ(ExpectedBar, getSingleMatcher(Foo.Args[0].Value)->getID());
149  EXPECT_EQ(ExpectedBaz, getSingleMatcher(Foo.Args[1].Value)->getID());
150  EXPECT_EQ("Yo!", Foo.BoundID);
151}
152
153using ast_matchers::internal::Matcher;
154
155TEST(ParserTest, FullParserTest) {
156  Diagnostics Error;
157  llvm::Optional<DynTypedMatcher> VarDecl(Parser::parseMatcherExpression(
158      "varDecl(hasInitializer(binaryOperator(hasLHS(integerLiteral()),"
159      "                                      hasOperatorName(\"+\"))))",
160      &Error));
161  EXPECT_EQ("", Error.toStringFull());
162  Matcher<Decl> M = VarDecl->unconditionalConvertTo<Decl>();
163  EXPECT_TRUE(matches("int x = 1 + false;", M));
164  EXPECT_FALSE(matches("int x = true + 1;", M));
165  EXPECT_FALSE(matches("int x = 1 - false;", M));
166  EXPECT_FALSE(matches("int x = true - 1;", M));
167
168  llvm::Optional<DynTypedMatcher> HasParameter(Parser::parseMatcherExpression(
169      "functionDecl(hasParameter(1, hasName(\"x\")))", &Error));
170  EXPECT_EQ("", Error.toStringFull());
171  M = HasParameter->unconditionalConvertTo<Decl>();
172
173  EXPECT_TRUE(matches("void f(int a, int x);", M));
174  EXPECT_FALSE(matches("void f(int x, int a);", M));
175
176  // Test named values.
177  struct NamedSema : public Parser::RegistrySema {
178   public:
179    virtual VariantValue getNamedValue(StringRef Name) {
180      if (Name == "nameX")
181        return std::string("x");
182      if (Name == "param0")
183        return VariantMatcher::SingleMatcher(hasParameter(0, hasName("a")));
184      return VariantValue();
185    }
186  };
187  NamedSema Sema;
188  llvm::Optional<DynTypedMatcher> HasParameterWithNamedValues(
189      Parser::parseMatcherExpression(
190          "functionDecl(param0, hasParameter(1, hasName(nameX)))", &Sema,
191          &Error));
192  EXPECT_EQ("", Error.toStringFull());
193  M = HasParameterWithNamedValues->unconditionalConvertTo<Decl>();
194
195  EXPECT_TRUE(matches("void f(int a, int x);", M));
196  EXPECT_FALSE(matches("void f(int x, int a);", M));
197
198
199  EXPECT_TRUE(!Parser::parseMatcherExpression(
200                   "hasInitializer(\n    binaryOperator(hasLHS(\"A\")))",
201                   &Error).hasValue());
202  EXPECT_EQ("1:1: Error parsing argument 1 for matcher hasInitializer.\n"
203            "2:5: Error parsing argument 1 for matcher binaryOperator.\n"
204            "2:20: Error building matcher hasLHS.\n"
205            "2:27: Incorrect type for arg 1. "
206            "(Expected = Matcher<Expr>) != (Actual = String)",
207            Error.toStringFull());
208}
209
210std::string ParseWithError(StringRef Code) {
211  Diagnostics Error;
212  VariantValue Value;
213  Parser::parseExpression(Code, &Value, &Error);
214  return Error.toStringFull();
215}
216
217std::string ParseMatcherWithError(StringRef Code) {
218  Diagnostics Error;
219  Parser::parseMatcherExpression(Code, &Error);
220  return Error.toStringFull();
221}
222
223TEST(ParserTest, Errors) {
224  EXPECT_EQ(
225      "1:5: Error parsing matcher. Found token <123> while looking for '('.",
226      ParseWithError("Foo 123"));
227  EXPECT_EQ(
228      "1:1: Matcher not found: Foo\n"
229      "1:9: Error parsing matcher. Found token <123> while looking for ','.",
230      ParseWithError("Foo(\"A\" 123)"));
231  EXPECT_EQ(
232      "1:1: Error parsing argument 1 for matcher stmt.\n"
233      "1:6: Value not found: someValue",
234      ParseWithError("stmt(someValue)"));
235  EXPECT_EQ(
236      "1:1: Matcher not found: Foo\n"
237      "1:4: Error parsing matcher. Found end-of-code while looking for ')'.",
238      ParseWithError("Foo("));
239  EXPECT_EQ("1:1: End of code found while looking for token.",
240            ParseWithError(""));
241  EXPECT_EQ("Input value is not a matcher expression.",
242            ParseMatcherWithError("\"A\""));
243  EXPECT_EQ("1:1: Matcher not found: Foo\n"
244            "1:1: Error parsing argument 1 for matcher Foo.\n"
245            "1:5: Invalid token <(> found when looking for a value.",
246            ParseWithError("Foo(("));
247  EXPECT_EQ("1:7: Expected end of code.", ParseWithError("expr()a"));
248  EXPECT_EQ("1:11: Malformed bind() expression.",
249            ParseWithError("isArrow().biind"));
250  EXPECT_EQ("1:15: Malformed bind() expression.",
251            ParseWithError("isArrow().bind"));
252  EXPECT_EQ("1:16: Malformed bind() expression.",
253            ParseWithError("isArrow().bind(foo"));
254  EXPECT_EQ("1:21: Malformed bind() expression.",
255            ParseWithError("isArrow().bind(\"foo\""));
256  EXPECT_EQ("1:1: Error building matcher isArrow.\n"
257            "1:1: Matcher does not support binding.",
258            ParseWithError("isArrow().bind(\"foo\")"));
259  EXPECT_EQ("Input value has unresolved overloaded type: "
260            "Matcher<DoStmt|ForStmt|WhileStmt|CXXForRangeStmt>",
261            ParseMatcherWithError("hasBody(stmt())"));
262}
263
264TEST(ParserTest, OverloadErrors) {
265  EXPECT_EQ("1:1: Error building matcher callee.\n"
266            "1:8: Candidate 1: Incorrect type for arg 1. "
267            "(Expected = Matcher<Stmt>) != (Actual = String)\n"
268            "1:8: Candidate 2: Incorrect type for arg 1. "
269            "(Expected = Matcher<Decl>) != (Actual = String)",
270            ParseWithError("callee(\"A\")"));
271}
272
273TEST(ParserTest, Completion) {
274  std::vector<MatcherCompletion> Comps =
275      Parser::completeExpression("while", 5);
276  ASSERT_EQ(1u, Comps.size());
277  EXPECT_EQ("Stmt(", Comps[0].TypedText);
278  EXPECT_EQ("Matcher<Stmt> whileStmt(Matcher<WhileStmt>...)",
279            Comps[0].MatcherDecl);
280
281  Comps = Parser::completeExpression("whileStmt().", 12);
282  ASSERT_EQ(1u, Comps.size());
283  EXPECT_EQ("bind(\"", Comps[0].TypedText);
284  EXPECT_EQ("bind", Comps[0].MatcherDecl);
285}
286
287}  // end anonymous namespace
288}  // end namespace dynamic
289}  // end namespace ast_matchers
290}  // end namespace clang
291