clang-tools-extra/unittests/clang-doc/SerializeTest.cpp

   1 //===-- clang-doc/SerializeTest.cpp ---------------------------------------===//
   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 "Serialize.h"
  10 #include "ClangDocTest.h"
  11 #include "Representation.h"
  12 #include "clang/AST/Comment.h"
  13 #include "clang/AST/RecursiveASTVisitor.h"
  14 #include "gtest/gtest.h"
  15
  16 namespace clang {
  17 namespace doc {
  18
  19 class ClangDocSerializeTestVisitor
  20     : public RecursiveASTVisitor<ClangDocSerializeTestVisitor> {
  21
  22   EmittedInfoList &EmittedInfos;
  23   bool Public;
  24
  25   comments::FullComment *getComment(const NamedDecl *D) const {
  26     if (RawComment *Comment =
  27             D->getASTContext().getRawCommentForDeclNoCache(D)) {
  28       Comment->setAttached();
  29       return Comment->parse(D->getASTContext(), nullptr, D);
  30     }
  31     return nullptr;
  32   }
  33
  34 public:
  35   ClangDocSerializeTestVisitor(EmittedInfoList &EmittedInfos, bool Public)
  36       : EmittedInfos(EmittedInfos), Public(Public) {}
  37
  38   template <typename T> bool mapDecl(const T *D) {
  39     auto I = serialize::emitInfo(D, getComment(D), /*Line=*/0,
  40                                  /*File=*/"test.cpp", true, Public);
  41     if (I.first)
  42       EmittedInfos.emplace_back(std::move(I.first));
  43     if (I.second)
  44       EmittedInfos.emplace_back(std::move(I.second));
  45     return true;
  46   }
  47
  48   bool VisitNamespaceDecl(const NamespaceDecl *D) { return mapDecl(D); }
  49
  50   bool VisitFunctionDecl(const FunctionDecl *D) {
  51     // Don't visit CXXMethodDecls twice
  52     if (dyn_cast<CXXMethodDecl>(D))
  53       return true;
  54     return mapDecl(D);
  55   }
  56
  57   bool VisitCXXMethodDecl(const CXXMethodDecl *D) { return mapDecl(D); }
  58
  59   bool VisitRecordDecl(const RecordDecl *D) { return mapDecl(D); }
  60
  61   bool VisitEnumDecl(const EnumDecl *D) { return mapDecl(D); }
  62
  63   bool VisitTypedefDecl(const TypedefDecl *D) { return mapDecl(D); }
  64
  65   bool VisitTypeAliasDecl(const TypeAliasDecl *D) { return mapDecl(D); }
  66 };
  67
  68 void ExtractInfosFromCode(StringRef Code, size_t NumExpectedInfos, bool Public,
  69                           EmittedInfoList &EmittedInfos) {
  70   auto ASTUnit = clang::tooling::buildASTFromCode(Code);
  71   auto TU = ASTUnit->getASTContext().getTranslationUnitDecl();
  72   ClangDocSerializeTestVisitor Visitor(EmittedInfos, Public);
  73   Visitor.TraverseTranslationUnitDecl(TU);
  74   ASSERT_EQ(NumExpectedInfos, EmittedInfos.size());
  75 }
  76
  77 void ExtractInfosFromCodeWithArgs(StringRef Code, size_t NumExpectedInfos,
  78                                   bool Public, EmittedInfoList &EmittedInfos,
  79                                   std::vector<std::string> &Args) {
  80   auto ASTUnit = clang::tooling::buildASTFromCodeWithArgs(Code, Args);
  81   auto TU = ASTUnit->getASTContext().getTranslationUnitDecl();
  82   ClangDocSerializeTestVisitor Visitor(EmittedInfos, Public);
  83   Visitor.TraverseTranslationUnitDecl(TU);
  84   ASSERT_EQ(NumExpectedInfos, EmittedInfos.size());
  85 }
  86
  87 // Constructs a comment definition as the parser would for one comment line.
  88 /* TODO uncomment this when the missing comment is fixed in emitRecordInfo and
  89    the code that calls this is re-enabled.
  90 CommentInfo MakeOneLineCommentInfo(const std::string &Text) {
  91   CommentInfo TopComment;
  92   TopComment.Kind = "FullComment";
  93   TopComment.Children.emplace_back(std::make_unique<CommentInfo>());
  94
  95   CommentInfo *Brief = TopComment.Children.back().get();
  96   Brief->Kind = "ParagraphComment";
  97
  98   Brief->Children.emplace_back(std::make_unique<CommentInfo>());
  99   Brief->Children.back()->Kind = "TextComment";
 100   Brief->Children.back()->Name = "ParagraphComment";
 101   Brief->Children.back()->Text = Text;
 102
 103   return TopComment;
 104 }
 105 */
 106
 107 // Test serialization of namespace declarations.
 108 TEST(SerializeTest, emitNamespaceInfo) {
 109   EmittedInfoList Infos;
 110   ExtractInfosFromCode("namespace A { namespace B { void f() {} } }", 5,
 111                        /*Public=*/false, Infos);
 112
 113   NamespaceInfo *A = InfoAsNamespace(Infos[0].get());
 114   NamespaceInfo ExpectedA(EmptySID, "A");
 115   CheckNamespaceInfo(&ExpectedA, A);
 116
 117   NamespaceInfo *B = InfoAsNamespace(Infos[2].get());
 118   NamespaceInfo ExpectedB(EmptySID, /*Name=*/"B", /*Path=*/"A");
 119   ExpectedB.Namespace.emplace_back(EmptySID, "A", InfoType::IT_namespace);
 120   CheckNamespaceInfo(&ExpectedB, B);
 121
 122   NamespaceInfo *BWithFunction = InfoAsNamespace(Infos[4].get());
 123   NamespaceInfo ExpectedBWithFunction(EmptySID);
 124   FunctionInfo F;
 125   F.Name = "f";
 126   F.ReturnType = TypeInfo("void");
 127   F.DefLoc = Location(0, llvm::SmallString<16>{"test.cpp"});
 128   F.Namespace.emplace_back(EmptySID, "B", InfoType::IT_namespace);
 129   F.Namespace.emplace_back(EmptySID, "A", InfoType::IT_namespace);
 130   F.Access = AccessSpecifier::AS_none;
 131   ExpectedBWithFunction.Children.Functions.emplace_back(std::move(F));
 132   CheckNamespaceInfo(&ExpectedBWithFunction, BWithFunction);
 133 }
 134
 135 TEST(SerializeTest, emitAnonymousNamespaceInfo) {
 136   EmittedInfoList Infos;
 137   ExtractInfosFromCode("namespace { }", 2, /*Public=*/false, Infos);
 138
 139   NamespaceInfo *A = InfoAsNamespace(Infos[0].get());
 140   NamespaceInfo ExpectedA(EmptySID);
 141   ExpectedA.Name = "@nonymous_namespace";
 142   CheckNamespaceInfo(&ExpectedA, A);
 143 }
 144
 145 // Test serialization of record declarations.
 146 TEST(SerializeTest, emitRecordInfo) {
 147   EmittedInfoList Infos;
 148   ExtractInfosFromCode(R"raw(class E {
 149 public:
 150   E() {}
 151
 152   // Some docs.
 153   int value;
 154 protected:
 155   void ProtectedMethod();
 156 };
 157 template <typename T>
 158 struct F {
 159   void TemplateMethod();
 160 };
 161 template <>
 162 void F<int>::TemplateMethod();
 163 typedef struct {} G;)raw",
 164                        10, /*Public=*/false, Infos);
 165
 166   RecordInfo *E = InfoAsRecord(Infos[0].get());
 167   RecordInfo ExpectedE(EmptySID, /*Name=*/"E", /*Path=*/"GlobalNamespace");
 168   ExpectedE.Namespace.emplace_back(EmptySID, "GlobalNamespace",
 169                                    InfoType::IT_namespace);
 170   ExpectedE.TagType = TagTypeKind::Class;
 171   ExpectedE.DefLoc = Location(0, llvm::SmallString<16>{"test.cpp"});
 172   ExpectedE.Members.emplace_back(TypeInfo("int"), "value",
 173                                  AccessSpecifier::AS_public);
 174   // TODO the data member should have the docstring on it:
 175   //ExpectedE.Members.back().Description.push_back(MakeOneLineCommentInfo(" Some docs"));
 176   CheckRecordInfo(&ExpectedE, E);
 177
 178   RecordInfo *RecordWithEConstructor = InfoAsRecord(Infos[2].get());
 179   RecordInfo ExpectedRecordWithEConstructor(EmptySID);
 180   FunctionInfo EConstructor;
 181   EConstructor.Name = "E";
 182   EConstructor.Parent = Reference(EmptySID, "E", InfoType::IT_record);
 183   EConstructor.ReturnType = TypeInfo("void");
 184   EConstructor.DefLoc = Location(0, llvm::SmallString<16>{"test.cpp"});
 185   EConstructor.Namespace.emplace_back(EmptySID, "E", InfoType::IT_record);
 186   EConstructor.Namespace.emplace_back(EmptySID, "GlobalNamespace",
 187                                       InfoType::IT_namespace);
 188   EConstructor.Access = AccessSpecifier::AS_public;
 189   EConstructor.IsMethod = true;
 190   ExpectedRecordWithEConstructor.Children.Functions.emplace_back(
 191       std::move(EConstructor));
 192   CheckRecordInfo(&ExpectedRecordWithEConstructor, RecordWithEConstructor);
 193
 194   RecordInfo *RecordWithMethod = InfoAsRecord(Infos[3].get());
 195   RecordInfo ExpectedRecordWithMethod(EmptySID);
 196   FunctionInfo Method;
 197   Method.Name = "ProtectedMethod";
 198   Method.Parent = Reference(EmptySID, "E", InfoType::IT_record);
 199   Method.ReturnType = TypeInfo("void");
 200   Method.Loc.emplace_back(0, llvm::SmallString<16>{"test.cpp"});
 201   Method.Namespace.emplace_back(EmptySID, "E", InfoType::IT_record);
 202   Method.Namespace.emplace_back(EmptySID, "GlobalNamespace",
 203                                 InfoType::IT_namespace);
 204   Method.Access = AccessSpecifier::AS_protected;
 205   Method.IsMethod = true;
 206   ExpectedRecordWithMethod.Children.Functions.emplace_back(std::move(Method));
 207   CheckRecordInfo(&ExpectedRecordWithMethod, RecordWithMethod);
 208
 209   RecordInfo *F = InfoAsRecord(Infos[4].get());
 210   RecordInfo ExpectedF(EmptySID, /*Name=*/"F", /*Path=*/"GlobalNamespace");
 211   ExpectedF.Namespace.emplace_back(EmptySID, "GlobalNamespace",
 212                                    InfoType::IT_namespace);
 213   ExpectedF.TagType = TagTypeKind::Struct;
 214   ExpectedF.DefLoc = Location(0, llvm::SmallString<16>{"test.cpp"});
 215   CheckRecordInfo(&ExpectedF, F);
 216
 217   RecordInfo *RecordWithTemplateMethod = InfoAsRecord(Infos[6].get());
 218   RecordInfo ExpectedRecordWithTemplateMethod(EmptySID);
 219   FunctionInfo TemplateMethod;
 220   TemplateMethod.Name = "TemplateMethod";
 221   TemplateMethod.Parent = Reference(EmptySID, "F", InfoType::IT_record);
 222   TemplateMethod.ReturnType = TypeInfo("void");
 223   TemplateMethod.Loc.emplace_back(0, llvm::SmallString<16>{"test.cpp"});
 224   TemplateMethod.Namespace.emplace_back(EmptySID, "F", InfoType::IT_record);
 225   TemplateMethod.Namespace.emplace_back(EmptySID, "GlobalNamespace",
 226                                         InfoType::IT_namespace);
 227   TemplateMethod.Access = AccessSpecifier::AS_public;
 228   TemplateMethod.IsMethod = true;
 229   ExpectedRecordWithTemplateMethod.Children.Functions.emplace_back(
 230       std::move(TemplateMethod));
 231   CheckRecordInfo(&ExpectedRecordWithTemplateMethod, RecordWithTemplateMethod);
 232
 233   RecordInfo *TemplatedRecord = InfoAsRecord(Infos[7].get());
 234   RecordInfo ExpectedTemplatedRecord(EmptySID);
 235   FunctionInfo SpecializedTemplateMethod;
 236   SpecializedTemplateMethod.Name = "TemplateMethod";
 237   SpecializedTemplateMethod.Parent =
 238       Reference(EmptySID, "F", InfoType::IT_record);
 239   SpecializedTemplateMethod.ReturnType = TypeInfo("void");
 240   SpecializedTemplateMethod.Loc.emplace_back(0,
 241                                              llvm::SmallString<16>{"test.cpp"});
 242   SpecializedTemplateMethod.Namespace.emplace_back(EmptySID, "F",
 243                                                    InfoType::IT_record);
 244   SpecializedTemplateMethod.Namespace.emplace_back(EmptySID, "GlobalNamespace",
 245                                                    InfoType::IT_namespace);
 246   SpecializedTemplateMethod.Access = AccessSpecifier::AS_public;
 247   SpecializedTemplateMethod.IsMethod = true;
 248   ExpectedTemplatedRecord.Children.Functions.emplace_back(
 249       std::move(SpecializedTemplateMethod));
 250   CheckRecordInfo(&ExpectedTemplatedRecord, TemplatedRecord);
 251
 252   RecordInfo *G = InfoAsRecord(Infos[8].get());
 253   RecordInfo ExpectedG(EmptySID, /*Name=*/"G", /*Path=*/"GlobalNamespace");
 254   ExpectedG.Namespace.emplace_back(EmptySID, "GlobalNamespace",
 255                                    InfoType::IT_namespace);
 256   ExpectedG.TagType = TagTypeKind::Struct;
 257   ExpectedG.DefLoc = Location(0, llvm::SmallString<16>{"test.cpp"});
 258   ExpectedG.IsTypeDef = true;
 259   CheckRecordInfo(&ExpectedG, G);
 260 }
 261
 262 // Test serialization of enum declarations.
 263 TEST(SerializeTest, emitEnumInfo) {
 264   EmittedInfoList Infos;
 265   ExtractInfosFromCode("enum E { X, Y }; enum class G { A, B };", 2,
 266                        /*Public=*/false, Infos);
 267
 268   NamespaceInfo *NamespaceWithEnum = InfoAsNamespace(Infos[0].get());
 269   NamespaceInfo ExpectedNamespaceWithEnum(EmptySID);
 270   EnumInfo E;
 271   E.Name = "E";
 272   E.DefLoc = Location(0, llvm::SmallString<16>{"test.cpp"});
 273   E.Members.emplace_back("X", "0");
 274   E.Members.emplace_back("Y", "1");
 275   ExpectedNamespaceWithEnum.Children.Enums.emplace_back(std::move(E));
 276   CheckNamespaceInfo(&ExpectedNamespaceWithEnum, NamespaceWithEnum);
 277
 278   NamespaceInfo *NamespaceWithScopedEnum = InfoAsNamespace(Infos[1].get());
 279   NamespaceInfo ExpectedNamespaceWithScopedEnum(EmptySID);
 280   EnumInfo G;
 281   G.Name = "G";
 282   G.Scoped = true;
 283   G.DefLoc = Location(0, llvm::SmallString<16>{"test.cpp"});
 284   G.Members.emplace_back("A", "0");
 285   G.Members.emplace_back("B", "1");
 286   ExpectedNamespaceWithScopedEnum.Children.Enums.emplace_back(std::move(G));
 287   CheckNamespaceInfo(&ExpectedNamespaceWithScopedEnum, NamespaceWithScopedEnum);
 288 }
 289
 290 TEST(SerializeTest, emitUndefinedRecordInfo) {
 291   EmittedInfoList Infos;
 292   ExtractInfosFromCode("class E;", 2, /*Public=*/false, Infos);
 293
 294   RecordInfo *E = InfoAsRecord(Infos[0].get());
 295   RecordInfo ExpectedE(EmptySID, /*Name=*/"E", /*Path=*/"GlobalNamespace");
 296   ExpectedE.Namespace.emplace_back(EmptySID, "GlobalNamespace",
 297                                    InfoType::IT_namespace);
 298   ExpectedE.TagType = TagTypeKind::Class;
 299   ExpectedE.Loc.emplace_back(0, llvm::SmallString<16>{"test.cpp"});
 300   CheckRecordInfo(&ExpectedE, E);
 301 }
 302
 303 TEST(SerializeTest, emitRecordMemberInfo) {
 304   EmittedInfoList Infos;
 305   ExtractInfosFromCode("struct E { int I; };", 2, /*Public=*/false, Infos);
 306
 307   RecordInfo *E = InfoAsRecord(Infos[0].get());
 308   RecordInfo ExpectedE(EmptySID, /*Name=*/"E", /*Path=*/"GlobalNamespace");
 309   ExpectedE.Namespace.emplace_back(EmptySID, "GlobalNamespace",
 310                                    InfoType::IT_namespace);
 311   ExpectedE.TagType = TagTypeKind::Struct;
 312   ExpectedE.DefLoc = Location(0, llvm::SmallString<16>{"test.cpp"});
 313   ExpectedE.Members.emplace_back(TypeInfo("int"), "I",
 314                                  AccessSpecifier::AS_public);
 315   CheckRecordInfo(&ExpectedE, E);
 316 }
 317
 318 TEST(SerializeTest, emitInternalRecordInfo) {
 319   EmittedInfoList Infos;
 320   ExtractInfosFromCode("class E { class G {}; };", 4, /*Public=*/false, Infos);
 321
 322   RecordInfo *E = InfoAsRecord(Infos[0].get());
 323   RecordInfo ExpectedE(EmptySID, /*Name=*/"E", /*Path=*/"GlobalNamespace");
 324   ExpectedE.Namespace.emplace_back(EmptySID, "GlobalNamespace",
 325                                    InfoType::IT_namespace);
 326   ExpectedE.DefLoc = Location(0, llvm::SmallString<16>{"test.cpp"});
 327   ExpectedE.TagType = TagTypeKind::Class;
 328   CheckRecordInfo(&ExpectedE, E);
 329
 330   RecordInfo *G = InfoAsRecord(Infos[2].get());
 331   llvm::SmallString<128> ExpectedGPath("GlobalNamespace/E");
 332   llvm::sys::path::native(ExpectedGPath);
 333   RecordInfo ExpectedG(EmptySID, /*Name=*/"G", /*Path=*/ExpectedGPath);
 334   ExpectedG.DefLoc = Location(0, llvm::SmallString<16>{"test.cpp"});
 335   ExpectedG.TagType = TagTypeKind::Class;
 336   ExpectedG.Namespace.emplace_back(EmptySID, "E", InfoType::IT_record);
 337   ExpectedG.Namespace.emplace_back(EmptySID, "GlobalNamespace",
 338                                    InfoType::IT_namespace);
 339   CheckRecordInfo(&ExpectedG, G);
 340 }
 341
 342 TEST(SerializeTest, emitPublicAnonymousNamespaceInfo) {
 343   EmittedInfoList Infos;
 344   ExtractInfosFromCode("namespace { class A; }", 0, /*Public=*/true, Infos);
 345 }
 346
 347 TEST(SerializeTest, emitPublicFunctionInternalInfo) {
 348   EmittedInfoList Infos;
 349   ExtractInfosFromCode("int F() { class G {}; return 0; };", 1, /*Public=*/true,
 350                        Infos);
 351
 352   NamespaceInfo *BWithFunction = InfoAsNamespace(Infos[0].get());
 353   NamespaceInfo ExpectedBWithFunction(EmptySID);
 354   FunctionInfo F;
 355   F.Name = "F";
 356   F.ReturnType = TypeInfo("int");
 357   F.DefLoc = Location(0, llvm::SmallString<16>{"test.cpp"});
 358   F.Access = AccessSpecifier::AS_none;
 359   ExpectedBWithFunction.Children.Functions.emplace_back(std::move(F));
 360   CheckNamespaceInfo(&ExpectedBWithFunction, BWithFunction);
 361 }
 362
 363 TEST(SerializeTest, emitInlinedFunctionInfo) {
 364   EmittedInfoList Infos;
 365   ExtractInfosFromCode("inline void F(int I) { };", 1, /*Public=*/true, Infos);
 366
 367   NamespaceInfo *BWithFunction = InfoAsNamespace(Infos[0].get());
 368   NamespaceInfo ExpectedBWithFunction(EmptySID);
 369   FunctionInfo F;
 370   F.Name = "F";
 371   F.ReturnType = TypeInfo("void");
 372   F.DefLoc = Location(0, llvm::SmallString<16>{"test.cpp"});
 373   F.Params.emplace_back(TypeInfo("int"), "I");
 374   F.Access = AccessSpecifier::AS_none;
 375   ExpectedBWithFunction.Children.Functions.emplace_back(std::move(F));
 376   CheckNamespaceInfo(&ExpectedBWithFunction, BWithFunction);
 377 }
 378
 379 TEST(SerializeTest, emitInheritedRecordInfo) {
 380   EmittedInfoList Infos;
 381   ExtractInfosFromCode(R"raw(class F { protected: void set(int N); };
 382 class G { public: int get() { return 1; } protected: int I; };
 383 class E : public F, virtual private G {};
 384 class H : private E {};
 385 template <typename T>
 386 class I {} ;
 387 class J : public I<int> {} ;)raw",
 388                        14, /*Public=*/false, Infos);
 389
 390   RecordInfo *F = InfoAsRecord(Infos[0].get());
 391   RecordInfo ExpectedF(EmptySID, /*Name=*/"F", /*Path=*/"GlobalNamespace");
 392   ExpectedF.Namespace.emplace_back(EmptySID, "GlobalNamespace",
 393                                    InfoType::IT_namespace, "");
 394   ExpectedF.TagType = TagTypeKind::Class;
 395   ExpectedF.DefLoc = Location(0, llvm::SmallString<16>{"test.cpp"});
 396   CheckRecordInfo(&ExpectedF, F);
 397
 398   RecordInfo *G = InfoAsRecord(Infos[3].get());
 399   RecordInfo ExpectedG(EmptySID, /*Name=*/"G", /*Path=*/"GlobalNamespace");
 400   ExpectedG.Namespace.emplace_back(EmptySID, "GlobalNamespace",
 401                                    InfoType::IT_namespace);
 402   ExpectedG.TagType = TagTypeKind::Class;
 403   ExpectedG.DefLoc = Location(0, llvm::SmallString<16>{"test.cpp"});
 404   ExpectedG.Members.emplace_back(TypeInfo("int"), "I",
 405                                  AccessSpecifier::AS_protected);
 406   CheckRecordInfo(&ExpectedG, G);
 407
 408   RecordInfo *E = InfoAsRecord(Infos[6].get());
 409   RecordInfo ExpectedE(EmptySID, /*Name=*/"E", /*Path=*/"GlobalNamespace");
 410   ExpectedE.Namespace.emplace_back(EmptySID, "GlobalNamespace",
 411                                    InfoType::IT_namespace);
 412   ExpectedE.Parents.emplace_back(EmptySID, /*Name=*/"F", InfoType::IT_record,
 413                                  /*QualName=*/"", /*Path*=*/"GlobalNamespace");
 414   ExpectedE.VirtualParents.emplace_back(EmptySID, /*Name=*/"G",
 415                                         InfoType::IT_record, /*QualName=*/"G",
 416                                         /*Path*=*/"GlobalNamespace");
 417   ExpectedE.Bases.emplace_back(EmptySID, /*Name=*/"F",
 418                                /*Path=*/"GlobalNamespace", false,
 419                                AccessSpecifier::AS_public, true);
 420   FunctionInfo FunctionSet;
 421   FunctionSet.Name = "set";
 422   FunctionSet.ReturnType = TypeInfo("void");
 423   FunctionSet.Loc.emplace_back();
 424   FunctionSet.Params.emplace_back(TypeInfo("int"), "N");
 425   FunctionSet.Namespace.emplace_back(EmptySID, "F", InfoType::IT_record);
 426   FunctionSet.Namespace.emplace_back(EmptySID, "GlobalNamespace",
 427                                      InfoType::IT_namespace);
 428   FunctionSet.Access = AccessSpecifier::AS_protected;
 429   FunctionSet.IsMethod = true;
 430   ExpectedE.Bases.back().Children.Functions.emplace_back(
 431       std::move(FunctionSet));
 432   ExpectedE.Bases.emplace_back(EmptySID, /*Name=*/"G",
 433                                /*Path=*/"GlobalNamespace", true,
 434                                AccessSpecifier::AS_private, true);
 435   FunctionInfo FunctionGet;
 436   FunctionGet.Name = "get";
 437   FunctionGet.ReturnType = TypeInfo("int");
 438   FunctionGet.DefLoc = Location();
 439   FunctionGet.Namespace.emplace_back(EmptySID, "G", InfoType::IT_record);
 440   FunctionGet.Namespace.emplace_back(EmptySID, "GlobalNamespace",
 441                                      InfoType::IT_namespace);
 442   FunctionGet.Access = AccessSpecifier::AS_private;
 443   FunctionGet.IsMethod = true;
 444   ExpectedE.Bases.back().Children.Functions.emplace_back(
 445       std::move(FunctionGet));
 446   ExpectedE.Bases.back().Members.emplace_back(TypeInfo("int"), "I",
 447                                               AccessSpecifier::AS_private);
 448   ExpectedE.DefLoc = Location(0, llvm::SmallString<16>{"test.cpp"});
 449   ExpectedE.TagType = TagTypeKind::Class;
 450   CheckRecordInfo(&ExpectedE, E);
 451
 452   RecordInfo *H = InfoAsRecord(Infos[8].get());
 453   RecordInfo ExpectedH(EmptySID, /*Name=*/"H", /*Path=*/"GlobalNamespace");
 454   ExpectedH.Namespace.emplace_back(EmptySID, "GlobalNamespace",
 455                                    InfoType::IT_namespace);
 456   ExpectedH.TagType = TagTypeKind::Class;
 457   ExpectedH.DefLoc = Location(0, llvm::SmallString<16>{"test.cpp"});
 458   ExpectedH.Parents.emplace_back(EmptySID, /*Name=*/"E", InfoType::IT_record,
 459                                  /*QualName=*/"E", /*Path=*/"GlobalNamespace");
 460   ExpectedH.VirtualParents.emplace_back(EmptySID, /*Name=*/"G",
 461                                         InfoType::IT_record, /*QualName=*/"G",
 462                                         /*Path=*/"GlobalNamespace");
 463   ExpectedH.Bases.emplace_back(EmptySID, /*Name=*/"E",
 464                                /*Path=*/"GlobalNamespace", false,
 465                                AccessSpecifier::AS_private, true);
 466   ExpectedH.Bases.emplace_back(EmptySID, /*Name=*/"F",
 467                                /*Path=*/"GlobalNamespace", false,
 468                                AccessSpecifier::AS_private, false);
 469   FunctionInfo FunctionSetNew;
 470   FunctionSetNew.Name = "set";
 471   FunctionSetNew.ReturnType = TypeInfo("void");
 472   FunctionSetNew.Loc.emplace_back();
 473   FunctionSetNew.Params.emplace_back(TypeInfo("int"), "N");
 474   FunctionSetNew.Namespace.emplace_back(EmptySID, "F", InfoType::IT_record);
 475   FunctionSetNew.Namespace.emplace_back(EmptySID, "GlobalNamespace",
 476                                         InfoType::IT_namespace);
 477   FunctionSetNew.Access = AccessSpecifier::AS_private;
 478   FunctionSetNew.IsMethod = true;
 479   ExpectedH.Bases.back().Children.Functions.emplace_back(
 480       std::move(FunctionSetNew));
 481   ExpectedH.Bases.emplace_back(EmptySID, /*Name=*/"G",
 482                                /*Path=*/"GlobalNamespace", true,
 483                                AccessSpecifier::AS_private, false);
 484   FunctionInfo FunctionGetNew;
 485   FunctionGetNew.Name = "get";
 486   FunctionGetNew.ReturnType = TypeInfo("int");
 487   FunctionGetNew.DefLoc = Location();
 488   FunctionGetNew.Namespace.emplace_back(EmptySID, "G", InfoType::IT_record);
 489   FunctionGetNew.Namespace.emplace_back(EmptySID, "GlobalNamespace",
 490                                         InfoType::IT_namespace);
 491   FunctionGetNew.Access = AccessSpecifier::AS_private;
 492   FunctionGetNew.IsMethod = true;
 493   ExpectedH.Bases.back().Children.Functions.emplace_back(
 494       std::move(FunctionGetNew));
 495   ExpectedH.Bases.back().Members.emplace_back(TypeInfo("int"), "I",
 496                                               AccessSpecifier::AS_private);
 497   CheckRecordInfo(&ExpectedH, H);
 498
 499   RecordInfo *I = InfoAsRecord(Infos[10].get());
 500   RecordInfo ExpectedI(EmptySID, /*Name=*/"I", /*Path=*/"GlobalNamespace");
 501   ExpectedI.Namespace.emplace_back(EmptySID, "GlobalNamespace",
 502                                    InfoType::IT_namespace);
 503   ExpectedI.TagType = TagTypeKind::Class;
 504   ExpectedI.DefLoc = Location(0, llvm::SmallString<16>{"test.cpp"});
 505   CheckRecordInfo(&ExpectedI, I);
 506
 507   RecordInfo *J = InfoAsRecord(Infos[12].get());
 508   RecordInfo ExpectedJ(EmptySID, /*Name=*/"J", /*Path=*/"GlobalNamespace");
 509   ExpectedJ.Namespace.emplace_back(EmptySID, "GlobalNamespace",
 510                                    InfoType::IT_namespace);
 511   ExpectedJ.Parents.emplace_back(EmptySID, /*Name=*/"I<int>",
 512                                  InfoType::IT_record);
 513   ExpectedJ.Bases.emplace_back(EmptySID, /*Name=*/"I<int>",
 514                                /*Path=*/"GlobalNamespace", false,
 515                                AccessSpecifier::AS_public, true);
 516   ExpectedJ.DefLoc = Location(0, llvm::SmallString<16>{"test.cpp"});
 517   ExpectedJ.TagType = TagTypeKind::Class;
 518   CheckRecordInfo(&ExpectedJ, J);
 519 }
 520
 521 TEST(SerializeTest, emitModulePublicLFunctions) {
 522   EmittedInfoList Infos;
 523   std::vector<std::string> Args;
 524   Args.push_back("-fmodules-ts");
 525   ExtractInfosFromCodeWithArgs(R"raw(export module M;
 526 int moduleFunction(int x, double d = 3.2 - 1.0);
 527 static int staticModuleFunction(int x);
 528 export double exportedModuleFunction(double y);)raw",
 529                                2, /*Public=*/true, Infos, Args);
 530
 531   NamespaceInfo *BWithFunction = InfoAsNamespace(Infos[0].get());
 532   NamespaceInfo ExpectedBWithFunction(EmptySID);
 533   FunctionInfo F;
 534   F.Name = "moduleFunction";
 535   F.ReturnType = TypeInfo("int");
 536   F.Loc.emplace_back(0, llvm::SmallString<16>{"test.cpp"});
 537   F.Params.emplace_back(TypeInfo("int"), "x");
 538   F.Params.emplace_back(TypeInfo("double"), "d");
 539   F.Params.back().DefaultValue = "3.2 - 1.0";
 540   F.Access = AccessSpecifier::AS_none;
 541   ExpectedBWithFunction.Children.Functions.emplace_back(std::move(F));
 542   CheckNamespaceInfo(&ExpectedBWithFunction, BWithFunction);
 543
 544   NamespaceInfo *BWithExportedFunction = InfoAsNamespace(Infos[1].get());
 545   NamespaceInfo ExpectedBWithExportedFunction(EmptySID);
 546   FunctionInfo ExportedF;
 547   ExportedF.Name = "exportedModuleFunction";
 548   ExportedF.ReturnType =
 549       TypeInfo(Reference(EmptySID, "double", InfoType::IT_default));
 550   ExportedF.Loc.emplace_back(0, llvm::SmallString<16>{"test.cpp"});
 551   ExportedF.Params.emplace_back(TypeInfo("double"), "y");
 552   ExportedF.Access = AccessSpecifier::AS_none;
 553   ExpectedBWithExportedFunction.Children.Functions.emplace_back(
 554       std::move(ExportedF));
 555   CheckNamespaceInfo(&ExpectedBWithExportedFunction, BWithExportedFunction);
 556 }
 557
 558 // Test serialization of child records in namespaces and other records
 559 TEST(SerializeTest, emitChildRecords) {
 560   EmittedInfoList Infos;
 561   ExtractInfosFromCode("class A { class B {}; }; namespace { class C {}; } ", 8,
 562                        /*Public=*/false, Infos);
 563
 564   NamespaceInfo *ParentA = InfoAsNamespace(Infos[1].get());
 565   NamespaceInfo ExpectedParentA(EmptySID);
 566   ExpectedParentA.Children.Records.emplace_back(
 567       EmptySID, "A", InfoType::IT_record, "A", "GlobalNamespace");
 568   CheckNamespaceInfo(&ExpectedParentA, ParentA);
 569
 570   RecordInfo *ParentB = InfoAsRecord(Infos[3].get());
 571   RecordInfo ExpectedParentB(EmptySID);
 572   llvm::SmallString<128> ExpectedParentBPath("GlobalNamespace/A");
 573   llvm::sys::path::native(ExpectedParentBPath);
 574   ExpectedParentB.Children.Records.emplace_back(
 575       EmptySID, "B", InfoType::IT_record, "A::B", ExpectedParentBPath);
 576   CheckRecordInfo(&ExpectedParentB, ParentB);
 577
 578   NamespaceInfo *ParentC = InfoAsNamespace(Infos[7].get());
 579   NamespaceInfo ExpectedParentC(EmptySID);
 580   ExpectedParentC.Children.Records.emplace_back(
 581       EmptySID, "C", InfoType::IT_record, "C", "@nonymous_namespace");
 582   CheckNamespaceInfo(&ExpectedParentC, ParentC);
 583 }
 584
 585 // Test serialization of child namespaces
 586 TEST(SerializeTest, emitChildNamespaces) {
 587   EmittedInfoList Infos;
 588   ExtractInfosFromCode("namespace A { namespace B { } }", 4, /*Public=*/false,
 589                        Infos);
 590
 591   NamespaceInfo *ParentA = InfoAsNamespace(Infos[1].get());
 592   NamespaceInfo ExpectedParentA(EmptySID);
 593   ExpectedParentA.Children.Namespaces.emplace_back(EmptySID, "A",
 594                                                    InfoType::IT_namespace);
 595   CheckNamespaceInfo(&ExpectedParentA, ParentA);
 596
 597   NamespaceInfo *ParentB = InfoAsNamespace(Infos[3].get());
 598   NamespaceInfo ExpectedParentB(EmptySID);
 599   ExpectedParentB.Children.Namespaces.emplace_back(
 600       EmptySID, "B", InfoType::IT_namespace, "A::B", "A");
 601   CheckNamespaceInfo(&ExpectedParentB, ParentB);
 602 }
 603
 604 TEST(SerializeTests, emitTypedefs) {
 605   EmittedInfoList Infos;
 606   ExtractInfosFromCode("typedef int MyInt; using MyDouble = double;", 2,
 607                        /*Public=*/false, Infos);
 608
 609   // First info will be the global namespace with the typedef in it.
 610   NamespaceInfo *GlobalNS1 = InfoAsNamespace(Infos[0].get());
 611   ASSERT_EQ(1u, GlobalNS1->Children.Typedefs.size());
 612
 613   const TypedefInfo &FirstTD = GlobalNS1->Children.Typedefs[0];
 614   EXPECT_EQ("MyInt", FirstTD.Name);
 615   EXPECT_FALSE(FirstTD.IsUsing);
 616   EXPECT_EQ("int", FirstTD.Underlying.Type.Name);
 617
 618   // The second will be another global namespace with the using in it (the
 619   // global namespace is duplicated because the items haven't been merged at the
 620   // serialization phase of processing).
 621   NamespaceInfo *GlobalNS2 = InfoAsNamespace(Infos[1].get());
 622   ASSERT_EQ(1u, GlobalNS2->Children.Typedefs.size());
 623
 624   // Second is the "using" typedef.
 625   const TypedefInfo &SecondTD = GlobalNS2->Children.Typedefs[0];
 626   EXPECT_EQ("MyDouble", SecondTD.Name);
 627   EXPECT_TRUE(SecondTD.IsUsing);
 628   EXPECT_EQ("double", SecondTD.Underlying.Type.Name);
 629 }
 630
 631 TEST(SerializeTests, emitFunctionTemplate) {
 632   EmittedInfoList Infos;
 633   // A template and a specialization.
 634   ExtractInfosFromCode("template<typename T = int> void GetFoo(T);\n"
 635                        "template<> void GetFoo<bool>(bool);",
 636                        2,
 637                        /*Public=*/false, Infos);
 638
 639   // First info will be the global namespace.
 640   NamespaceInfo *GlobalNS1 = InfoAsNamespace(Infos[0].get());
 641   ASSERT_EQ(1u, GlobalNS1->Children.Functions.size());
 642
 643   const FunctionInfo &Func1 = GlobalNS1->Children.Functions[0];
 644   EXPECT_EQ("GetFoo", Func1.Name);
 645   ASSERT_TRUE(Func1.Template);
 646   EXPECT_FALSE(Func1.Template->Specialization); // Not a specialization.
 647
 648   // Template parameter.
 649   ASSERT_EQ(1u, Func1.Template->Params.size());
 650   EXPECT_EQ("typename T = int", Func1.Template->Params[0].Contents);
 651
 652   // The second will be another global namespace with the function in it (the
 653   // global namespace is duplicated because the items haven't been merged at the
 654   // serialization phase of processing).
 655   NamespaceInfo *GlobalNS2 = InfoAsNamespace(Infos[1].get());
 656   ASSERT_EQ(1u, GlobalNS2->Children.Functions.size());
 657
 658   // This one is a template specialization.
 659   const FunctionInfo &Func2 = GlobalNS2->Children.Functions[0];
 660   EXPECT_EQ("GetFoo", Func2.Name);
 661   ASSERT_TRUE(Func2.Template);
 662   EXPECT_TRUE(Func2.Template->Params.empty()); // No template params.
 663   ASSERT_TRUE(Func2.Template->Specialization);
 664
 665   // Specialization values.
 666   ASSERT_EQ(1u, Func2.Template->Specialization->Params.size());
 667   EXPECT_EQ("bool", Func2.Template->Specialization->Params[0].Contents);
 668   EXPECT_EQ(Func1.USR, Func2.Template->Specialization->SpecializationOf);
 669 }
 670
 671 TEST(SerializeTests, emitClassTemplate) {
 672   EmittedInfoList Infos;
 673   // This will generate 2x the number of infos: each Record will be followed by
 674   // a copy of the global namespace containing it (this test checks the data
 675   // pre-merge).
 676   ExtractInfosFromCode(
 677       "template<int I> class MyTemplate { int i[I]; };\n"
 678       "template<> class MyTemplate<0> {};\n"
 679       "template<typename T, int U = 1> class OtherTemplate {};\n"
 680       "template<int U> class OtherTemplate<MyTemplate<0>, U> {};",
 681       8,
 682       /*Public=*/false, Infos);
 683
 684   // First record.
 685   const RecordInfo *Rec1 = InfoAsRecord(Infos[0].get());
 686   EXPECT_EQ("MyTemplate", Rec1->Name);
 687   ASSERT_TRUE(Rec1->Template);
 688   EXPECT_FALSE(Rec1->Template->Specialization); // Not a specialization.
 689
 690   // First record template parameter.
 691   ASSERT_EQ(1u, Rec1->Template->Params.size());
 692   EXPECT_EQ("int I", Rec1->Template->Params[0].Contents);
 693
 694   // Second record.
 695   const RecordInfo *Rec2 = InfoAsRecord(Infos[2].get());
 696   EXPECT_EQ("MyTemplate", Rec2->Name);
 697   ASSERT_TRUE(Rec2->Template);
 698   EXPECT_TRUE(Rec2->Template->Params.empty()); // No template params.
 699   ASSERT_TRUE(Rec2->Template->Specialization);
 700
 701   // Second record specialization values.
 702   ASSERT_EQ(1u, Rec2->Template->Specialization->Params.size());
 703   EXPECT_EQ("0", Rec2->Template->Specialization->Params[0].Contents);
 704   EXPECT_EQ(Rec1->USR, Rec2->Template->Specialization->SpecializationOf);
 705
 706   // Third record.
 707   const RecordInfo *Rec3 = InfoAsRecord(Infos[4].get());
 708   EXPECT_EQ("OtherTemplate", Rec3->Name);
 709   ASSERT_TRUE(Rec3->Template);
 710
 711   // Third record template parameters.
 712   ASSERT_EQ(2u, Rec3->Template->Params.size());
 713   EXPECT_EQ("typename T", Rec3->Template->Params[0].Contents);
 714   EXPECT_EQ("int U = 1", Rec3->Template->Params[1].Contents);
 715
 716   // Fourth record.
 717   const RecordInfo *Rec4 = InfoAsRecord(Infos[6].get());
 718   EXPECT_EQ("OtherTemplate", Rec3->Name);
 719   ASSERT_TRUE(Rec4->Template);
 720   ASSERT_TRUE(Rec4->Template->Specialization);
 721
 722   // Fourth record template + specialization parameters.
 723   ASSERT_EQ(1u, Rec4->Template->Params.size());
 724   EXPECT_EQ("int U", Rec4->Template->Params[0].Contents);
 725   ASSERT_EQ(2u, Rec4->Template->Specialization->Params.size());
 726   EXPECT_EQ("MyTemplate<0>",
 727             Rec4->Template->Specialization->Params[0].Contents);
 728   EXPECT_EQ("U", Rec4->Template->Specialization->Params[1].Contents);
 729 }
 730
 731 } // namespace doc
 732 } // end namespace clang