llvm-project

1
//===- unittests/AST/ASTTraverserTest.h------------------------------------===//
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 "clang/AST/ASTContext.h"
10
#include "clang/AST/ASTNodeTraverser.h"
11
#include "clang/AST/TextNodeDumper.h"
12
#include "clang/ASTMatchers/ASTMatchFinder.h"
13
#include "clang/ASTMatchers/ASTMatchers.h"
14
#include "clang/Tooling/Tooling.h"
15
#include "gmock/gmock.h"
16
#include "gtest/gtest.h"
17

18
using namespace clang::tooling;
19
using namespace clang::ast_matchers;
20

21
namespace clang {
22

23
class NodeTreePrinter : public TextTreeStructure {
24
  llvm::raw_ostream &OS;
25

26
public:
27
  NodeTreePrinter(llvm::raw_ostream &OS)
28
      : TextTreeStructure(OS, /* showColors */ false), OS(OS) {}
29

30
  void Visit(const Decl *D) {
31
    OS << D->getDeclKindName() << "Decl";
32
    if (auto *ND = dyn_cast<NamedDecl>(D)) {
33
      OS << " '" << ND->getDeclName() << "'";
34
    }
35
  }
36

37
  void Visit(const Stmt *S) {
38
    if (!S) {
39
      OS << "<<<NULL>>>";
40
      return;
41
    }
42
    OS << S->getStmtClassName();
43
    if (auto *E = dyn_cast<DeclRefExpr>(S)) {
44
      OS << " '" << E->getDecl()->getDeclName() << "'";
45
    }
46
  }
47

48
  void Visit(QualType QT) {
49
    OS << "QualType " << QT.split().Quals.getAsString();
50
  }
51

52
  void Visit(const Type *T) { OS << T->getTypeClassName() << "Type"; }
53

54
  void Visit(const comments::Comment *C, const comments::FullComment *FC) {
55
    OS << C->getCommentKindName();
56
  }
57

58
  void Visit(const CXXCtorInitializer *Init) {
59
    OS << "CXXCtorInitializer";
60
    if (const auto *F = Init->getAnyMember()) {
61
      OS << " '" << F->getNameAsString() << "'";
62
    } else if (auto const *TSI = Init->getTypeSourceInfo()) {
63
      OS << " '" << TSI->getType() << "'";
64
    }
65
  }
66

67
  void Visit(const Attr *A) {
68
    switch (A->getKind()) {
69
#define ATTR(X)                                                                \
70
  case attr::X:                                                                \
71
    OS << #X;                                                                  \
72
    break;
73
#include "clang/Basic/AttrList.inc"
74
    }
75
    OS << "Attr";
76
  }
77

78
  void Visit(const OMPClause *C) { OS << "OMPClause"; }
79
  void Visit(const TemplateArgument &A, SourceRange R = {},
80
             const Decl *From = nullptr, const char *Label = nullptr) {
81
    OS << "TemplateArgument";
82
    switch (A.getKind()) {
83
    case TemplateArgument::Type: {
84
      OS << " type " << A.getAsType();
85
      break;
86
    }
87
    default:
88
      break;
89
    }
90
  }
91

92
  template <typename... T> void Visit(T...) {}
93
};
94

95
class TestASTDumper : public ASTNodeTraverser<TestASTDumper, NodeTreePrinter> {
96

97
  NodeTreePrinter MyNodeRecorder;
98

99
public:
100
  TestASTDumper(llvm::raw_ostream &OS) : MyNodeRecorder(OS) {}
101
  NodeTreePrinter &doGetNodeDelegate() { return MyNodeRecorder; }
102
};
103

104
template <typename... NodeType> std::string dumpASTString(NodeType &&... N) {
105
  std::string Buffer;
106
  llvm::raw_string_ostream OS(Buffer);
107

108
  TestASTDumper Dumper(OS);
109

110
  OS << "\n";
111

112
  Dumper.Visit(std::forward<NodeType &&>(N)...);
113

114
  return Buffer;
115
}
116

117
template <typename... NodeType>
118
std::string dumpASTString(TraversalKind TK, NodeType &&... N) {
119
  std::string Buffer;
120
  llvm::raw_string_ostream OS(Buffer);
121

122
  TestASTDumper Dumper(OS);
123
  Dumper.SetTraversalKind(TK);
124

125
  OS << "\n";
126

127
  Dumper.Visit(std::forward<NodeType &&>(N)...);
128

129
  return Buffer;
130
}
131

132
const FunctionDecl *getFunctionNode(clang::ASTUnit *AST,
133
                                    const std::string &Name) {
134
  auto Result = ast_matchers::match(functionDecl(hasName(Name)).bind("fn"),
135
                                    AST->getASTContext());
136
  EXPECT_EQ(Result.size(), 1u);
137
  return Result[0].getNodeAs<FunctionDecl>("fn");
138
}
139

140
template <typename T> struct Verifier {
141
  static void withDynNode(T Node, const std::string &DumpString) {
142
    EXPECT_EQ(dumpASTString(DynTypedNode::create(Node)), DumpString);
143
  }
144
};
145

146
template <typename T> struct Verifier<T *> {
147
  static void withDynNode(T *Node, const std::string &DumpString) {
148
    EXPECT_EQ(dumpASTString(DynTypedNode::create(*Node)), DumpString);
149
  }
150
};
151

152
template <typename T>
153
void verifyWithDynNode(T Node, const std::string &DumpString) {
154
  EXPECT_EQ(dumpASTString(Node), DumpString);
155

156
  Verifier<T>::withDynNode(Node, DumpString);
157
}
158

159
TEST(Traverse, Dump) {
160

161
  auto AST = buildASTFromCode(R"cpp(
162
struct A {
163
  int m_number;
164

165
  /// CTor
166
  A() : m_number(42) {}
167

168
  [[nodiscard]] const int func() {
169
    return 42;
170
  }
171

172
};
173

174
template<typename T>
175
struct templ
176
{
177
};
178

179
template<>
180
struct templ<int>
181
{
182
};
183

184
void parmvardecl_attr(struct A __attribute__((address_space(19)))*);
185

186
)cpp");
187

188
  const FunctionDecl *Func = getFunctionNode(AST.get(), "func");
189

190
  verifyWithDynNode(Func,
191
                    R"cpp(
192
CXXMethodDecl 'func'
193
|-CompoundStmt
194
| `-ReturnStmt
195
|   `-IntegerLiteral
196
`-WarnUnusedResultAttr
197
)cpp");
198

199
  Stmt *Body = Func->getBody();
200

201
  verifyWithDynNode(Body,
202
                    R"cpp(
203
CompoundStmt
204
`-ReturnStmt
205
  `-IntegerLiteral
206
)cpp");
207

208
  QualType QT = Func->getType();
209

210
  verifyWithDynNode(QT,
211
                    R"cpp(
212
FunctionProtoType
213
`-QualType const
214
  `-BuiltinType
215
)cpp");
216

217
  const FunctionDecl *CTorFunc = getFunctionNode(AST.get(), "A");
218

219
  verifyWithDynNode(CTorFunc->getType(),
220
                    R"cpp(
221
FunctionProtoType
222
`-BuiltinType
223
)cpp");
224

225
  Attr *A = *Func->attr_begin();
226

227
  {
228
    std::string expectedString = R"cpp(
229
WarnUnusedResultAttr
230
)cpp";
231

232
    EXPECT_EQ(dumpASTString(A), expectedString);
233
  }
234

235
  auto *CTor = dyn_cast<CXXConstructorDecl>(CTorFunc);
236
  const CXXCtorInitializer *Init = *CTor->init_begin();
237

238
  verifyWithDynNode(Init,
239
                    R"cpp(
240
CXXCtorInitializer 'm_number'
241
`-IntegerLiteral
242
)cpp");
243

244
  const comments::FullComment *Comment =
245
      AST->getASTContext().getLocalCommentForDeclUncached(CTorFunc);
246
  {
247
    std::string expectedString = R"cpp(
248
FullComment
249
`-ParagraphComment
250
  `-TextComment
251
)cpp";
252
    EXPECT_EQ(dumpASTString(Comment, Comment), expectedString);
253
  }
254

255
  auto Result = ast_matchers::match(
256
      classTemplateSpecializationDecl(hasName("templ")).bind("fn"),
257
      AST->getASTContext());
258
  EXPECT_EQ(Result.size(), 1u);
259
  auto Templ = Result[0].getNodeAs<ClassTemplateSpecializationDecl>("fn");
260

261
  TemplateArgument TA = Templ->getTemplateArgs()[0];
262

263
  verifyWithDynNode(TA,
264
                    R"cpp(
265
TemplateArgument type int
266
`-BuiltinType
267
)cpp");
268

269
  Func = getFunctionNode(AST.get(), "parmvardecl_attr");
270

271
  const auto *Parm = Func->getParamDecl(0);
272
  const auto TL = Parm->getTypeSourceInfo()->getTypeLoc();
273
  ASSERT_TRUE(TL.getType()->isPointerType());
274

275
  const auto ATL = TL.getNextTypeLoc().getAs<AttributedTypeLoc>();
276
  const auto *AS = cast<AddressSpaceAttr>(ATL.getAttr());
277
  EXPECT_EQ(toTargetAddressSpace(static_cast<LangAS>(AS->getAddressSpace())),
278
            19u);
279
}
280

281
TEST(Traverse, IgnoreUnlessSpelledInSourceVars) {
282

283
  auto AST = buildASTFromCodeWithArgs(R"cpp(
284

285
struct String
286
{
287
    String(const char*, int = -1) {}
288

289
    int overloaded() const;
290
    int& overloaded();
291
};
292

293
void stringConstruct()
294
{
295
    String s = "foo";
296
    s = "bar";
297
}
298

299
void overloadCall()
300
{
301
   String s = "foo";
302
   (s).overloaded();
303
}
304

305
struct C1 {};
306
struct C2 { operator C1(); };
307

308
void conversionOperator()
309
{
310
    C2* c2;
311
    C1 c1 = (*c2);
312
}
313

314
template <unsigned alignment>
315
void template_test() {
316
  static_assert(alignment, "");
317
}
318
void actual_template_test() {
319
  template_test<4>();
320
}
321

322
struct OneParamCtor {
323
  explicit OneParamCtor(int);
324
};
325
struct TwoParamCtor {
326
  explicit TwoParamCtor(int, int);
327
};
328

329
void varDeclCtors() {
330
  {
331
  auto var1 = OneParamCtor(5);
332
  auto var2 = TwoParamCtor(6, 7);
333
  }
334
  {
335
  OneParamCtor var3(5);
336
  TwoParamCtor var4(6, 7);
337
  }
338
  int i = 0;
339
  {
340
  auto var5 = OneParamCtor(i);
341
  auto var6 = TwoParamCtor(i, 7);
342
  }
343
  {
344
  OneParamCtor var7(i);
345
  TwoParamCtor var8(i, 7);
346
  }
347
}
348

349
)cpp", {"-std=c++14"});
350

351
  {
352
    auto FN =
353
        ast_matchers::match(functionDecl(hasName("stringConstruct")).bind("fn"),
354
                            AST->getASTContext());
355
    EXPECT_EQ(FN.size(), 1u);
356

357
    EXPECT_EQ(dumpASTString(TK_AsIs, FN[0].getNodeAs<Decl>("fn")),
358
              R"cpp(
359
FunctionDecl 'stringConstruct'
360
`-CompoundStmt
361
  |-DeclStmt
362
  | `-VarDecl 's'
363
  |   `-ExprWithCleanups
364
  |     `-CXXConstructExpr
365
  |       `-MaterializeTemporaryExpr
366
  |         `-ImplicitCastExpr
367
  |           `-CXXConstructExpr
368
  |             |-ImplicitCastExpr
369
  |             | `-StringLiteral
370
  |             `-CXXDefaultArgExpr
371
  |               `-UnaryOperator
372
  |                 `-IntegerLiteral
373
  `-ExprWithCleanups
374
    `-CXXOperatorCallExpr
375
      |-ImplicitCastExpr
376
      | `-DeclRefExpr 'operator='
377
      |-DeclRefExpr 's'
378
      `-MaterializeTemporaryExpr
379
        `-CXXConstructExpr
380
          |-ImplicitCastExpr
381
          | `-StringLiteral
382
          `-CXXDefaultArgExpr
383
            `-UnaryOperator
384
              `-IntegerLiteral
385
)cpp");
386

387
    EXPECT_EQ(dumpASTString(TK_IgnoreUnlessSpelledInSource,
388
                            FN[0].getNodeAs<Decl>("fn")),
389
              R"cpp(
390
FunctionDecl 'stringConstruct'
391
`-CompoundStmt
392
  |-DeclStmt
393
  | `-VarDecl 's'
394
  |   `-StringLiteral
395
  `-CXXOperatorCallExpr
396
    |-DeclRefExpr 'operator='
397
    |-DeclRefExpr 's'
398
    `-StringLiteral
399
)cpp");
400
  }
401

402
  {
403
    auto FN =
404
        ast_matchers::match(functionDecl(hasName("overloadCall")).bind("fn"),
405
                            AST->getASTContext());
406
    EXPECT_EQ(FN.size(), 1u);
407

408
    EXPECT_EQ(dumpASTString(TK_AsIs, FN[0].getNodeAs<Decl>("fn")),
409
              R"cpp(
410
FunctionDecl 'overloadCall'
411
`-CompoundStmt
412
  |-DeclStmt
413
  | `-VarDecl 's'
414
  |   `-ExprWithCleanups
415
  |     `-CXXConstructExpr
416
  |       `-MaterializeTemporaryExpr
417
  |         `-ImplicitCastExpr
418
  |           `-CXXConstructExpr
419
  |             |-ImplicitCastExpr
420
  |             | `-StringLiteral
421
  |             `-CXXDefaultArgExpr
422
  |               `-UnaryOperator
423
  |                 `-IntegerLiteral
424
  `-CXXMemberCallExpr
425
    `-MemberExpr
426
      `-ParenExpr
427
        `-DeclRefExpr 's'
428
)cpp");
429

430
    EXPECT_EQ(dumpASTString(TK_IgnoreUnlessSpelledInSource,
431
                            FN[0].getNodeAs<Decl>("fn")),
432
              R"cpp(
433
FunctionDecl 'overloadCall'
434
`-CompoundStmt
435
  |-DeclStmt
436
  | `-VarDecl 's'
437
  |   `-StringLiteral
438
  `-CXXMemberCallExpr
439
    `-MemberExpr
440
      `-DeclRefExpr 's'
441
)cpp");
442
  }
443

444
  {
445
    auto FN = ast_matchers::match(
446
        functionDecl(hasName("conversionOperator"),
447
                     hasDescendant(varDecl(hasName("c1")).bind("var"))),
448
        AST->getASTContext());
449
    EXPECT_EQ(FN.size(), 1u);
450

451
    EXPECT_EQ(dumpASTString(TK_AsIs, FN[0].getNodeAs<Decl>("var")),
452
              R"cpp(
453
VarDecl 'c1'
454
`-ExprWithCleanups
455
  `-CXXConstructExpr
456
    `-MaterializeTemporaryExpr
457
      `-ImplicitCastExpr
458
        `-CXXMemberCallExpr
459
          `-MemberExpr
460
            `-ParenExpr
461
              `-UnaryOperator
462
                `-ImplicitCastExpr
463
                  `-DeclRefExpr 'c2'
464
)cpp");
465

466
    EXPECT_EQ(dumpASTString(TK_IgnoreUnlessSpelledInSource,
467
                            FN[0].getNodeAs<Decl>("var")),
468
              R"cpp(
469
VarDecl 'c1'
470
`-UnaryOperator
471
  `-DeclRefExpr 'c2'
472
)cpp");
473
  }
474

475
  {
476
    auto FN = ast_matchers::match(
477
        functionDecl(hasName("template_test"),
478
                     hasDescendant(staticAssertDecl().bind("staticAssert"))),
479
        AST->getASTContext());
480
    EXPECT_EQ(FN.size(), 2u);
481

482
    EXPECT_EQ(dumpASTString(TK_AsIs, FN[1].getNodeAs<Decl>("staticAssert")),
483
              R"cpp(
484
StaticAssertDecl
485
|-ImplicitCastExpr
486
| `-SubstNonTypeTemplateParmExpr
487
|   |-NonTypeTemplateParmDecl 'alignment'
488
|   `-IntegerLiteral
489
`-StringLiteral
490
)cpp");
491

492
    EXPECT_EQ(dumpASTString(TK_IgnoreUnlessSpelledInSource,
493
                            FN[1].getNodeAs<Decl>("staticAssert")),
494
              R"cpp(
495
StaticAssertDecl
496
|-IntegerLiteral
497
`-StringLiteral
498
)cpp");
499
  }
500

501
  auto varChecker = [&AST](StringRef varName, StringRef SemanticDump,
502
                           StringRef SyntacticDump) {
503
    auto FN = ast_matchers::match(
504
        functionDecl(
505
            hasName("varDeclCtors"),
506
            forEachDescendant(varDecl(hasName(varName)).bind("varDeclCtor"))),
507
        AST->getASTContext());
508
    EXPECT_EQ(FN.size(), 1u);
509

510
    EXPECT_EQ(dumpASTString(TK_AsIs, FN[0].getNodeAs<Decl>("varDeclCtor")),
511
              SemanticDump);
512

513
    EXPECT_EQ(dumpASTString(TK_IgnoreUnlessSpelledInSource,
514
                            FN[0].getNodeAs<Decl>("varDeclCtor")),
515
              SyntacticDump);
516
  };
517

518
  varChecker("var1",
519
             R"cpp(
520
VarDecl 'var1'
521
`-ExprWithCleanups
522
  `-CXXConstructExpr
523
    `-MaterializeTemporaryExpr
524
      `-CXXFunctionalCastExpr
525
        `-CXXConstructExpr
526
          `-IntegerLiteral
527
)cpp",
528
             R"cpp(
529
VarDecl 'var1'
530
`-CXXConstructExpr
531
  `-IntegerLiteral
532
)cpp");
533

534
  varChecker("var2",
535
             R"cpp(
536
VarDecl 'var2'
537
`-ExprWithCleanups
538
  `-CXXConstructExpr
539
    `-MaterializeTemporaryExpr
540
      `-CXXTemporaryObjectExpr
541
        |-IntegerLiteral
542
        `-IntegerLiteral
543
)cpp",
544
             R"cpp(
545
VarDecl 'var2'
546
`-CXXTemporaryObjectExpr
547
  |-IntegerLiteral
548
  `-IntegerLiteral
549
)cpp");
550

551
  varChecker("var3",
552
             R"cpp(
553
VarDecl 'var3'
554
`-CXXConstructExpr
555
  `-IntegerLiteral
556
)cpp",
557
             R"cpp(
558
VarDecl 'var3'
559
`-CXXConstructExpr
560
  `-IntegerLiteral
561
)cpp");
562

563
  varChecker("var4",
564
             R"cpp(
565
VarDecl 'var4'
566
`-CXXConstructExpr
567
  |-IntegerLiteral
568
  `-IntegerLiteral
569
)cpp",
570
             R"cpp(
571
VarDecl 'var4'
572
`-CXXConstructExpr
573
  |-IntegerLiteral
574
  `-IntegerLiteral
575
)cpp");
576

577
  varChecker("var5",
578
             R"cpp(
579
VarDecl 'var5'
580
`-ExprWithCleanups
581
  `-CXXConstructExpr
582
    `-MaterializeTemporaryExpr
583
      `-CXXFunctionalCastExpr
584
        `-CXXConstructExpr
585
          `-ImplicitCastExpr
586
            `-DeclRefExpr 'i'
587
)cpp",
588
             R"cpp(
589
VarDecl 'var5'
590
`-CXXConstructExpr
591
  `-DeclRefExpr 'i'
592
)cpp");
593

594
  varChecker("var6",
595
             R"cpp(
596
VarDecl 'var6'
597
`-ExprWithCleanups
598
  `-CXXConstructExpr
599
    `-MaterializeTemporaryExpr
600
      `-CXXTemporaryObjectExpr
601
        |-ImplicitCastExpr
602
        | `-DeclRefExpr 'i'
603
        `-IntegerLiteral
604
)cpp",
605
             R"cpp(
606
VarDecl 'var6'
607
`-CXXTemporaryObjectExpr
608
  |-DeclRefExpr 'i'
609
  `-IntegerLiteral
610
)cpp");
611

612
  varChecker("var7",
613
             R"cpp(
614
VarDecl 'var7'
615
`-CXXConstructExpr
616
  `-ImplicitCastExpr
617
    `-DeclRefExpr 'i'
618
)cpp",
619
             R"cpp(
620
VarDecl 'var7'
621
`-CXXConstructExpr
622
  `-DeclRefExpr 'i'
623
)cpp");
624

625
  varChecker("var8",
626
             R"cpp(
627
VarDecl 'var8'
628
`-CXXConstructExpr
629
  |-ImplicitCastExpr
630
  | `-DeclRefExpr 'i'
631
  `-IntegerLiteral
632
)cpp",
633
             R"cpp(
634
VarDecl 'var8'
635
`-CXXConstructExpr
636
  |-DeclRefExpr 'i'
637
  `-IntegerLiteral
638
)cpp");
639
}
640

641
TEST(Traverse, IgnoreUnlessSpelledInSourceStructs) {
642
  auto AST = buildASTFromCode(R"cpp(
643

644
struct MyStruct {
645
  MyStruct();
646
  MyStruct(int i) {
647
    MyStruct();
648
  }
649
  ~MyStruct();
650
};
651

652
)cpp");
653

654
  auto BN = ast_matchers::match(
655
      cxxConstructorDecl(hasName("MyStruct"),
656
                         hasParameter(0, parmVarDecl(hasType(isInteger()))))
657
          .bind("ctor"),
658
      AST->getASTContext());
659
  EXPECT_EQ(BN.size(), 1u);
660

661
  EXPECT_EQ(dumpASTString(TK_IgnoreUnlessSpelledInSource,
662
                          BN[0].getNodeAs<Decl>("ctor")),
663
            R"cpp(
664
CXXConstructorDecl 'MyStruct'
665
|-ParmVarDecl 'i'
666
`-CompoundStmt
667
  `-CXXTemporaryObjectExpr
668
)cpp");
669

670
  EXPECT_EQ(dumpASTString(TK_AsIs, BN[0].getNodeAs<Decl>("ctor")),
671
            R"cpp(
672
CXXConstructorDecl 'MyStruct'
673
|-ParmVarDecl 'i'
674
`-CompoundStmt
675
  `-ExprWithCleanups
676
    `-CXXBindTemporaryExpr
677
      `-CXXTemporaryObjectExpr
678
)cpp");
679
}
680

681
TEST(Traverse, IgnoreUnlessSpelledInSourceReturnStruct) {
682

683
  auto AST = buildASTFromCode(R"cpp(
684
struct Retval {
685
  Retval() {}
686
  ~Retval() {}
687
};
688

689
Retval someFun();
690

691
void foo()
692
{
693
    someFun();
694
}
695
)cpp");
696

697
  auto BN = ast_matchers::match(functionDecl(hasName("foo")).bind("fn"),
698
                                AST->getASTContext());
699
  EXPECT_EQ(BN.size(), 1u);
700

701
  EXPECT_EQ(dumpASTString(TK_IgnoreUnlessSpelledInSource,
702
                          BN[0].getNodeAs<Decl>("fn")),
703
            R"cpp(
704
FunctionDecl 'foo'
705
`-CompoundStmt
706
  `-CallExpr
707
    `-DeclRefExpr 'someFun'
708
)cpp");
709

710
  EXPECT_EQ(dumpASTString(TK_AsIs, BN[0].getNodeAs<Decl>("fn")),
711
            R"cpp(
712
FunctionDecl 'foo'
713
`-CompoundStmt
714
  `-ExprWithCleanups
715
    `-CXXBindTemporaryExpr
716
      `-CallExpr
717
        `-ImplicitCastExpr
718
          `-DeclRefExpr 'someFun'
719
)cpp");
720
}
721

722
TEST(Traverse, IgnoreUnlessSpelledInSourceReturns) {
723

724
  auto AST = buildASTFromCodeWithArgs(R"cpp(
725

726
struct A
727
{
728
};
729

730
struct B
731
{
732
  B(int);
733
  B(A const& a);
734
  B();
735
};
736

737
struct C
738
{
739
  operator B();
740
};
741

742
B func1() {
743
  return 42;
744
}
745

746
B func2() {
747
  return B{42};
748
}
749

750
B func3() {
751
  return B(42);
752
}
753

754
B func4() {
755
  return B();
756
}
757

758
B func5() {
759
  return B{};
760
}
761

762
B func6() {
763
  return C();
764
}
765

766
B func7() {
767
  return A();
768
}
769

770
B func8() {
771
  return C{};
772
}
773

774
B func9() {
775
  return A{};
776
}
777

778
B func10() {
779
  A a;
780
  return a;
781
}
782

783
B func11() {
784
  B b;
785
  return b;
786
}
787

788
B func12() {
789
  C c;
790
  return c;
791
}
792

793
)cpp", {"-std=c++14"});
794

795
  auto getFunctionNode = [&AST](const std::string &name) {
796
    auto BN = ast_matchers::match(functionDecl(hasName(name)).bind("fn"),
797
                                  AST->getASTContext());
798
    EXPECT_EQ(BN.size(), 1u);
799
    return BN[0].getNodeAs<Decl>("fn");
800
  };
801

802
  {
803
    auto FN = getFunctionNode("func1");
804
    llvm::StringRef Expected = R"cpp(
805
FunctionDecl 'func1'
806
`-CompoundStmt
807
  `-ReturnStmt
808
    `-ExprWithCleanups
809
      `-CXXConstructExpr
810
        `-MaterializeTemporaryExpr
811
          `-ImplicitCastExpr
812
            `-CXXConstructExpr
813
              `-IntegerLiteral
814
)cpp";
815

816
    EXPECT_EQ(dumpASTString(TK_AsIs, FN), Expected);
817

818
    Expected = R"cpp(
819
FunctionDecl 'func1'
820
`-CompoundStmt
821
  `-ReturnStmt
822
    `-IntegerLiteral
823
)cpp";
824
    EXPECT_EQ(dumpASTString(TK_IgnoreUnlessSpelledInSource, FN), Expected);
825
  }
826

827
  llvm::StringRef Expected = R"cpp(
828
FunctionDecl 'func2'
829
`-CompoundStmt
830
  `-ReturnStmt
831
    `-CXXTemporaryObjectExpr
832
      `-IntegerLiteral
833
)cpp";
834
  EXPECT_EQ(
835
      dumpASTString(TK_IgnoreUnlessSpelledInSource, getFunctionNode("func2")),
836
      Expected);
837

838
  Expected = R"cpp(
839
FunctionDecl 'func3'
840
`-CompoundStmt
841
  `-ReturnStmt
842
    `-CXXConstructExpr
843
      `-IntegerLiteral
844
)cpp";
845
  EXPECT_EQ(
846
      dumpASTString(TK_IgnoreUnlessSpelledInSource, getFunctionNode("func3")),
847
      Expected);
848

849
  Expected = R"cpp(
850
FunctionDecl 'func4'
851
`-CompoundStmt
852
  `-ReturnStmt
853
    `-CXXTemporaryObjectExpr
854
)cpp";
855
  EXPECT_EQ(
856
      dumpASTString(TK_IgnoreUnlessSpelledInSource, getFunctionNode("func4")),
857
      Expected);
858

859
  Expected = R"cpp(
860
FunctionDecl 'func5'
861
`-CompoundStmt
862
  `-ReturnStmt
863
    `-CXXTemporaryObjectExpr
864
)cpp";
865
  EXPECT_EQ(
866
      dumpASTString(TK_IgnoreUnlessSpelledInSource, getFunctionNode("func5")),
867
      Expected);
868

869
  Expected = R"cpp(
870
FunctionDecl 'func6'
871
`-CompoundStmt
872
  `-ReturnStmt
873
    `-CXXTemporaryObjectExpr
874
)cpp";
875
  EXPECT_EQ(
876
      dumpASTString(TK_IgnoreUnlessSpelledInSource, getFunctionNode("func6")),
877
      Expected);
878

879
  Expected = R"cpp(
880
FunctionDecl 'func7'
881
`-CompoundStmt
882
  `-ReturnStmt
883
    `-CXXTemporaryObjectExpr
884
)cpp";
885
  EXPECT_EQ(
886
      dumpASTString(TK_IgnoreUnlessSpelledInSource, getFunctionNode("func7")),
887
      Expected);
888

889
  Expected = R"cpp(
890
FunctionDecl 'func8'
891
`-CompoundStmt
892
  `-ReturnStmt
893
    `-CXXFunctionalCastExpr
894
      `-InitListExpr
895
)cpp";
896
  EXPECT_EQ(
897
      dumpASTString(TK_IgnoreUnlessSpelledInSource, getFunctionNode("func8")),
898
      Expected);
899

900
  Expected = R"cpp(
901
FunctionDecl 'func9'
902
`-CompoundStmt
903
  `-ReturnStmt
904
    `-CXXFunctionalCastExpr
905
      `-InitListExpr
906
)cpp";
907
  EXPECT_EQ(
908
      dumpASTString(TK_IgnoreUnlessSpelledInSource, getFunctionNode("func9")),
909
      Expected);
910

911
  Expected = R"cpp(
912
FunctionDecl 'func10'
913
`-CompoundStmt
914
  |-DeclStmt
915
  | `-VarDecl 'a'
916
  |   `-CXXConstructExpr
917
  `-ReturnStmt
918
    `-DeclRefExpr 'a'
919
)cpp";
920
  EXPECT_EQ(
921
      dumpASTString(TK_IgnoreUnlessSpelledInSource, getFunctionNode("func10")),
922
      Expected);
923

924
  Expected = R"cpp(
925
FunctionDecl 'func11'
926
`-CompoundStmt
927
  |-DeclStmt
928
  | `-VarDecl 'b'
929
  |   `-CXXConstructExpr
930
  `-ReturnStmt
931
    `-DeclRefExpr 'b'
932
)cpp";
933
  EXPECT_EQ(
934
      dumpASTString(TK_IgnoreUnlessSpelledInSource, getFunctionNode("func11")),
935
      Expected);
936

937
  Expected = R"cpp(
938
FunctionDecl 'func12'
939
`-CompoundStmt
940
  |-DeclStmt
941
  | `-VarDecl 'c'
942
  |   `-CXXConstructExpr
943
  `-ReturnStmt
944
    `-DeclRefExpr 'c'
945
)cpp";
946
  EXPECT_EQ(
947
      dumpASTString(TK_IgnoreUnlessSpelledInSource, getFunctionNode("func12")),
948
      Expected);
949
}
950

951
TEST(Traverse, LambdaUnlessSpelledInSource) {
952

953
  auto AST =
954
      buildASTFromCodeWithArgs(R"cpp(
955

956
void captures() {
957
  int a = 0;
958
  int b = 0;
959
  int d = 0;
960
  int f = 0;
961

962
  [a, &b, c = d, &e = f](int g, int h = 42) {};
963
}
964

965
void templated() {
966
  int a = 0;
967
  [a]<typename T>(T t) {};
968
}
969

970
struct SomeStruct {
971
    int a = 0;
972
    void capture_this() {
973
        [this]() {};
974
    }
975
    void capture_this_copy() {
976
        [self = *this]() {};
977
    }
978
};
979
)cpp",
980
                               {"-Wno-unused-value", "-Wno-c++2a-extensions"});
981

982
  auto getLambdaNode = [&AST](const std::string &name) {
983
    auto BN = ast_matchers::match(
984
        lambdaExpr(hasAncestor(functionDecl(hasName(name)))).bind("lambda"),
985
        AST->getASTContext());
986
    EXPECT_EQ(BN.size(), 1u);
987
    return BN[0].getNodeAs<LambdaExpr>("lambda");
988
  };
989

990
  {
991
    auto L = getLambdaNode("captures");
992

993
    llvm::StringRef Expected = R"cpp(
994
LambdaExpr
995
|-DeclRefExpr 'a'
996
|-DeclRefExpr 'b'
997
|-VarDecl 'c'
998
| `-DeclRefExpr 'd'
999
|-VarDecl 'e'
1000
| `-DeclRefExpr 'f'
1001
|-ParmVarDecl 'g'
1002
|-ParmVarDecl 'h'
1003
| `-IntegerLiteral
1004
`-CompoundStmt
1005
)cpp";
1006
    EXPECT_EQ(dumpASTString(TK_IgnoreUnlessSpelledInSource, L), Expected);
1007

1008
    Expected = R"cpp(
1009
LambdaExpr
1010
|-CXXRecordDecl ''
1011
| |-CXXMethodDecl 'operator()'
1012
| | |-ParmVarDecl 'g'
1013
| | |-ParmVarDecl 'h'
1014
| | | `-IntegerLiteral
1015
| | `-CompoundStmt
1016
| |-FieldDecl ''
1017
| |-FieldDecl ''
1018
| |-FieldDecl ''
1019
| |-FieldDecl ''
1020
| `-CXXDestructorDecl '~(lambda at input.cc:9:3)'
1021
|-ImplicitCastExpr
1022
| `-DeclRefExpr 'a'
1023
|-DeclRefExpr 'b'
1024
|-ImplicitCastExpr
1025
| `-DeclRefExpr 'd'
1026
|-DeclRefExpr 'f'
1027
`-CompoundStmt
1028
)cpp";
1029
    EXPECT_EQ(dumpASTString(TK_AsIs, L), Expected);
1030
  }
1031

1032
  {
1033
    auto L = getLambdaNode("templated");
1034

1035
    llvm::StringRef Expected = R"cpp(
1036
LambdaExpr
1037
|-DeclRefExpr 'a'
1038
|-TemplateTypeParmDecl 'T'
1039
|-ParmVarDecl 't'
1040
`-CompoundStmt
1041
)cpp";
1042
    EXPECT_EQ(dumpASTString(TK_IgnoreUnlessSpelledInSource, L), Expected);
1043
  }
1044

1045
  {
1046
    auto L = getLambdaNode("capture_this");
1047

1048
    llvm::StringRef Expected = R"cpp(
1049
LambdaExpr
1050
|-CXXThisExpr
1051
`-CompoundStmt
1052
)cpp";
1053
    EXPECT_EQ(dumpASTString(TK_IgnoreUnlessSpelledInSource, L), Expected);
1054
  }
1055

1056
  {
1057
    auto L = getLambdaNode("capture_this_copy");
1058

1059
    llvm::StringRef Expected = R"cpp(
1060
LambdaExpr
1061
|-VarDecl 'self'
1062
| `-UnaryOperator
1063
|   `-CXXThisExpr
1064
`-CompoundStmt
1065
)cpp";
1066
    EXPECT_EQ(dumpASTString(TK_IgnoreUnlessSpelledInSource, L), Expected);
1067
  }
1068
}
1069

1070
TEST(Traverse, IgnoreUnlessSpelledInSourceImplicit) {
1071
  {
1072
    auto AST = buildASTFromCode(R"cpp(
1073
int i = 0;
1074
)cpp");
1075
    const auto *TUDecl = AST->getASTContext().getTranslationUnitDecl();
1076

1077
    EXPECT_EQ(dumpASTString(TK_IgnoreUnlessSpelledInSource, TUDecl),
1078
              R"cpp(
1079
TranslationUnitDecl
1080
`-VarDecl 'i'
1081
  `-IntegerLiteral
1082
)cpp");
1083
  }
1084

1085
  auto AST2 = buildASTFromCodeWithArgs(R"cpp(
1086
struct Simple {
1087
};
1088
struct Other {
1089
};
1090

1091
struct Record : Simple, Other {
1092
  Record() : Simple(), m_i(42) {}
1093
private:
1094
  int m_i;
1095
  int m_i2 = 42;
1096
  Simple m_s;
1097
};
1098

1099
struct NonTrivial {
1100
    NonTrivial() {}
1101
    NonTrivial(NonTrivial&) {}
1102
    NonTrivial& operator=(NonTrivial&) { return *this; }
1103

1104
    ~NonTrivial() {}
1105
};
1106

1107
struct ContainsArray {
1108
    NonTrivial arr[2];
1109
    int irr[2];
1110
    ContainsArray& operator=(ContainsArray &) = default;
1111
};
1112

1113
void copyIt()
1114
{
1115
    ContainsArray ca;
1116
    ContainsArray ca2;
1117
    ca2 = ca;
1118
}
1119

1120
void forLoop()
1121
{
1122
    int arr[2];
1123
    for (auto i : arr)
1124
    {
1125

1126
    }
1127
    for (auto& a = arr; auto i : a)
1128
    {
1129

1130
    }
1131
}
1132

1133
struct DefaultedAndDeleted {
1134
  NonTrivial nt;
1135
  DefaultedAndDeleted() = default;
1136
  ~DefaultedAndDeleted() = default;
1137
  DefaultedAndDeleted(DefaultedAndDeleted &) = default;
1138
  DefaultedAndDeleted& operator=(DefaultedAndDeleted &) = default;
1139
  DefaultedAndDeleted(DefaultedAndDeleted &&) = delete;
1140
  DefaultedAndDeleted& operator=(DefaultedAndDeleted &&) = delete;
1141
};
1142

1143
void copyIt2()
1144
{
1145
    DefaultedAndDeleted ca;
1146
    DefaultedAndDeleted ca2;
1147
    ca2 = ca;
1148
}
1149

1150
void hasDefaultArg(int i, int j = 0)
1151
{
1152
}
1153
void callDefaultArg()
1154
{
1155
  hasDefaultArg(42);
1156
}
1157

1158
void decomposition()
1159
{
1160
    int arr[3];
1161
    auto &[f, s, t] = arr;
1162

1163
    f = 42;
1164
}
1165

1166
typedef __typeof(sizeof(int)) size_t;
1167

1168
struct Pair
1169
{
1170
    int x, y;
1171
};
1172

1173
// Note: these utilities are required to force binding to tuple like structure
1174
namespace std
1175
{
1176
    template <typename E>
1177
    struct tuple_size
1178
    {
1179
    };
1180

1181
    template <>
1182
    struct tuple_size<Pair>
1183
    {
1184
        static constexpr size_t value = 2;
1185
    };
1186

1187
    template <size_t I, class T>
1188
    struct tuple_element
1189
    {
1190
        using type = int;
1191
    };
1192

1193
};
1194

1195
template <size_t I>
1196
int &&get(Pair &&p);
1197

1198
void decompTuple()
1199
{
1200
    Pair p{1, 2};
1201
    auto [a, b] = p;
1202

1203
    a = 3;
1204
}
1205

1206
)cpp",
1207
                                       {"-std=c++20"});
1208

1209
  {
1210
    auto BN = ast_matchers::match(
1211
        cxxRecordDecl(hasName("Record"), unless(isImplicit())).bind("rec"),
1212
        AST2->getASTContext());
1213
    EXPECT_EQ(BN.size(), 1u);
1214

1215
    EXPECT_EQ(dumpASTString(TK_AsIs, BN[0].getNodeAs<Decl>("rec")),
1216
              R"cpp(
1217
CXXRecordDecl 'Record'
1218
|-CXXRecordDecl 'Record'
1219
|-CXXConstructorDecl 'Record'
1220
| |-CXXCtorInitializer 'Simple'
1221
| | `-CXXConstructExpr
1222
| |-CXXCtorInitializer 'Other'
1223
| | `-CXXConstructExpr
1224
| |-CXXCtorInitializer 'm_i'
1225
| | `-IntegerLiteral
1226
| |-CXXCtorInitializer 'm_i2'
1227
| | `-CXXDefaultInitExpr
1228
| |   `-IntegerLiteral
1229
| |-CXXCtorInitializer 'm_s'
1230
| | `-CXXConstructExpr
1231
| `-CompoundStmt
1232
|-AccessSpecDecl
1233
|-FieldDecl 'm_i'
1234
|-FieldDecl 'm_i2'
1235
| `-IntegerLiteral
1236
`-FieldDecl 'm_s'
1237
)cpp");
1238

1239
    EXPECT_EQ(dumpASTString(TK_IgnoreUnlessSpelledInSource,
1240
                            BN[0].getNodeAs<Decl>("rec")),
1241
              R"cpp(
1242
CXXRecordDecl 'Record'
1243
|-CXXConstructorDecl 'Record'
1244
| |-CXXCtorInitializer 'Simple'
1245
| | `-CXXConstructExpr
1246
| |-CXXCtorInitializer 'm_i'
1247
| | `-IntegerLiteral
1248
| `-CompoundStmt
1249
|-AccessSpecDecl
1250
|-FieldDecl 'm_i'
1251
|-FieldDecl 'm_i2'
1252
| `-IntegerLiteral
1253
`-FieldDecl 'm_s'
1254
)cpp");
1255
  }
1256
  {
1257
    auto BN = ast_matchers::match(
1258
        cxxRecordDecl(hasName("ContainsArray"), unless(isImplicit()))
1259
            .bind("rec"),
1260
        AST2->getASTContext());
1261
    EXPECT_EQ(BN.size(), 1u);
1262

1263
    EXPECT_EQ(dumpASTString(TK_AsIs, BN[0].getNodeAs<Decl>("rec")),
1264
              R"cpp(
1265
CXXRecordDecl 'ContainsArray'
1266
|-CXXRecordDecl 'ContainsArray'
1267
|-FieldDecl 'arr'
1268
|-FieldDecl 'irr'
1269
|-CXXMethodDecl 'operator='
1270
| |-ParmVarDecl ''
1271
| `-CompoundStmt
1272
|   |-ForStmt
1273
|   | |-DeclStmt
1274
|   | | `-VarDecl '__i0'
1275
|   | |   `-IntegerLiteral
1276
|   | |-<<<NULL>>>
1277
|   | |-BinaryOperator
1278
|   | | |-ImplicitCastExpr
1279
|   | | | `-DeclRefExpr '__i0'
1280
|   | | `-IntegerLiteral
1281
|   | |-UnaryOperator
1282
|   | | `-DeclRefExpr '__i0'
1283
|   | `-CXXMemberCallExpr
1284
|   |   |-MemberExpr
1285
|   |   | `-ArraySubscriptExpr
1286
|   |   |   |-ImplicitCastExpr
1287
|   |   |   | `-MemberExpr
1288
|   |   |   |   `-CXXThisExpr
1289
|   |   |   `-ImplicitCastExpr
1290
|   |   |     `-DeclRefExpr '__i0'
1291
|   |   `-ArraySubscriptExpr
1292
|   |     |-ImplicitCastExpr
1293
|   |     | `-MemberExpr
1294
|   |     |   `-DeclRefExpr ''
1295
|   |     `-ImplicitCastExpr
1296
|   |       `-DeclRefExpr '__i0'
1297
|   |-CallExpr
1298
|   | |-ImplicitCastExpr
1299
|   | | `-DeclRefExpr '__builtin_memcpy'
1300
|   | |-ImplicitCastExpr
1301
|   | | `-UnaryOperator
1302
|   | |   `-MemberExpr
1303
|   | |     `-CXXThisExpr
1304
|   | |-ImplicitCastExpr
1305
|   | | `-UnaryOperator
1306
|   | |   `-MemberExpr
1307
|   | |     `-DeclRefExpr ''
1308
|   | `-IntegerLiteral
1309
|   `-ReturnStmt
1310
|     `-UnaryOperator
1311
|       `-CXXThisExpr
1312
|-CXXConstructorDecl 'ContainsArray'
1313
| `-ParmVarDecl ''
1314
|-CXXDestructorDecl '~ContainsArray'
1315
| `-CompoundStmt
1316
`-CXXConstructorDecl 'ContainsArray'
1317
  |-CXXCtorInitializer 'arr'
1318
  | `-CXXConstructExpr
1319
  `-CompoundStmt
1320
)cpp");
1321

1322
    EXPECT_EQ(dumpASTString(TK_IgnoreUnlessSpelledInSource,
1323
                            BN[0].getNodeAs<Decl>("rec")),
1324
              R"cpp(
1325
CXXRecordDecl 'ContainsArray'
1326
|-FieldDecl 'arr'
1327
|-FieldDecl 'irr'
1328
`-CXXMethodDecl 'operator='
1329
  `-ParmVarDecl ''
1330
)cpp");
1331
  }
1332
  {
1333
    auto BN = ast_matchers::match(functionDecl(hasName("forLoop")).bind("func"),
1334
                                  AST2->getASTContext());
1335
    EXPECT_EQ(BN.size(), 1u);
1336

1337
    EXPECT_EQ(dumpASTString(TK_AsIs, BN[0].getNodeAs<Decl>("func")),
1338
              R"cpp(
1339
FunctionDecl 'forLoop'
1340
`-CompoundStmt
1341
  |-DeclStmt
1342
  | `-VarDecl 'arr'
1343
  |-CXXForRangeStmt
1344
  | |-<<<NULL>>>
1345
  | |-DeclStmt
1346
  | | `-VarDecl '__range1'
1347
  | |   `-DeclRefExpr 'arr'
1348
  | |-DeclStmt
1349
  | | `-VarDecl '__begin1'
1350
  | |   `-ImplicitCastExpr
1351
  | |     `-DeclRefExpr '__range1'
1352
  | |-DeclStmt
1353
  | | `-VarDecl '__end1'
1354
  | |   `-BinaryOperator
1355
  | |     |-ImplicitCastExpr
1356
  | |     | `-DeclRefExpr '__range1'
1357
  | |     `-IntegerLiteral
1358
  | |-BinaryOperator
1359
  | | |-ImplicitCastExpr
1360
  | | | `-DeclRefExpr '__begin1'
1361
  | | `-ImplicitCastExpr
1362
  | |   `-DeclRefExpr '__end1'
1363
  | |-UnaryOperator
1364
  | | `-DeclRefExpr '__begin1'
1365
  | |-DeclStmt
1366
  | | `-VarDecl 'i'
1367
  | |   `-ImplicitCastExpr
1368
  | |     `-UnaryOperator
1369
  | |       `-ImplicitCastExpr
1370
  | |         `-DeclRefExpr '__begin1'
1371
  | `-CompoundStmt
1372
  `-CXXForRangeStmt
1373
    |-DeclStmt
1374
    | `-VarDecl 'a'
1375
    |   `-DeclRefExpr 'arr'
1376
    |-DeclStmt
1377
    | `-VarDecl '__range1'
1378
    |   `-DeclRefExpr 'a'
1379
    |-DeclStmt
1380
    | `-VarDecl '__begin1'
1381
    |   `-ImplicitCastExpr
1382
    |     `-DeclRefExpr '__range1'
1383
    |-DeclStmt
1384
    | `-VarDecl '__end1'
1385
    |   `-BinaryOperator
1386
    |     |-ImplicitCastExpr
1387
    |     | `-DeclRefExpr '__range1'
1388
    |     `-IntegerLiteral
1389
    |-BinaryOperator
1390
    | |-ImplicitCastExpr
1391
    | | `-DeclRefExpr '__begin1'
1392
    | `-ImplicitCastExpr
1393
    |   `-DeclRefExpr '__end1'
1394
    |-UnaryOperator
1395
    | `-DeclRefExpr '__begin1'
1396
    |-DeclStmt
1397
    | `-VarDecl 'i'
1398
    |   `-ImplicitCastExpr
1399
    |     `-UnaryOperator
1400
    |       `-ImplicitCastExpr
1401
    |         `-DeclRefExpr '__begin1'
1402
    `-CompoundStmt
1403
)cpp");
1404

1405
    EXPECT_EQ(dumpASTString(TK_IgnoreUnlessSpelledInSource,
1406
                            BN[0].getNodeAs<Decl>("func")),
1407
              R"cpp(
1408
FunctionDecl 'forLoop'
1409
`-CompoundStmt
1410
  |-DeclStmt
1411
  | `-VarDecl 'arr'
1412
  |-CXXForRangeStmt
1413
  | |-<<<NULL>>>
1414
  | |-VarDecl 'i'
1415
  | |-DeclRefExpr 'arr'
1416
  | `-CompoundStmt
1417
  `-CXXForRangeStmt
1418
    |-DeclStmt
1419
    | `-VarDecl 'a'
1420
    |   `-DeclRefExpr 'arr'
1421
    |-VarDecl 'i'
1422
    |-DeclRefExpr 'a'
1423
    `-CompoundStmt
1424
)cpp");
1425
  }
1426
  {
1427
    auto BN = ast_matchers::match(
1428
        cxxRecordDecl(hasName("DefaultedAndDeleted"), unless(isImplicit()))
1429
            .bind("rec"),
1430
        AST2->getASTContext());
1431
    EXPECT_EQ(BN.size(), 1u);
1432

1433
    EXPECT_EQ(dumpASTString(TK_AsIs, BN[0].getNodeAs<Decl>("rec")),
1434
              R"cpp(
1435
CXXRecordDecl 'DefaultedAndDeleted'
1436
|-CXXRecordDecl 'DefaultedAndDeleted'
1437
|-FieldDecl 'nt'
1438
|-CXXConstructorDecl 'DefaultedAndDeleted'
1439
| |-CXXCtorInitializer 'nt'
1440
| | `-CXXConstructExpr
1441
| `-CompoundStmt
1442
|-CXXDestructorDecl '~DefaultedAndDeleted'
1443
| `-CompoundStmt
1444
|-CXXConstructorDecl 'DefaultedAndDeleted'
1445
| `-ParmVarDecl ''
1446
|-CXXMethodDecl 'operator='
1447
| |-ParmVarDecl ''
1448
| `-CompoundStmt
1449
|   |-CXXMemberCallExpr
1450
|   | |-MemberExpr
1451
|   | | `-MemberExpr
1452
|   | |   `-CXXThisExpr
1453
|   | `-MemberExpr
1454
|   |   `-DeclRefExpr ''
1455
|   `-ReturnStmt
1456
|     `-UnaryOperator
1457
|       `-CXXThisExpr
1458
|-CXXConstructorDecl 'DefaultedAndDeleted'
1459
| `-ParmVarDecl ''
1460
`-CXXMethodDecl 'operator='
1461
  `-ParmVarDecl ''
1462
)cpp");
1463

1464
    EXPECT_EQ(dumpASTString(TK_IgnoreUnlessSpelledInSource,
1465
                            BN[0].getNodeAs<Decl>("rec")),
1466
              R"cpp(
1467
CXXRecordDecl 'DefaultedAndDeleted'
1468
|-FieldDecl 'nt'
1469
|-CXXConstructorDecl 'DefaultedAndDeleted'
1470
|-CXXDestructorDecl '~DefaultedAndDeleted'
1471
|-CXXConstructorDecl 'DefaultedAndDeleted'
1472
| `-ParmVarDecl ''
1473
|-CXXMethodDecl 'operator='
1474
| `-ParmVarDecl ''
1475
|-CXXConstructorDecl 'DefaultedAndDeleted'
1476
| `-ParmVarDecl ''
1477
`-CXXMethodDecl 'operator='
1478
  `-ParmVarDecl ''
1479
)cpp");
1480
  }
1481
  {
1482
    auto BN = ast_matchers::match(
1483
        callExpr(callee(functionDecl(hasName("hasDefaultArg"))))
1484
            .bind("funcCall"),
1485
        AST2->getASTContext());
1486
    EXPECT_EQ(BN.size(), 1u);
1487

1488
    EXPECT_EQ(dumpASTString(TK_AsIs, BN[0].getNodeAs<CallExpr>("funcCall")),
1489
              R"cpp(
1490
CallExpr
1491
|-ImplicitCastExpr
1492
| `-DeclRefExpr 'hasDefaultArg'
1493
|-IntegerLiteral
1494
`-CXXDefaultArgExpr
1495
  `-IntegerLiteral
1496
)cpp");
1497
    EXPECT_EQ(dumpASTString(TK_IgnoreUnlessSpelledInSource,
1498
                            BN[0].getNodeAs<CallExpr>("funcCall")),
1499
              R"cpp(
1500
CallExpr
1501
|-DeclRefExpr 'hasDefaultArg'
1502
`-IntegerLiteral
1503
)cpp");
1504
  }
1505

1506
  {
1507
    auto FN = ast_matchers::match(
1508
        functionDecl(hasName("decomposition"),
1509
                     hasDescendant(decompositionDecl().bind("decomp"))),
1510
        AST2->getASTContext());
1511
    EXPECT_EQ(FN.size(), 1u);
1512

1513
    EXPECT_EQ(
1514
        dumpASTString(TK_AsIs, FN[0].getNodeAs<DecompositionDecl>("decomp")),
1515
        R"cpp(
1516
DecompositionDecl ''
1517
|-DeclRefExpr 'arr'
1518
|-BindingDecl 'f'
1519
| `-ArraySubscriptExpr
1520
|   |-ImplicitCastExpr
1521
|   | `-DeclRefExpr ''
1522
|   `-IntegerLiteral
1523
|-BindingDecl 's'
1524
| `-ArraySubscriptExpr
1525
|   |-ImplicitCastExpr
1526
|   | `-DeclRefExpr ''
1527
|   `-IntegerLiteral
1528
`-BindingDecl 't'
1529
  `-ArraySubscriptExpr
1530
    |-ImplicitCastExpr
1531
    | `-DeclRefExpr ''
1532
    `-IntegerLiteral
1533
)cpp");
1534

1535
    EXPECT_EQ(dumpASTString(TK_IgnoreUnlessSpelledInSource,
1536
                            FN[0].getNodeAs<DecompositionDecl>("decomp")),
1537
              R"cpp(
1538
DecompositionDecl ''
1539
|-DeclRefExpr 'arr'
1540
|-BindingDecl 'f'
1541
|-BindingDecl 's'
1542
`-BindingDecl 't'
1543
)cpp");
1544
  }
1545

1546
  {
1547
    auto FN = ast_matchers::match(
1548
        functionDecl(hasName("decompTuple"),
1549
                     hasDescendant(decompositionDecl().bind("decomp"))),
1550
        AST2->getASTContext());
1551
    EXPECT_EQ(FN.size(), 1u);
1552

1553
    EXPECT_EQ(
1554
        dumpASTString(TK_AsIs, FN[0].getNodeAs<DecompositionDecl>("decomp")),
1555
        R"cpp(
1556
DecompositionDecl ''
1557
|-CXXConstructExpr
1558
| `-ImplicitCastExpr
1559
|   `-DeclRefExpr 'p'
1560
|-BindingDecl 'a'
1561
| |-VarDecl 'a'
1562
| | `-CallExpr
1563
| |   |-ImplicitCastExpr
1564
| |   | `-DeclRefExpr 'get'
1565
| |   `-ImplicitCastExpr
1566
| |     `-DeclRefExpr ''
1567
| `-DeclRefExpr 'a'
1568
`-BindingDecl 'b'
1569
  |-VarDecl 'b'
1570
  | `-CallExpr
1571
  |   |-ImplicitCastExpr
1572
  |   | `-DeclRefExpr 'get'
1573
  |   `-ImplicitCastExpr
1574
  |     `-DeclRefExpr ''
1575
  `-DeclRefExpr 'b'
1576
)cpp");
1577

1578
    EXPECT_EQ(dumpASTString(TK_IgnoreUnlessSpelledInSource,
1579
                            FN[0].getNodeAs<DecompositionDecl>("decomp")),
1580
              R"cpp(
1581
DecompositionDecl ''
1582
|-DeclRefExpr 'p'
1583
|-BindingDecl 'a'
1584
`-BindingDecl 'b'
1585
)cpp");
1586
  }
1587
}
1588

1589
TEST(Traverse, IgnoreUnlessSpelledInSourceTemplateInstantiations) {
1590

1591
  auto AST = buildASTFromCode(R"cpp(
1592
template<typename T>
1593
struct TemplStruct {
1594
  TemplStruct() {}
1595
  ~TemplStruct() {}
1596

1597
private:
1598
  T m_t;
1599
};
1600

1601
template<typename T>
1602
T timesTwo(T input)
1603
{
1604
  return input * 2;
1605
}
1606

1607
void instantiate()
1608
{
1609
  TemplStruct<int> ti;
1610
  TemplStruct<double> td;
1611
  (void)timesTwo<int>(2);
1612
  (void)timesTwo<double>(2);
1613
}
1614

1615
template class TemplStruct<float>;
1616

1617
extern template class TemplStruct<long>;
1618

1619
template<> class TemplStruct<bool> {
1620
  TemplStruct() {}
1621
  ~TemplStruct() {}
1622

1623
  void foo() {}
1624
private:
1625
  bool m_t;
1626
};
1627

1628
// Explicit instantiation of template functions do not appear in the AST
1629
template float timesTwo(float);
1630

1631
template<> bool timesTwo<bool>(bool) {
1632
  return true;
1633
}
1634
)cpp");
1635
  {
1636
    auto BN = ast_matchers::match(
1637
        classTemplateDecl(hasName("TemplStruct")).bind("rec"),
1638
        AST->getASTContext());
1639
    EXPECT_EQ(BN.size(), 1u);
1640

1641
    EXPECT_EQ(dumpASTString(TK_IgnoreUnlessSpelledInSource,
1642
                            BN[0].getNodeAs<Decl>("rec")),
1643
              R"cpp(
1644
ClassTemplateDecl 'TemplStruct'
1645
|-TemplateTypeParmDecl 'T'
1646
`-CXXRecordDecl 'TemplStruct'
1647
  |-CXXConstructorDecl 'TemplStruct<T>'
1648
  | `-CompoundStmt
1649
  |-CXXDestructorDecl '~TemplStruct<T>'
1650
  | `-CompoundStmt
1651
  |-AccessSpecDecl
1652
  `-FieldDecl 'm_t'
1653
)cpp");
1654

1655
    EXPECT_EQ(dumpASTString(TK_AsIs, BN[0].getNodeAs<Decl>("rec")),
1656
              R"cpp(
1657
ClassTemplateDecl 'TemplStruct'
1658
|-TemplateTypeParmDecl 'T'
1659
|-CXXRecordDecl 'TemplStruct'
1660
| |-CXXRecordDecl 'TemplStruct'
1661
| |-CXXConstructorDecl 'TemplStruct<T>'
1662
| | `-CompoundStmt
1663
| |-CXXDestructorDecl '~TemplStruct<T>'
1664
| | `-CompoundStmt
1665
| |-AccessSpecDecl
1666
| `-FieldDecl 'm_t'
1667
|-ClassTemplateSpecializationDecl 'TemplStruct'
1668
| |-TemplateArgument type int
1669
| | `-BuiltinType
1670
| |-CXXRecordDecl 'TemplStruct'
1671
| |-CXXConstructorDecl 'TemplStruct'
1672
| | `-CompoundStmt
1673
| |-CXXDestructorDecl '~TemplStruct'
1674
| | `-CompoundStmt
1675
| |-AccessSpecDecl
1676
| |-FieldDecl 'm_t'
1677
| `-CXXConstructorDecl 'TemplStruct'
1678
|   `-ParmVarDecl ''
1679
|-ClassTemplateSpecializationDecl 'TemplStruct'
1680
| |-TemplateArgument type double
1681
| | `-BuiltinType
1682
| |-CXXRecordDecl 'TemplStruct'
1683
| |-CXXConstructorDecl 'TemplStruct'
1684
| | `-CompoundStmt
1685
| |-CXXDestructorDecl '~TemplStruct'
1686
| | `-CompoundStmt
1687
| |-AccessSpecDecl
1688
| |-FieldDecl 'm_t'
1689
| `-CXXConstructorDecl 'TemplStruct'
1690
|   `-ParmVarDecl ''
1691
|-ClassTemplateSpecializationDecl 'TemplStruct'
1692
| |-TemplateArgument type float
1693
| | `-BuiltinType
1694
| |-CXXRecordDecl 'TemplStruct'
1695
| |-CXXConstructorDecl 'TemplStruct'
1696
| | `-CompoundStmt
1697
| |-CXXDestructorDecl '~TemplStruct'
1698
| | `-CompoundStmt
1699
| |-AccessSpecDecl
1700
| `-FieldDecl 'm_t'
1701
|-ClassTemplateSpecializationDecl 'TemplStruct'
1702
| |-TemplateArgument type long
1703
| | `-BuiltinType
1704
| |-CXXRecordDecl 'TemplStruct'
1705
| |-CXXConstructorDecl 'TemplStruct'
1706
| |-CXXDestructorDecl '~TemplStruct'
1707
| |-AccessSpecDecl
1708
| `-FieldDecl 'm_t'
1709
`-ClassTemplateSpecializationDecl 'TemplStruct'
1710
  |-TemplateArgument type _Bool
1711
  | `-BuiltinType
1712
  |-CXXRecordDecl 'TemplStruct'
1713
  |-CXXConstructorDecl 'TemplStruct'
1714
  | `-CompoundStmt
1715
  |-CXXDestructorDecl '~TemplStruct'
1716
  | `-CompoundStmt
1717
  |-CXXMethodDecl 'foo'
1718
  | `-CompoundStmt
1719
  |-AccessSpecDecl
1720
  `-FieldDecl 'm_t'
1721
)cpp");
1722
  }
1723
  {
1724
    auto BN = ast_matchers::match(
1725
        classTemplateSpecializationDecl(
1726
            hasTemplateArgument(
1727
                0, templateArgument(refersToType(asString("_Bool")))))
1728
            .bind("templSpec"),
1729
        AST->getASTContext());
1730
    EXPECT_EQ(BN.size(), 1u);
1731

1732
    EXPECT_EQ(dumpASTString(TK_AsIs, BN[0].getNodeAs<Decl>("templSpec")),
1733
              R"cpp(
1734
ClassTemplateSpecializationDecl 'TemplStruct'
1735
|-TemplateArgument type _Bool
1736
| `-BuiltinType
1737
|-CXXRecordDecl 'TemplStruct'
1738
|-CXXConstructorDecl 'TemplStruct'
1739
| `-CompoundStmt
1740
|-CXXDestructorDecl '~TemplStruct'
1741
| `-CompoundStmt
1742
|-CXXMethodDecl 'foo'
1743
| `-CompoundStmt
1744
|-AccessSpecDecl
1745
`-FieldDecl 'm_t'
1746
)cpp");
1747

1748
    EXPECT_EQ(dumpASTString(TK_IgnoreUnlessSpelledInSource,
1749
                            BN[0].getNodeAs<Decl>("templSpec")),
1750
              R"cpp(
1751
ClassTemplateSpecializationDecl 'TemplStruct'
1752
|-TemplateArgument type _Bool
1753
| `-BuiltinType
1754
|-CXXConstructorDecl 'TemplStruct'
1755
| `-CompoundStmt
1756
|-CXXDestructorDecl '~TemplStruct'
1757
| `-CompoundStmt
1758
|-CXXMethodDecl 'foo'
1759
| `-CompoundStmt
1760
|-AccessSpecDecl
1761
`-FieldDecl 'm_t'
1762
)cpp");
1763
  }
1764
  {
1765
    auto BN = ast_matchers::match(
1766
        functionTemplateDecl(hasName("timesTwo")).bind("fn"),
1767
        AST->getASTContext());
1768
    EXPECT_EQ(BN.size(), 1u);
1769

1770
    EXPECT_EQ(dumpASTString(TK_IgnoreUnlessSpelledInSource,
1771
                            BN[0].getNodeAs<Decl>("fn")),
1772
              R"cpp(
1773
FunctionTemplateDecl 'timesTwo'
1774
|-TemplateTypeParmDecl 'T'
1775
`-FunctionDecl 'timesTwo'
1776
  |-ParmVarDecl 'input'
1777
  `-CompoundStmt
1778
    `-ReturnStmt
1779
      `-BinaryOperator
1780
        |-DeclRefExpr 'input'
1781
        `-IntegerLiteral
1782
)cpp");
1783

1784
    EXPECT_EQ(dumpASTString(TK_AsIs, BN[0].getNodeAs<Decl>("fn")),
1785
              R"cpp(
1786
FunctionTemplateDecl 'timesTwo'
1787
|-TemplateTypeParmDecl 'T'
1788
|-FunctionDecl 'timesTwo'
1789
| |-ParmVarDecl 'input'
1790
| `-CompoundStmt
1791
|   `-ReturnStmt
1792
|     `-BinaryOperator
1793
|       |-DeclRefExpr 'input'
1794
|       `-IntegerLiteral
1795
|-FunctionDecl 'timesTwo'
1796
| |-TemplateArgument type int
1797
| | `-BuiltinType
1798
| |-ParmVarDecl 'input'
1799
| `-CompoundStmt
1800
|   `-ReturnStmt
1801
|     `-BinaryOperator
1802
|       |-ImplicitCastExpr
1803
|       | `-DeclRefExpr 'input'
1804
|       `-IntegerLiteral
1805
|-FunctionDecl 'timesTwo'
1806
| |-TemplateArgument type double
1807
| | `-BuiltinType
1808
| |-ParmVarDecl 'input'
1809
| `-CompoundStmt
1810
|   `-ReturnStmt
1811
|     `-BinaryOperator
1812
|       |-ImplicitCastExpr
1813
|       | `-DeclRefExpr 'input'
1814
|       `-ImplicitCastExpr
1815
|         `-IntegerLiteral
1816
|-FunctionDecl 'timesTwo'
1817
| |-TemplateArgument type float
1818
| | `-BuiltinType
1819
| |-ParmVarDecl 'input'
1820
| `-CompoundStmt
1821
|   `-ReturnStmt
1822
|     `-BinaryOperator
1823
|       |-ImplicitCastExpr
1824
|       | `-DeclRefExpr 'input'
1825
|       `-ImplicitCastExpr
1826
|         `-IntegerLiteral
1827
|-FunctionDecl 'timesTwo'
1828
| |-TemplateArgument type _Bool
1829
| | `-BuiltinType
1830
| |-ParmVarDecl ''
1831
| `-CompoundStmt
1832
|   `-ReturnStmt
1833
|     `-CXXBoolLiteralExpr
1834
`-FunctionDecl 'timesTwo'
1835
  |-TemplateArgument type _Bool
1836
  | `-BuiltinType
1837
  `-ParmVarDecl 'input'
1838
)cpp");
1839
  }
1840
  {
1841
    auto BN = ast_matchers::match(
1842
        classTemplateSpecializationDecl(
1843
            hasName("TemplStruct"),
1844
            hasTemplateArgument(
1845
                0, templateArgument(refersToType(asString("float")))),
1846
            hasParent(translationUnitDecl()))
1847
            .bind("rec"),
1848
        AST->getASTContext());
1849
    EXPECT_EQ(BN.size(), 1u);
1850

1851
    EXPECT_EQ(dumpASTString(TK_IgnoreUnlessSpelledInSource,
1852
                            BN[0].getNodeAs<Decl>("rec")),
1853
              R"cpp(
1854
ClassTemplateSpecializationDecl 'TemplStruct'
1855
`-TemplateArgument type float
1856
  `-BuiltinType
1857
)cpp");
1858

1859
    EXPECT_EQ(dumpASTString(TK_AsIs, BN[0].getNodeAs<Decl>("rec")),
1860
              R"cpp(
1861
ClassTemplateSpecializationDecl 'TemplStruct'
1862
|-TemplateArgument type float
1863
| `-BuiltinType
1864
|-CXXRecordDecl 'TemplStruct'
1865
|-CXXConstructorDecl 'TemplStruct'
1866
| `-CompoundStmt
1867
|-CXXDestructorDecl '~TemplStruct'
1868
| `-CompoundStmt
1869
|-AccessSpecDecl
1870
`-FieldDecl 'm_t'
1871
)cpp");
1872
  }
1873
}
1874

1875
TEST(Traverse, CXXRewrittenBinaryOperator) {
1876

1877
  auto AST = buildASTFromCodeWithArgs(R"cpp(
1878
namespace std {
1879
struct strong_ordering {
1880
  int n;
1881
  constexpr operator int() const { return n; }
1882
  static const strong_ordering equal, greater, less;
1883
};
1884
constexpr strong_ordering strong_ordering::equal = {0};
1885
constexpr strong_ordering strong_ordering::greater = {1};
1886
constexpr strong_ordering strong_ordering::less = {-1};
1887
}
1888

1889
struct HasSpaceshipMem {
1890
  int a;
1891
  constexpr auto operator<=>(const HasSpaceshipMem&) const = default;
1892
};
1893

1894
void binop()
1895
{
1896
    HasSpaceshipMem hs1, hs2;
1897
    if (hs1 < hs2)
1898
        return;
1899
}
1900
)cpp",
1901
                                      {"-std=c++20"});
1902
  {
1903
    auto BN = ast_matchers::match(cxxRewrittenBinaryOperator().bind("binop"),
1904
                                  AST->getASTContext());
1905
    EXPECT_EQ(BN.size(), 1u);
1906

1907
    EXPECT_EQ(dumpASTString(TK_AsIs, BN[0].getNodeAs<Stmt>("binop")),
1908
              R"cpp(
1909
CXXRewrittenBinaryOperator
1910
`-BinaryOperator
1911
  |-ImplicitCastExpr
1912
  | `-CXXMemberCallExpr
1913
  |   `-MemberExpr
1914
  |     `-ImplicitCastExpr
1915
  |       `-MaterializeTemporaryExpr
1916
  |         `-CXXOperatorCallExpr
1917
  |           |-ImplicitCastExpr
1918
  |           | `-DeclRefExpr 'operator<=>'
1919
  |           |-ImplicitCastExpr
1920
  |           | `-DeclRefExpr 'hs1'
1921
  |           `-ImplicitCastExpr
1922
  |             `-DeclRefExpr 'hs2'
1923
  `-IntegerLiteral
1924
)cpp");
1925
    EXPECT_EQ(dumpASTString(TK_IgnoreUnlessSpelledInSource,
1926
                            BN[0].getNodeAs<Stmt>("binop")),
1927
              R"cpp(
1928
CXXRewrittenBinaryOperator
1929
|-DeclRefExpr 'hs1'
1930
`-DeclRefExpr 'hs2'
1931
)cpp");
1932
  }
1933
}
1934

1935
} // namespace clang
1936