clang/unittests/AST/NamedDeclPrinterTest.cpp

   1 //===- unittests/AST/NamedDeclPrinterTest.cpp --- NamedDecl printer 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 // This file contains tests for NamedDecl::printQualifiedName().
  10 //
  11 // These tests have a coding convention:
  12 // * declaration to be printed is named 'A' unless it should have some special
  13 // name (e.g., 'operator+');
  14 // * additional helper declarations are 'Z', 'Y', 'X' and so on.
  15 //
  16 //===----------------------------------------------------------------------===//
  17
  18 #include "ASTPrint.h"
  19 #include "clang/AST/ASTContext.h"
  20 #include "clang/AST/Decl.h"
  21 #include "clang/AST/PrettyPrinter.h"
  22 #include "clang/ASTMatchers/ASTMatchFinder.h"
  23 #include "clang/Tooling/Tooling.h"
  24 #include "llvm/ADT/SmallString.h"
  25 #include "llvm/Support/raw_ostream.h"
  26 #include "gtest/gtest.h"
  27
  28 using namespace clang;
  29 using namespace ast_matchers;
  30 using namespace tooling;
  31
  32 namespace {
  33
  34 class PrintMatch : public MatchFinder::MatchCallback {
  35   SmallString<1024> Printed;
  36   unsigned NumFoundDecls;
  37   std::function<void(llvm::raw_ostream &OS, const NamedDecl *)> Printer;
  38
  39 public:
  40   explicit PrintMatch(
  41       std::function<void(llvm::raw_ostream &OS, const NamedDecl *)> Printer)
  42       : NumFoundDecls(0), Printer(std::move(Printer)) {}
  43
  44   void run(const MatchFinder::MatchResult &Result) override {
  45     const NamedDecl *ND = Result.Nodes.getNodeAs<NamedDecl>("id");
  46     if (!ND)
  47       return;
  48     NumFoundDecls++;
  49     if (NumFoundDecls > 1)
  50       return;
  51
  52     llvm::raw_svector_ostream Out(Printed);
  53     Printer(Out, ND);
  54   }
  55
  56   StringRef getPrinted() const {
  57     return Printed;
  58   }
  59
  60   unsigned getNumFoundDecls() const {
  61     return NumFoundDecls;
  62   }
  63 };
  64
  65 ::testing::AssertionResult PrintedDeclMatches(
  66     StringRef Code, const std::vector<std::string> &Args,
  67     const DeclarationMatcher &NodeMatch, StringRef ExpectedPrinted,
  68     StringRef FileName,
  69     std::function<void(llvm::raw_ostream &, const NamedDecl *)> Print) {
  70   return PrintedNodeMatches<NamedDecl>(
  71       Code, Args, NodeMatch, ExpectedPrinted, FileName,
  72       [Print](llvm::raw_ostream &Out, const ASTContext *Context,
  73               const NamedDecl *ND,
  74               PrintingPolicyAdjuster PolicyAdjuster) { Print(Out, ND); });
  75 }
  76
  77 ::testing::AssertionResult
  78 PrintedNamedDeclMatches(StringRef Code, const std::vector<std::string> &Args,
  79                         bool SuppressUnwrittenScope,
  80                         const DeclarationMatcher &NodeMatch,
  81                         StringRef ExpectedPrinted, StringRef FileName) {
  82   return PrintedDeclMatches(Code, Args, NodeMatch, ExpectedPrinted, FileName,
  83                             [=](llvm::raw_ostream &Out, const NamedDecl *ND) {
  84                               auto Policy =
  85                                   ND->getASTContext().getPrintingPolicy();
  86                               Policy.SuppressUnwrittenScope =
  87                                   SuppressUnwrittenScope;
  88                               ND->printQualifiedName(Out, Policy);
  89                             });
  90 }
  91
  92 ::testing::AssertionResult
  93 PrintedNamedDeclCXX98Matches(StringRef Code, StringRef DeclName,
  94                              StringRef ExpectedPrinted) {
  95   std::vector<std::string> Args(1, "-std=c++98");
  96   return PrintedNamedDeclMatches(Code, Args,
  97                                  /*SuppressUnwrittenScope*/ false,
  98                                  namedDecl(hasName(DeclName)).bind("id"),
  99                                  ExpectedPrinted, "input.cc");
 100 }
 101
 102 ::testing::AssertionResult
 103 PrintedWrittenNamedDeclCXX11Matches(StringRef Code, StringRef DeclName,
 104                                     StringRef ExpectedPrinted) {
 105   std::vector<std::string> Args(1, "-std=c++11");
 106   return PrintedNamedDeclMatches(Code, Args,
 107                                  /*SuppressUnwrittenScope*/ true,
 108                                  namedDecl(hasName(DeclName)).bind("id"),
 109                                  ExpectedPrinted, "input.cc");
 110 }
 111
 112 ::testing::AssertionResult
 113 PrintedWrittenPropertyDeclObjCMatches(StringRef Code, StringRef DeclName,
 114                                    StringRef ExpectedPrinted) {
 115   std::vector<std::string> Args{"-std=c++11", "-xobjective-c++"};
 116   return PrintedNamedDeclMatches(Code, Args,
 117                                  /*SuppressUnwrittenScope*/ true,
 118                                  objcPropertyDecl(hasName(DeclName)).bind("id"),
 119                                  ExpectedPrinted, "input.m");
 120 }
 121
 122 ::testing::AssertionResult
 123 PrintedNestedNameSpecifierMatches(StringRef Code, StringRef DeclName,
 124                                   StringRef ExpectedPrinted) {
 125   std::vector<std::string> Args{"-std=c++11"};
 126   return PrintedDeclMatches(Code, Args, namedDecl(hasName(DeclName)).bind("id"),
 127                             ExpectedPrinted, "input.cc",
 128                             [](llvm::raw_ostream &Out, const NamedDecl *D) {
 129                               D->printNestedNameSpecifier(Out);
 130                             });
 131 }
 132
 133 } // unnamed namespace
 134
 135 TEST(NamedDeclPrinter, TestNamespace1) {
 136   ASSERT_TRUE(PrintedNamedDeclCXX98Matches(
 137     "namespace { int A; }",
 138     "A",
 139     "(anonymous namespace)::A"));
 140 }
 141
 142 TEST(NamedDeclPrinter, TestNamespace2) {
 143   ASSERT_TRUE(PrintedWrittenNamedDeclCXX11Matches(
 144     "inline namespace Z { namespace { int A; } }",
 145     "A",
 146     "A"));
 147 }
 148
 149 TEST(NamedDeclPrinter, TestUnscopedUnnamedEnum) {
 150   ASSERT_TRUE(PrintedWrittenNamedDeclCXX11Matches(
 151     "enum { A };",
 152     "A",
 153     "A"));
 154 }
 155
 156 TEST(NamedDeclPrinter, TestNamedEnum) {
 157   ASSERT_TRUE(PrintedWrittenNamedDeclCXX11Matches(
 158     "enum X { A };",
 159     "A",
 160     "A"));
 161 }
 162
 163 TEST(NamedDeclPrinter, TestScopedNamedEnum) {
 164   ASSERT_TRUE(PrintedWrittenNamedDeclCXX11Matches(
 165     "enum class X { A };",
 166     "A",
 167     "X::A"));
 168 }
 169
 170 TEST(NamedDeclPrinter, TestClassWithUnscopedUnnamedEnum) {
 171   ASSERT_TRUE(PrintedWrittenNamedDeclCXX11Matches(
 172     "class X { enum { A }; };",
 173     "A",
 174     "X::A"));
 175 }
 176
 177 TEST(NamedDeclPrinter, TestClassWithUnscopedNamedEnum) {
 178   ASSERT_TRUE(PrintedWrittenNamedDeclCXX11Matches(
 179     "class X { enum Y { A }; };",
 180     "A",
 181     "X::A"));
 182 }
 183
 184 TEST(NamedDeclPrinter, TestClassWithScopedNamedEnum) {
 185   ASSERT_TRUE(PrintedWrittenNamedDeclCXX11Matches(
 186     "class X { enum class Y { A }; };",
 187     "A",
 188     "X::Y::A"));
 189 }
 190
 191 TEST(NamedDeclPrinter, TestLinkageInNamespace) {
 192   ASSERT_TRUE(PrintedWrittenNamedDeclCXX11Matches(
 193     "namespace X { extern \"C\" { int A; } }",
 194     "A",
 195     "X::A"));
 196 }
 197
 198 TEST(NamedDeclPrinter, TestObjCClassExtension) {
 199   const char *Code =
 200 R"(
 201   @interface Obj
 202   @end
 203
 204   @interface Obj ()
 205   @property(nonatomic) int property;
 206   @end
 207 )";
 208   ASSERT_TRUE(PrintedWrittenPropertyDeclObjCMatches(
 209     Code,
 210     "property",
 211     "Obj::property"));
 212 }
 213
 214 TEST(NamedDeclPrinter, TestInstanceObjCClassExtension) {
 215   const char *Code =
 216 R"(
 217 @interface ObjC
 218 @end
 219 @interface ObjC () {
 220   char data; // legal with non-fragile ABI.
 221 }
 222 @end
 223 )";
 224
 225   std::vector<std::string> Args{
 226       "-std=c++11", "-xobjective-c++",
 227       "-fobjc-runtime=macosx" /*force to use non-fragile ABI*/};
 228   ASSERT_TRUE(PrintedNamedDeclMatches(Code, Args,
 229                                       /*SuppressUnwrittenScope*/ true,
 230                                       namedDecl(hasName("data")).bind("id"),
 231                                       // not "::data"
 232                                       "ObjC::data", "input.mm"));
 233 }
 234
 235 TEST(NamedDeclPrinter, TestObjCClassExtensionWithGetter) {
 236   const char *Code =
 237 R"(
 238   @interface Obj
 239   @end
 240
 241   @interface Obj ()
 242   @property(nonatomic, getter=myPropertyGetter) int property;
 243   @end
 244 )";
 245   ASSERT_TRUE(PrintedWrittenPropertyDeclObjCMatches(
 246     Code,
 247     "property",
 248     "Obj::property"));
 249 }
 250
 251 TEST(NamedDeclPrinter, NestedNameSpecifierSimple) {
 252   const char *Code =
 253       R"(
 254   namespace foo { namespace bar { void func(); }  }
 255 )";
 256   ASSERT_TRUE(PrintedNestedNameSpecifierMatches(Code, "func", "foo::bar::"));
 257 }
 258
 259 TEST(NamedDeclPrinter, NestedNameSpecifierTemplateArgs) {
 260   const char *Code =
 261       R"(
 262         template <class T> struct vector;
 263         template <> struct vector<int> { int method(); };
 264 )";
 265   ASSERT_TRUE(
 266       PrintedNestedNameSpecifierMatches(Code, "method", "vector<int>::"));
 267 }