clang-tools-extra/include-cleaner/unittests/WalkASTTest.cpp

   1 //===--- WalkASTTest.cpp ------------------------------------------- C++-*-===//
   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 #include "AnalysisInternal.h"
   9 #include "clang-include-cleaner/Types.h"
  10 #include "clang/AST/ASTContext.h"
  11 #include "clang/AST/Decl.h"
  12 #include "clang/AST/DeclBase.h"
  13 #include "clang/Basic/Diagnostic.h"
  14 #include "clang/Basic/DiagnosticOptions.h"
  15 #include "clang/Basic/FileManager.h"
  16 #include "clang/Basic/SourceLocation.h"
  17 #include "clang/Frontend/TextDiagnostic.h"
  18 #include "clang/Testing/TestAST.h"
  19 #include "llvm/ADT/STLExtras.h"
  20 #include "llvm/ADT/StringRef.h"
  21 #include "llvm/Support/Error.h"
  22 #include "llvm/Support/ScopedPrinter.h"
  23 #include "llvm/Support/raw_ostream.h"
  24 #include "llvm/Testing/Annotations/Annotations.h"
  25 #include "gmock/gmock.h"
  26 #include "gtest/gtest.h"
  27 #include <cstddef>
  28 #include <string>
  29 #include <unordered_map>
  30 #include <utility>
  31 #include <vector>
  32
  33 namespace clang::include_cleaner {
  34 namespace {
  35 using testing::ElementsAre;
  36
  37 // Specifies a test of which symbols are referenced by a piece of code.
  38 // Target should contain points annotated with the reference kind.
  39 // Example:
  40 //   Target:      int $explicit^foo();
  41 //   Referencing: int x = ^foo();
  42 // There must be exactly one referencing location marked.
  43 // Returns target decls.
  44 std::vector<Decl::Kind> testWalk(llvm::StringRef TargetCode,
  45                                  llvm::StringRef ReferencingCode) {
  46   llvm::Annotations Target(TargetCode);
  47   llvm::Annotations Referencing(ReferencingCode);
  48
  49   TestInputs Inputs(Referencing.code());
  50   Inputs.ExtraFiles["target.h"] = Target.code().str();
  51   Inputs.ExtraArgs.push_back("-include");
  52   Inputs.ExtraArgs.push_back("target.h");
  53   Inputs.ExtraArgs.push_back("-std=c++20");
  54   TestAST AST(Inputs);
  55   const auto &SM = AST.sourceManager();
  56
  57   // We're only going to record references from the nominated point,
  58   // to the target file.
  59   FileID ReferencingFile = SM.getMainFileID();
  60   SourceLocation ReferencingLoc =
  61       SM.getComposedLoc(ReferencingFile, Referencing.point());
  62   FileID TargetFile = SM.translateFile(
  63       llvm::cantFail(AST.fileManager().getFileRef("target.h")));
  64
  65   std::vector<Decl::Kind> TargetDecls;
  66   // Perform the walk, and capture the offsets of the referenced targets.
  67   std::unordered_map<RefType, std::vector<size_t>> ReferencedOffsets;
  68   for (Decl *D : AST.context().getTranslationUnitDecl()->decls()) {
  69     if (ReferencingFile != SM.getDecomposedExpansionLoc(D->getLocation()).first)
  70       continue;
  71     walkAST(*D, [&](SourceLocation Loc, NamedDecl &ND, RefType RT) {
  72       if (SM.getFileLoc(Loc) != ReferencingLoc)
  73         return;
  74       auto NDLoc = SM.getDecomposedLoc(SM.getFileLoc(ND.getLocation()));
  75       if (NDLoc.first != TargetFile)
  76         return;
  77       ReferencedOffsets[RT].push_back(NDLoc.second);
  78       TargetDecls.push_back(ND.getKind());
  79     });
  80   }
  81   for (auto &Entry : ReferencedOffsets)
  82     llvm::sort(Entry.second);
  83
  84   // Compare results to the expected points.
  85   // For each difference, show the target point in context, like a diagnostic.
  86   std::string DiagBuf;
  87   llvm::raw_string_ostream DiagOS(DiagBuf);
  88   auto *DiagOpts = new DiagnosticOptions();
  89   DiagOpts->ShowLevel = 0;
  90   DiagOpts->ShowNoteIncludeStack = 0;
  91   TextDiagnostic Diag(DiagOS, AST.context().getLangOpts(), DiagOpts);
  92   auto DiagnosePoint = [&](llvm::StringRef Message, unsigned Offset) {
  93     Diag.emitDiagnostic(
  94         FullSourceLoc(SM.getComposedLoc(TargetFile, Offset), SM),
  95         DiagnosticsEngine::Note, Message, {}, {});
  96   };
  97   for (auto RT : {RefType::Explicit, RefType::Implicit, RefType::Ambiguous}) {
  98     auto RTStr = llvm::to_string(RT);
  99     for (auto Expected : Target.points(RTStr))
 100       if (!llvm::is_contained(ReferencedOffsets[RT], Expected))
 101         DiagnosePoint("location not marked used with type " + RTStr, Expected);
 102     for (auto Actual : ReferencedOffsets[RT])
 103       if (!llvm::is_contained(Target.points(RTStr), Actual))
 104         DiagnosePoint("location unexpectedly used with type " + RTStr, Actual);
 105   }
 106
 107   // If there were any differences, we print the entire referencing code once.
 108   if (!DiagBuf.empty())
 109     ADD_FAILURE() << DiagBuf << "\nfrom code:\n" << ReferencingCode;
 110   return TargetDecls;
 111 }
 112
 113 TEST(WalkAST, DeclRef) {
 114   testWalk("int $explicit^x;", "int y = ^x;");
 115   testWalk("int $explicit^foo();", "int y = ^foo();");
 116   testWalk("namespace ns { int $explicit^x; }", "int y = ns::^x;");
 117   testWalk("struct S { static int x; };", "int y = S::^x;");
 118   // Canonical declaration only.
 119   testWalk("extern int $explicit^x; int x;", "int y = ^x;");
 120   // Return type of `foo` isn't used.
 121   testWalk("struct S{}; S $explicit^foo();", "auto bar() { return ^foo(); }");
 122 }
 123
 124 TEST(WalkAST, TagType) {
 125   testWalk("struct $explicit^S {};", "^S *y;");
 126   testWalk("enum $explicit^E {};", "^E *y;");
 127   testWalk("struct $explicit^S { static int x; };", "int y = ^S::x;");
 128   // One explicit call from the TypeLoc in constructor spelling, another
 129   // implicit reference through the constructor call.
 130   testWalk("struct $explicit^$implicit^S { static int x; };", "auto y = ^S();");
 131 }
 132
 133 TEST(WalkAST, ClassTemplates) {
 134   // Explicit instantiation and (partial) specialization references primary
 135   // template.
 136   EXPECT_THAT(testWalk("template<typename> struct $explicit^Foo{};",
 137                        "template struct ^Foo<int>;"),
 138               ElementsAre(Decl::CXXRecord));
 139   EXPECT_THAT(testWalk("template<typename> struct $explicit^Foo{};",
 140                        "template<> struct ^Foo<int> {};"),
 141               ElementsAre(Decl::CXXRecord));
 142   EXPECT_THAT(testWalk("template<typename> struct $explicit^Foo{};",
 143                        "template<typename T> struct ^Foo<T*> {};"),
 144               ElementsAre(Decl::CXXRecord));
 145
 146   // Implicit instantiations references most relevant template.
 147   EXPECT_THAT(
 148       testWalk("template<typename> struct $explicit^Foo;", "^Foo<int> x();"),
 149       ElementsAre(Decl::Kind::ClassTemplate));
 150   EXPECT_THAT(
 151       testWalk("template<typename> struct $explicit^Foo {};", "^Foo<int> x;"),
 152       ElementsAre(Decl::CXXRecord));
 153   EXPECT_THAT(testWalk(R"cpp(
 154     template<typename> struct Foo {};
 155     template<> struct $explicit^Foo<int> {};)cpp",
 156                        "^Foo<int> x;"),
 157               ElementsAre(Decl::ClassTemplateSpecialization));
 158   EXPECT_THAT(testWalk(R"cpp(
 159     template<typename> struct Foo {};
 160     template<typename T> struct $explicit^Foo<T*> {};)cpp",
 161                        "^Foo<int *> x;"),
 162               ElementsAre(Decl::ClassTemplatePartialSpecialization));
 163   // Incomplete instantiations don't have a specific specialization associated.
 164   EXPECT_THAT(testWalk(R"cpp(
 165     template<typename> struct $explicit^Foo;
 166     template<typename T> struct Foo<T*>;)cpp",
 167                        "^Foo<int *> x();"),
 168               ElementsAre(Decl::Kind::ClassTemplate));
 169   EXPECT_THAT(testWalk(R"cpp(
 170     template<typename> struct $explicit^Foo {};
 171     template struct Foo<int>;)cpp",
 172                        "^Foo<int> x;"),
 173               ElementsAre(Decl::CXXRecord));
 174   // FIXME: This is broken due to
 175   // https://github.com/llvm/llvm-project/issues/42259.
 176   EXPECT_THAT(testWalk(R"cpp(
 177     template<typename T> struct $explicit^Foo { Foo(T); };
 178     template<> struct Foo<int> { Foo(int); };)cpp",
 179                        "^Foo x(3);"),
 180               ElementsAre(Decl::ClassTemplate));
 181 }
 182 TEST(WalkAST, VarTemplates) {
 183   // Explicit instantiation and (partial) specialization references primary
 184   // template.
 185   // FIXME: Explicit instantiations has wrong source location, they point at the
 186   // primary template location (hence we drop the reference).
 187   EXPECT_THAT(
 188       testWalk("template<typename T> T Foo = 0;", "template int ^Foo<int>;"),
 189       ElementsAre());
 190   EXPECT_THAT(testWalk("template<typename T> T $explicit^Foo = 0;",
 191                        "template<> int ^Foo<int> = 2;"),
 192               ElementsAre(Decl::Var));
 193   EXPECT_THAT(testWalk("template<typename T> T $explicit^Foo = 0;",
 194                        "template<typename T> T* ^Foo<T*> = 1;"),
 195               ElementsAre(Decl::Var));
 196
 197   // Implicit instantiations references most relevant template.
 198   // FIXME: This points at implicit specialization, instead we should point to
 199   // pattern.
 200   EXPECT_THAT(testWalk(R"cpp(
 201     template <typename T> T $explicit^Foo = 0;)cpp",
 202                        "int z = ^Foo<int>;"),
 203               ElementsAre(Decl::VarTemplateSpecialization));
 204   EXPECT_THAT(testWalk(R"cpp(
 205     template<typename T> T Foo = 0;
 206     template<> int $explicit^Foo<int> = 1;)cpp",
 207                        "int x = ^Foo<int>;"),
 208               ElementsAre(Decl::VarTemplateSpecialization));
 209   // FIXME: This points at implicit specialization, instead we should point to
 210   // explicit partial specializaiton pattern.
 211   EXPECT_THAT(testWalk(R"cpp(
 212     template<typename T> T Foo = 0;
 213     template<typename T> T* $explicit^Foo<T*> = nullptr;)cpp",
 214                        "int *x = ^Foo<int *>;"),
 215               ElementsAre(Decl::VarTemplateSpecialization));
 216   EXPECT_THAT(testWalk(R"cpp(
 217     template<typename T> T $explicit^Foo = 0;
 218     template int Foo<int>;)cpp",
 219                        "int x = ^Foo<int>;"),
 220               ElementsAre(Decl::VarTemplateSpecialization));
 221 }
 222 TEST(WalkAST, FunctionTemplates) {
 223   // Explicit instantiation and (partial) specialization references primary
 224   // template.
 225   // FIXME: Explicit instantiations has wrong source location, they point at the
 226   // primary template location (hence we drop the reference).
 227   EXPECT_THAT(testWalk("template<typename T> void foo(T) {}",
 228                        "template void ^foo<int>(int);"),
 229               ElementsAre());
 230   // FIXME: Report specialized template as used from explicit specializations.
 231   EXPECT_THAT(testWalk("template<typename T> void foo(T);",
 232                        "template<> void ^foo<int>(int);"),
 233               ElementsAre());
 234   EXPECT_THAT(testWalk("template<typename T> void foo(T) {}",
 235                        "template<typename T> void ^foo(T*) {}"),
 236               ElementsAre());
 237
 238   // Implicit instantiations references most relevant template.
 239   EXPECT_THAT(testWalk(R"cpp(
 240     template <typename T> void $explicit^foo() {})cpp",
 241                        "auto x = []{ ^foo<int>(); };"),
 242               ElementsAre(Decl::FunctionTemplate));
 243   // FIXME: DeclRefExpr points at primary template, not the specialization.
 244   EXPECT_THAT(testWalk(R"cpp(
 245     template<typename T> void $explicit^foo() {}
 246     template<> void foo<int>(){})cpp",
 247                        "auto x = []{ ^foo<int>(); };"),
 248               ElementsAre(Decl::FunctionTemplate));
 249   EXPECT_THAT(testWalk(R"cpp(
 250     template<typename T> void $explicit^foo() {};
 251     template void foo<int>();)cpp",
 252                        "auto x = [] { ^foo<int>(); };"),
 253               ElementsAre(Decl::FunctionTemplate));
 254 }
 255 TEST(WalkAST, TemplateSpecializationsFromUsingDecl) {
 256   // Class templates
 257   testWalk(R"cpp(
 258 namespace ns {
 259 template<class T> class $ambiguous^Z {};      // primary template
 260 template<class T> class $ambiguous^Z<T*> {};  // partial specialization
 261 template<> class $ambiguous^Z<int> {};        // full specialization
 262 }
 263   )cpp",
 264            "using ns::^Z;");
 265
 266   // Var templates
 267   testWalk(R"cpp(
 268 namespace ns {
 269 template<class T> T $ambiguous^foo;      // primary template
 270 template<class T> T $ambiguous^foo<T*>;  // partial specialization
 271 template<> int* $ambiguous^foo<int>;     // full specialization
 272 }
 273   )cpp",
 274            "using ns::^foo;");
 275   // Function templates, no partial template specializations.
 276   testWalk(R"cpp(
 277 namespace ns {
 278 template<class T> void $ambiguous^function(T);  // primary template
 279 template<> void $ambiguous^function(int);       // full specialization
 280 }
 281   )cpp",
 282            "using ns::^function;");
 283 }
 284
 285 TEST(WalkAST, Alias) {
 286   testWalk(R"cpp(
 287     namespace ns { int x; }
 288     using ns::$explicit^x;
 289   )cpp",
 290            "int y = ^x;");
 291   testWalk("using $explicit^foo = int;", "^foo x;");
 292   testWalk("struct S {}; using $explicit^foo = S;", "^foo x;");
 293   testWalk(R"cpp(
 294     template<typename> struct Foo {};
 295     template<> struct Foo<int> {};
 296     namespace ns { using ::$explicit^Foo; })cpp",
 297            "ns::^Foo<int> x;");
 298   testWalk(R"cpp(
 299     template<typename> struct Foo {};
 300     namespace ns { using ::Foo; }
 301     template<> struct ns::$explicit^Foo<int> {};)cpp",
 302            "^Foo<int> x;");
 303   // AST doesn't have enough information to figure out whether specialization
 304   // happened through an exported type or not. So err towards attributing use to
 305   // the using-decl, specializations on the exported type should be rare and
 306   // they're not permitted on type-aliases.
 307   testWalk(R"cpp(
 308     template<typename> struct Foo {};
 309     namespace ns { using ::$explicit^Foo; }
 310     template<> struct ns::Foo<int> {};)cpp",
 311            "ns::^Foo<int> x;");
 312   testWalk(R"cpp(
 313     namespace ns { enum class foo { bar }; }
 314     using ns::foo;)cpp",
 315            "auto x = foo::^bar;");
 316   testWalk(R"cpp(
 317     namespace ns { enum foo { bar }; }
 318     using ns::foo::$explicit^bar;)cpp",
 319            "auto x = ^bar;");
 320 }
 321
 322 TEST(WalkAST, Using) {
 323   // We should report unused overloads as ambiguous.
 324   testWalk(R"cpp(
 325     namespace ns {
 326       void $explicit^x(); void $ambiguous^x(int); void $ambiguous^x(char);
 327     })cpp",
 328            "using ns::^x; void foo() { x(); }");
 329   testWalk(R"cpp(
 330     namespace ns {
 331       void $ambiguous^x(); void $ambiguous^x(int); void $ambiguous^x(char);
 332     })cpp",
 333            "using ns::^x;");
 334   testWalk("namespace ns { struct S; } using ns::$explicit^S;", "^S *s;");
 335
 336   testWalk(R"cpp(
 337     namespace ns {
 338       template<class T>
 339       class $ambiguous^Y {};
 340     })cpp",
 341            "using ns::^Y;");
 342   testWalk(R"cpp(
 343     namespace ns {
 344       template<class T>
 345       class Y {};
 346     }
 347     using ns::$explicit^Y;)cpp",
 348            "^Y<int> x;");
 349   testWalk("namespace ns { enum E {A}; } using enum ns::$explicit^E;",
 350            "auto x = ^A;");
 351 }
 352
 353 TEST(WalkAST, Namespaces) {
 354   testWalk("namespace ns { void x(); }", "using namespace ^ns;");
 355 }
 356
 357 TEST(WalkAST, TemplateNames) {
 358   testWalk("template<typename> struct $explicit^S {};", "^S<int> s;");
 359   // FIXME: Template decl has the wrong primary location for type-alias template
 360   // decls.
 361   testWalk(R"cpp(
 362       template <typename> struct S {};
 363       template <typename T> $explicit^using foo = S<T>;)cpp",
 364            "^foo<int> x;");
 365   testWalk(R"cpp(
 366       namespace ns {template <typename> struct S {}; }
 367       using ns::$explicit^S;)cpp",
 368            "^S<int> x;");
 369   testWalk(R"cpp(
 370       namespace ns {
 371         template <typename T> struct S { S(T);};
 372         template <typename T> S(T t) -> S<T>;
 373       }
 374       using ns::$explicit^S;)cpp",
 375            "^S x(123);");
 376   testWalk("template<typename> struct $explicit^S {};",
 377            R"cpp(
 378       template <template <typename> typename> struct X {};
 379       X<^S> x;)cpp");
 380   testWalk("template<typename T> struct $explicit^S { S(T); };", "^S s(42);");
 381 }
 382
 383 TEST(WalkAST, NestedTypes) {
 384   testWalk(R"cpp(
 385       struct Base { typedef int $implicit^a; };
 386       struct Derived : public Base {};)cpp",
 387            "void fun() { Derived::^a x; }");
 388   testWalk(R"cpp(
 389       struct Base { using $implicit^a = int; };
 390       struct Derived : public Base {};)cpp",
 391            "void fun() { Derived::^a x; }");
 392   testWalk(R"cpp(
 393       struct ns { struct a {}; };
 394       struct Base : public ns { using ns::$implicit^a; };
 395       struct Derived : public Base {};)cpp",
 396            "void fun() { Derived::^a x; }");
 397   testWalk(R"cpp(
 398       struct Base { struct $implicit^a {}; };
 399       struct Derived : public Base {};)cpp",
 400            "void fun() { Derived::^a x; }");
 401   testWalk("struct Base { struct $implicit^a {}; };",
 402            "struct Derived : public Base { ^a x; };");
 403   testWalk(R"cpp(
 404       struct Base { struct $implicit^a {}; };
 405       struct Derived : public Base {};
 406       struct SoDerived : public Derived {};
 407       )cpp",
 408            "void fun() { SoDerived::Derived::^a x; }");
 409 }
 410
 411 TEST(WalkAST, MemberExprs) {
 412   testWalk("struct S { static int f; };", "void foo() { S::^f; }");
 413   testWalk("struct B { static int f; }; struct S : B {};",
 414            "void foo() { S::^f; }");
 415   testWalk("struct B { static void f(); }; struct S : B {};",
 416            "void foo() { S::^f; }");
 417   testWalk("struct B { static void f(); }; ",
 418            "struct S : B { void foo() { ^f(); } };");
 419   testWalk("struct $implicit^S { void foo(); };", "void foo() { S{}.^foo(); }");
 420   testWalk(
 421       "struct S { void foo(); }; struct $implicit^X : S { using S::foo; };",
 422       "void foo() { X{}.^foo(); }");
 423   testWalk("struct Base { int a; }; struct $implicit^Derived : public Base {};",
 424            "void fun(Derived d) { d.^a; }");
 425   testWalk("struct Base { int a; }; struct $implicit^Derived : public Base {};",
 426            "void fun(Derived* d) { d->^a; }");
 427   testWalk("struct Base { int a; }; struct $implicit^Derived : public Base {};",
 428            "void fun(Derived& d) { d.^a; }");
 429   testWalk("struct Base { int a; }; struct $implicit^Derived : public Base {};",
 430            "void fun() { Derived().^a; }");
 431   testWalk("struct Base { int a; }; struct $implicit^Derived : public Base {};",
 432            "Derived foo(); void fun() { foo().^a; }");
 433   testWalk("struct Base { int a; }; struct $implicit^Derived : public Base {};",
 434            "Derived& foo(); void fun() { foo().^a; }");
 435   testWalk(R"cpp(
 436       template <typename T>
 437       struct unique_ptr {
 438         T *operator->();
 439       };
 440       struct $implicit^Foo { int a; };)cpp",
 441            "void test(unique_ptr<Foo> &V) { V->^a; }");
 442   testWalk(R"cpp(
 443       template <typename T>
 444       struct $implicit^unique_ptr {
 445         void release();
 446       };
 447       struct Foo {};)cpp",
 448            "void test(unique_ptr<Foo> &V) { V.^release(); }");
 449   // Respect the sugar type (typedef, using-type).
 450   testWalk(R"cpp(
 451       namespace ns { struct Foo { int a; }; }
 452       using $implicit^Bar = ns::Foo;)cpp",
 453            "void test(Bar b) { b.^a; }");
 454   testWalk(R"cpp(
 455       namespace ns { struct Foo { int a; }; }
 456       using ns::$implicit^Foo;)cpp",
 457            "void test(Foo b) { b.^a; }");
 458   testWalk(R"cpp(
 459       namespace ns { struct Foo { int a; }; }
 460       namespace ns2 { using Bar = ns::Foo; }
 461       using ns2::$implicit^Bar;
 462       )cpp",
 463            "void test(Bar b) { b.^a; }");
 464   testWalk(R"cpp(
 465       namespace ns { template<typename> struct Foo { int a; }; }
 466       using ns::$implicit^Foo;)cpp",
 467            "void k(Foo<int> b) { b.^a; }");
 468   // Test the dependent-type case (CXXDependentScopeMemberExpr)
 469   testWalk("template<typename T> struct $implicit^Base { void method(); };",
 470            "template<typename T> void k(Base<T> t) { t.^method(); }");
 471   testWalk("template<typename T> struct $implicit^Base { void method(); };",
 472            "template<typename T> void k(Base<T>& t) { t.^method(); }");
 473   testWalk("template<typename T> struct $implicit^Base { void method(); };",
 474            "template<typename T> void k(Base<T>* t) { t->^method(); }");
 475 }
 476
 477 TEST(WalkAST, ConstructExprs) {
 478   testWalk("struct $implicit^S {};", "S ^t;");
 479   testWalk("struct $implicit^S { S(); };", "S ^t;");
 480   testWalk("struct $implicit^S { S(int); };", "S ^t(42);");
 481   testWalk("struct $implicit^S { S(int); };", "S t = ^42;");
 482   testWalk("namespace ns { struct S{}; } using ns::$implicit^S;", "S ^t;");
 483 }
 484
 485 TEST(WalkAST, Operator) {
 486   // Operator calls are marked as implicit references as they're ADL-used and
 487   // type should be providing them.
 488   testWalk(
 489       "struct string { friend int $implicit^operator+(string, string); }; ",
 490       "int k = string() ^+ string();");
 491   // Treat member operators as regular member expr calls.
 492   testWalk("struct $implicit^string {int operator+(string); }; ",
 493            "int k = string() ^+ string();");
 494   // Make sure usage is attributed to the alias.
 495   testWalk(
 496       "struct string {int operator+(string); }; using $implicit^foo = string;",
 497       "int k = foo() ^+ string();");
 498 }
 499
 500 TEST(WalkAST, VarDecls) {
 501   // Definition uses declaration, not the other way around.
 502   testWalk("extern int $explicit^x;", "int ^x = 1;");
 503   testWalk("int x = 1;", "extern int ^x;");
 504 }
 505
 506 TEST(WalkAST, Functions) {
 507   // Definition uses declaration, not the other way around.
 508   testWalk("void $explicit^foo();", "void ^foo() {}");
 509   testWalk("void foo() {}", "void ^foo();");
 510
 511   // Unresolved calls marks all the overloads.
 512   testWalk("void $ambiguous^foo(int); void $ambiguous^foo(char);",
 513            "template <typename T> void bar() { ^foo(T{}); }");
 514 }
 515
 516 TEST(WalkAST, Enums) {
 517   testWalk("enum E { $explicit^A = 42 };", "int e = ^A;");
 518   testWalk("enum class $explicit^E : int;", "enum class ^E : int {};");
 519   testWalk("enum class E : int {};", "enum class ^E : int ;");
 520   testWalk("namespace ns { enum E { $explicit^A = 42 }; }", "int e = ns::^A;");
 521   testWalk("namespace ns { enum E { A = 42 }; } using ns::E::$explicit^A;",
 522            "int e = ^A;");
 523   testWalk("namespace ns { enum E { A = 42 }; } using enum ns::$explicit^E;",
 524            "int e = ^A;");
 525   testWalk(R"(namespace ns { enum E { A = 42 }; }
 526               struct S { using enum ns::E; };)",
 527            "int e = S::^A;");
 528   testWalk(R"(namespace ns { enum E { A = 42 }; }
 529               struct S { using ns::E::A; };)",
 530            "int e = S::^A;");
 531 }
 532
 533 TEST(WalkAST, InitializerList) {
 534   testWalk(R"cpp(
 535        namespace std {
 536         template <typename T> struct $implicit^initializer_list {};
 537        })cpp",
 538            R"cpp(
 539        const char* s = "";
 540        auto sx = ^{s};)cpp");
 541 }
 542
 543 TEST(WalkAST, Concepts) {
 544   std::string Concept = "template<typename T> concept $explicit^Foo = true;";
 545   testWalk(Concept, "template<typename T>concept Bar = ^Foo<T> && true;");
 546   testWalk(Concept, "template<^Foo T>void func() {}");
 547   testWalk(Concept, "template<typename T> requires ^Foo<T> void func() {}");
 548   testWalk(Concept, "template<typename T> void func() requires ^Foo<T> {}");
 549   testWalk(Concept, "void func(^Foo auto x) {}");
 550   // FIXME: Foo should be explicitly referenced.
 551   testWalk("template<typename T> concept Foo = true;", "void func() { ^Foo auto x = 1; }");
 552 }
 553 } // namespace
 554 } // namespace clang::include_cleaner