1 //===- unittest/ASTMatchers/Dynamic/ParserTest.cpp - Parser unit tests -===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===-------------------------------------------------------------------===//
8 
9 #include "../ASTMatchersTest.h"
10 #include "clang/ASTMatchers/Dynamic/Parser.h"
11 #include "clang/ASTMatchers/Dynamic/Registry.h"
12 #include "llvm/ADT/Optional.h"
13 #include "gtest/gtest.h"
14 #include <string>
15 #include <vector>
16 
17 namespace clang {
18 namespace ast_matchers {
19 namespace dynamic {
20 namespace {
21 
22 class MockSema : public Parser::Sema {
23 public:
24   ~MockSema() override {}
25 
26   uint64_t expectMatcher(StringRef MatcherName) {
27     // Optimizations on the matcher framework make simple matchers like
28     // 'stmt()' to be all the same matcher.
29     // Use a more complex expression to prevent that.
30     ast_matchers::internal::Matcher<Stmt> M = stmt(stmt(), stmt());
31     ExpectedMatchers.insert(std::make_pair(std::string(MatcherName), M));
32     return M.getID().second;
33   }
34 
35   void parse(StringRef Code) {
36     Diagnostics Error;
37     VariantValue Value;
38     Parser::parseExpression(Code, this, &Value, &Error);
39     Values.push_back(Value);
40     Errors.push_back(Error.toStringFull());
41   }
42 
43   llvm::Optional<MatcherCtor>
44   lookupMatcherCtor(StringRef MatcherName) override {
45     const ExpectedMatchersTy::value_type *Matcher =
46         &*ExpectedMatchers.find(std::string(MatcherName));
47     return reinterpret_cast<MatcherCtor>(Matcher);
48   }
49 
50   VariantMatcher actOnMatcherExpression(MatcherCtor Ctor,
51                                         SourceRange NameRange,
52                                         StringRef BindID,
53                                         ArrayRef<ParserValue> Args,
54                                         Diagnostics *Error) override {
55     const ExpectedMatchersTy::value_type *Matcher =
56         reinterpret_cast<const ExpectedMatchersTy::value_type *>(Ctor);
57     MatcherInfo ToStore = {Matcher->first, NameRange, Args,
58                            std::string(BindID)};
59     Matchers.push_back(ToStore);
60     return VariantMatcher::SingleMatcher(Matcher->second);
61   }
62 
63   struct MatcherInfo {
64     StringRef MatcherName;
65     SourceRange NameRange;
66     std::vector<ParserValue> Args;
67     std::string BoundID;
68   };
69 
70   std::vector<std::string> Errors;
71   std::vector<VariantValue> Values;
72   std::vector<MatcherInfo> Matchers;
73   typedef std::map<std::string, ast_matchers::internal::Matcher<Stmt> >
74   ExpectedMatchersTy;
75   ExpectedMatchersTy ExpectedMatchers;
76 };
77 
78 TEST(ParserTest, ParseBoolean) {
79   MockSema Sema;
80   Sema.parse("true");
81   Sema.parse("false");
82   EXPECT_EQ(2U, Sema.Values.size());
83   EXPECT_TRUE(Sema.Values[0].getBoolean());
84   EXPECT_FALSE(Sema.Values[1].getBoolean());
85 }
86 
87 TEST(ParserTest, ParseDouble) {
88   MockSema Sema;
89   Sema.parse("1.0");
90   Sema.parse("2.0f");
91   Sema.parse("34.56e-78");
92   Sema.parse("4.E+6");
93   Sema.parse("1");
94   EXPECT_EQ(5U, Sema.Values.size());
95   EXPECT_EQ(1.0, Sema.Values[0].getDouble());
96   EXPECT_EQ("1:1: Error parsing numeric literal: <2.0f>", Sema.Errors[1]);
97   EXPECT_EQ(34.56e-78, Sema.Values[2].getDouble());
98   EXPECT_EQ(4e+6, Sema.Values[3].getDouble());
99   EXPECT_FALSE(Sema.Values[4].isDouble());
100 }
101 
102 TEST(ParserTest, ParseUnsigned) {
103   MockSema Sema;
104   Sema.parse("0");
105   Sema.parse("123");
106   Sema.parse("0x1f");
107   Sema.parse("12345678901");
108   Sema.parse("1a1");
109   EXPECT_EQ(5U, Sema.Values.size());
110   EXPECT_EQ(0U, Sema.Values[0].getUnsigned());
111   EXPECT_EQ(123U, Sema.Values[1].getUnsigned());
112   EXPECT_EQ(31U, Sema.Values[2].getUnsigned());
113   EXPECT_EQ("1:1: Error parsing numeric literal: <12345678901>", Sema.Errors[3]);
114   EXPECT_EQ("1:1: Error parsing numeric literal: <1a1>", Sema.Errors[4]);
115 }
116 
117 TEST(ParserTest, ParseString) {
118   MockSema Sema;
119   Sema.parse("\"Foo\"");
120   Sema.parse("\"\"");
121   Sema.parse("\"Baz");
122   EXPECT_EQ(3ULL, Sema.Values.size());
123   EXPECT_EQ("Foo", Sema.Values[0].getString());
124   EXPECT_EQ("", Sema.Values[1].getString());
125   EXPECT_EQ("1:1: Error parsing string token: <\"Baz>", Sema.Errors[2]);
126 }
127 
128 bool matchesRange(SourceRange Range, unsigned StartLine,
129                   unsigned EndLine, unsigned StartColumn, unsigned EndColumn) {
130   EXPECT_EQ(StartLine, Range.Start.Line);
131   EXPECT_EQ(EndLine, Range.End.Line);
132   EXPECT_EQ(StartColumn, Range.Start.Column);
133   EXPECT_EQ(EndColumn, Range.End.Column);
134   return Range.Start.Line == StartLine && Range.End.Line == EndLine &&
135          Range.Start.Column == StartColumn && Range.End.Column == EndColumn;
136 }
137 
138 llvm::Optional<DynTypedMatcher> getSingleMatcher(const VariantValue &Value) {
139   llvm::Optional<DynTypedMatcher> Result =
140       Value.getMatcher().getSingleMatcher();
141   EXPECT_TRUE(Result.hasValue());
142   return Result;
143 }
144 
145 TEST(ParserTest, ParseMatcher) {
146   MockSema Sema;
147   const uint64_t ExpectedFoo = Sema.expectMatcher("Foo");
148   const uint64_t ExpectedBar = Sema.expectMatcher("Bar");
149   const uint64_t ExpectedBaz = Sema.expectMatcher("Baz");
150   Sema.parse(" Foo ( Bar ( 17), Baz( \n \"B A,Z\") ) .bind( \"Yo!\") ");
151   for (const auto &E : Sema.Errors) {
152     EXPECT_EQ("", E);
153   }
154 
155   EXPECT_NE(ExpectedFoo, ExpectedBar);
156   EXPECT_NE(ExpectedFoo, ExpectedBaz);
157   EXPECT_NE(ExpectedBar, ExpectedBaz);
158 
159   EXPECT_EQ(1ULL, Sema.Values.size());
160   EXPECT_EQ(ExpectedFoo, getSingleMatcher(Sema.Values[0])->getID().second);
161 
162   EXPECT_EQ(3ULL, Sema.Matchers.size());
163   const MockSema::MatcherInfo Bar = Sema.Matchers[0];
164   EXPECT_EQ("Bar", Bar.MatcherName);
165   EXPECT_TRUE(matchesRange(Bar.NameRange, 1, 1, 8, 17));
166   EXPECT_EQ(1ULL, Bar.Args.size());
167   EXPECT_EQ(17U, Bar.Args[0].Value.getUnsigned());
168 
169   const MockSema::MatcherInfo Baz = Sema.Matchers[1];
170   EXPECT_EQ("Baz", Baz.MatcherName);
171   EXPECT_TRUE(matchesRange(Baz.NameRange, 1, 2, 19, 10));
172   EXPECT_EQ(1ULL, Baz.Args.size());
173   EXPECT_EQ("B A,Z", Baz.Args[0].Value.getString());
174 
175   const MockSema::MatcherInfo Foo = Sema.Matchers[2];
176   EXPECT_EQ("Foo", Foo.MatcherName);
177   EXPECT_TRUE(matchesRange(Foo.NameRange, 1, 2, 2, 12));
178   EXPECT_EQ(2ULL, Foo.Args.size());
179   EXPECT_EQ(ExpectedBar, getSingleMatcher(Foo.Args[0].Value)->getID().second);
180   EXPECT_EQ(ExpectedBaz, getSingleMatcher(Foo.Args[1].Value)->getID().second);
181   EXPECT_EQ("Yo!", Foo.BoundID);
182 }
183 
184 TEST(ParserTest, ParseComment) {
185   MockSema Sema;
186   Sema.expectMatcher("Foo");
187   Sema.parse(" Foo() # Bar() ");
188   for (const auto &E : Sema.Errors) {
189     EXPECT_EQ("", E);
190   }
191 
192   EXPECT_EQ(1ULL, Sema.Matchers.size());
193 
194   Sema.parse("Foo(#) ");
195 
196   EXPECT_EQ("1:4: Error parsing matcher. Found end-of-code while looking for ')'.", Sema.Errors[1]);
197 }
198 
199 using ast_matchers::internal::Matcher;
200 
201 Parser::NamedValueMap getTestNamedValues() {
202   Parser::NamedValueMap Values;
203   Values["nameX"] = llvm::StringRef("x");
204   Values["hasParamA"] = VariantMatcher::SingleMatcher(
205       functionDecl(hasParameter(0, hasName("a"))));
206   return Values;
207 }
208 
209 TEST(ParserTest, FullParserTest) {
210   Diagnostics Error;
211 
212   StringRef Code =
213       "varDecl(hasInitializer(binaryOperator(hasLHS(integerLiteral()),"
214       "                                      hasOperatorName(\"+\"))))";
215   llvm::Optional<DynTypedMatcher> VarDecl(
216       Parser::parseMatcherExpression(Code, &Error));
217   EXPECT_EQ("", Error.toStringFull());
218   Matcher<Decl> M = VarDecl->unconditionalConvertTo<Decl>();
219   EXPECT_TRUE(matches("int x = 1 + false;", M));
220   EXPECT_FALSE(matches("int x = true + 1;", M));
221   EXPECT_FALSE(matches("int x = 1 - false;", M));
222   EXPECT_FALSE(matches("int x = true - 1;", M));
223 
224   Code = "functionDecl(hasParameter(1, hasName(\"x\")))";
225   llvm::Optional<DynTypedMatcher> HasParameter(
226       Parser::parseMatcherExpression(Code, &Error));
227   EXPECT_EQ("", Error.toStringFull());
228   M = HasParameter->unconditionalConvertTo<Decl>();
229 
230   EXPECT_TRUE(matches("void f(int a, int x);", M));
231   EXPECT_FALSE(matches("void f(int x, int a);", M));
232 
233   // Test named values.
234   auto NamedValues = getTestNamedValues();
235 
236   Code = "functionDecl(hasParamA, hasParameter(1, hasName(nameX)))";
237   llvm::Optional<DynTypedMatcher> HasParameterWithNamedValues(
238       Parser::parseMatcherExpression(Code, nullptr, &NamedValues, &Error));
239   EXPECT_EQ("", Error.toStringFull());
240   M = HasParameterWithNamedValues->unconditionalConvertTo<Decl>();
241 
242   EXPECT_TRUE(matches("void f(int a, int x);", M));
243   EXPECT_FALSE(matches("void f(int x, int a);", M));
244 
245   Code = "hasInitializer(\n    binaryOperator(hasLHS(\"A\")))";
246   EXPECT_TRUE(!Parser::parseMatcherExpression(Code, &Error).hasValue());
247   EXPECT_EQ("1:1: Error parsing argument 1 for matcher hasInitializer.\n"
248             "2:5: Error parsing argument 1 for matcher binaryOperator.\n"
249             "2:20: Error building matcher hasLHS.\n"
250             "2:27: Incorrect type for arg 1. "
251             "(Expected = Matcher<Expr>) != (Actual = String)",
252             Error.toStringFull());
253 }
254 
255 TEST(ParserTest, VariadicMatchTest) {
256   Diagnostics Error;
257 
258   StringRef Code =
259       "stmt(objcMessageExpr(hasAnySelector(\"methodA\", \"methodB:\")))";
260   llvm::Optional<DynTypedMatcher> OM(
261       Parser::parseMatcherExpression(Code, &Error));
262   EXPECT_EQ("", Error.toStringFull());
263   auto M = OM->unconditionalConvertTo<Stmt>();
264   EXPECT_TRUE(matchesObjC("@interface I @end "
265                           "void foo(I* i) { [i methodA]; }", M));
266 }
267 
268 std::string ParseWithError(StringRef Code) {
269   Diagnostics Error;
270   VariantValue Value;
271   Parser::parseExpression(Code, &Value, &Error);
272   return Error.toStringFull();
273 }
274 
275 std::string ParseMatcherWithError(StringRef Code) {
276   Diagnostics Error;
277   Parser::parseMatcherExpression(Code, &Error);
278   return Error.toStringFull();
279 }
280 
281 TEST(ParserTest, Errors) {
282   EXPECT_EQ(
283       "1:5: Error parsing matcher. Found token <123> while looking for '('.",
284       ParseWithError("Foo 123"));
285   EXPECT_EQ(
286       "1:1: Matcher not found: Foo\n"
287       "1:9: Error parsing matcher. Found token <123> while looking for ','.",
288       ParseWithError("Foo(\"A\" 123)"));
289   EXPECT_EQ(
290       "1:1: Error parsing argument 1 for matcher stmt.\n"
291       "1:6: Value not found: someValue",
292       ParseWithError("stmt(someValue)"));
293   EXPECT_EQ(
294       "1:1: Matcher not found: Foo\n"
295       "1:4: Error parsing matcher. Found end-of-code while looking for ')'.",
296       ParseWithError("Foo("));
297   EXPECT_EQ("1:1: End of code found while looking for token.",
298             ParseWithError(""));
299   EXPECT_EQ("Input value is not a matcher expression.",
300             ParseMatcherWithError("\"A\""));
301   EXPECT_EQ("1:1: Matcher not found: Foo\n"
302             "1:1: Error parsing argument 1 for matcher Foo.\n"
303             "1:5: Invalid token <(> found when looking for a value.",
304             ParseWithError("Foo(("));
305   EXPECT_EQ("1:7: Expected end of code.", ParseWithError("expr()a"));
306   EXPECT_EQ("1:11: Malformed bind() expression.",
307             ParseWithError("isArrow().biind"));
308   EXPECT_EQ("1:15: Malformed bind() expression.",
309             ParseWithError("isArrow().bind"));
310   EXPECT_EQ("1:16: Malformed bind() expression.",
311             ParseWithError("isArrow().bind(foo"));
312   EXPECT_EQ("1:21: Malformed bind() expression.",
313             ParseWithError("isArrow().bind(\"foo\""));
314   EXPECT_EQ("1:1: Error building matcher isArrow.\n"
315             "1:1: Matcher does not support binding.",
316             ParseWithError("isArrow().bind(\"foo\")"));
317   EXPECT_EQ("Input value has unresolved overloaded type: "
318             "Matcher<DoStmt|ForStmt|WhileStmt|CXXForRangeStmt|FunctionDecl>",
319             ParseMatcherWithError("hasBody(stmt())"));
320 }
321 
322 TEST(ParserTest, OverloadErrors) {
323   EXPECT_EQ("1:1: Error building matcher callee.\n"
324             "1:8: Candidate 1: Incorrect type for arg 1. "
325             "(Expected = Matcher<Stmt>) != (Actual = String)\n"
326             "1:8: Candidate 2: Incorrect type for arg 1. "
327             "(Expected = Matcher<Decl>) != (Actual = String)",
328             ParseWithError("callee(\"A\")"));
329 }
330 
331 TEST(ParserTest, ParseMultiline) {
332   StringRef Code;
333 
334   llvm::Optional<DynTypedMatcher> M;
335   {
336     Code = R"matcher(varDecl(
337   hasName("foo")
338   )
339 )matcher";
340     Diagnostics Error;
341     EXPECT_TRUE(Parser::parseMatcherExpression(Code, &Error).hasValue());
342   }
343 
344   {
345     Code = R"matcher(varDecl(
346   # Internal comment
347   hasName("foo") # Internal comment
348 # Internal comment
349   )
350 )matcher";
351     Diagnostics Error;
352     EXPECT_TRUE(Parser::parseMatcherExpression(Code, &Error).hasValue());
353   }
354 
355   {
356     Code = R"matcher(decl().bind(
357   "paramName")
358 )matcher";
359     Diagnostics Error;
360     EXPECT_TRUE(Parser::parseMatcherExpression(Code, &Error).hasValue());
361   }
362 
363   {
364     Code = R"matcher(decl().bind(
365   "paramName"
366   )
367 )matcher";
368     Diagnostics Error;
369     EXPECT_TRUE(Parser::parseMatcherExpression(Code, &Error).hasValue());
370   }
371 
372   {
373     Code = R"matcher(decl(decl()
374 , decl()))matcher";
375     Diagnostics Error;
376     EXPECT_TRUE(Parser::parseMatcherExpression(Code, &Error).hasValue());
377   }
378 
379   {
380     Code = R"matcher(decl(decl(),
381 decl()))matcher";
382     Diagnostics Error;
383     EXPECT_TRUE(Parser::parseMatcherExpression(Code, &Error).hasValue());
384   }
385 
386   {
387     Code = "namedDecl(hasName(\"n\"\n))";
388     Diagnostics Error;
389     EXPECT_TRUE(Parser::parseMatcherExpression(Code, &Error).hasValue());
390   }
391 
392   {
393     Diagnostics Error;
394 
395     auto NamedValues = getTestNamedValues();
396 
397     Code = R"matcher(hasParamA.bind
398   ("paramName")
399 )matcher";
400     M = Parser::parseMatcherExpression(Code, nullptr, &NamedValues, &Error);
401     EXPECT_FALSE(M.hasValue());
402     EXPECT_EQ("1:15: Malformed bind() expression.", Error.toStringFull());
403   }
404 
405   {
406     Diagnostics Error;
407 
408     auto NamedValues = getTestNamedValues();
409 
410     Code = R"matcher(hasParamA.
411   bind("paramName")
412 )matcher";
413     M = Parser::parseMatcherExpression(Code, nullptr, &NamedValues, &Error);
414     EXPECT_FALSE(M.hasValue());
415     EXPECT_EQ("1:11: Malformed bind() expression.", Error.toStringFull());
416   }
417 
418   {
419     Diagnostics Error;
420 
421     Code = R"matcher(varDecl
422 ()
423 )matcher";
424     M = Parser::parseMatcherExpression(Code, nullptr, nullptr, &Error);
425     EXPECT_FALSE(M.hasValue());
426     EXPECT_EQ("1:8: Error parsing matcher. Found token "
427               "<NewLine> while looking for '('.",
428               Error.toStringFull());
429   }
430 
431   // Correct line/column numbers
432   {
433     Diagnostics Error;
434 
435     Code = R"matcher(varDecl(
436   doesNotExist()
437   )
438 )matcher";
439     M = Parser::parseMatcherExpression(Code, nullptr, nullptr, &Error);
440     EXPECT_FALSE(M.hasValue());
441     StringRef Expected = R"error(1:1: Error parsing argument 1 for matcher varDecl.
442 2:3: Matcher not found: doesNotExist)error";
443     EXPECT_EQ(Expected, Error.toStringFull());
444   }
445 }
446 
447 TEST(ParserTest, CompletionRegistry) {
448   StringRef Code = "while";
449   std::vector<MatcherCompletion> Comps = Parser::completeExpression(Code, 5);
450   ASSERT_EQ(1u, Comps.size());
451   EXPECT_EQ("Stmt(", Comps[0].TypedText);
452   EXPECT_EQ("Matcher<Stmt> whileStmt(Matcher<WhileStmt>...)",
453             Comps[0].MatcherDecl);
454 
455   Code = "whileStmt().";
456   Comps = Parser::completeExpression(Code, 12);
457   ASSERT_EQ(1u, Comps.size());
458   EXPECT_EQ("bind(\"", Comps[0].TypedText);
459   EXPECT_EQ("bind", Comps[0].MatcherDecl);
460 }
461 
462 TEST(ParserTest, CompletionNamedValues) {
463   // Can complete non-matcher types.
464   auto NamedValues = getTestNamedValues();
465   StringRef Code = "functionDecl(hasName(";
466   std::vector<MatcherCompletion> Comps =
467       Parser::completeExpression(Code, Code.size(), nullptr, &NamedValues);
468   ASSERT_EQ(1u, Comps.size());
469   EXPECT_EQ("nameX", Comps[0].TypedText);
470   EXPECT_EQ("String nameX", Comps[0].MatcherDecl);
471 
472   // Can complete if there are names in the expression.
473   Code = "cxxMethodDecl(hasName(nameX), ";
474   Comps = Parser::completeExpression(Code, Code.size(), nullptr, &NamedValues);
475   EXPECT_LT(0u, Comps.size());
476 
477   // Can complete names and registry together.
478   Code = "functionDecl(hasP";
479   Comps = Parser::completeExpression(Code, Code.size(), nullptr, &NamedValues);
480   ASSERT_EQ(3u, Comps.size());
481 
482   EXPECT_EQ("arameter(", Comps[0].TypedText);
483   EXPECT_EQ(
484       "Matcher<FunctionDecl> hasParameter(unsigned, Matcher<ParmVarDecl>)",
485       Comps[0].MatcherDecl);
486 
487   EXPECT_EQ("aramA", Comps[1].TypedText);
488   EXPECT_EQ("Matcher<Decl> hasParamA", Comps[1].MatcherDecl);
489 
490   EXPECT_EQ("arent(", Comps[2].TypedText);
491   EXPECT_EQ(
492       "Matcher<Decl> "
493       "hasParent(Matcher<NestedNameSpecifierLoc|TypeLoc|Decl|...>)",
494       Comps[2].MatcherDecl);
495 }
496 
497 TEST(ParserTest, ParseBindOnLet) {
498 
499   auto NamedValues = getTestNamedValues();
500 
501   Diagnostics Error;
502 
503   {
504     StringRef Code = "hasParamA.bind(\"parmABinding\")";
505     llvm::Optional<DynTypedMatcher> TopLevelLetBinding(
506         Parser::parseMatcherExpression(Code, nullptr, &NamedValues, &Error));
507     EXPECT_EQ("", Error.toStringFull());
508     auto M = TopLevelLetBinding->unconditionalConvertTo<Decl>();
509 
510     EXPECT_TRUE(matchAndVerifyResultTrue(
511         "void foo(int a);", M,
512         std::make_unique<VerifyIdIsBoundTo<FunctionDecl>>("parmABinding")));
513     EXPECT_TRUE(matchAndVerifyResultFalse(
514         "void foo(int b);", M,
515         std::make_unique<VerifyIdIsBoundTo<FunctionDecl>>("parmABinding")));
516   }
517 
518   {
519     StringRef Code = "functionDecl(hasParamA.bind(\"parmABinding\"))";
520     llvm::Optional<DynTypedMatcher> NestedLetBinding(
521         Parser::parseMatcherExpression(Code, nullptr, &NamedValues, &Error));
522     EXPECT_EQ("", Error.toStringFull());
523     auto M = NestedLetBinding->unconditionalConvertTo<Decl>();
524 
525     EXPECT_TRUE(matchAndVerifyResultTrue(
526         "void foo(int a);", M,
527         std::make_unique<VerifyIdIsBoundTo<FunctionDecl>>("parmABinding")));
528     EXPECT_TRUE(matchAndVerifyResultFalse(
529         "void foo(int b);", M,
530         std::make_unique<VerifyIdIsBoundTo<FunctionDecl>>("parmABinding")));
531   }
532 }
533 
534 }  // end anonymous namespace
535 }  // end namespace dynamic
536 }  // end namespace ast_matchers
537 }  // end namespace clang
538