clang/unittests/Basic/SourceManagerTest.cpp

   1 //===- unittests/Basic/SourceManagerTest.cpp ------ SourceManager tests ---===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "clang/Basic/SourceManager.h"
  10 #include "clang/Basic/Diagnostic.h"
  11 #include "clang/Basic/DiagnosticOptions.h"
  12 #include "clang/Basic/FileManager.h"
  13 #include "clang/Basic/LangOptions.h"
  14 #include "clang/Basic/TargetInfo.h"
  15 #include "clang/Basic/TargetOptions.h"
  16 #include "clang/Lex/HeaderSearch.h"
  17 #include "clang/Lex/HeaderSearchOptions.h"
  18 #include "clang/Lex/ModuleLoader.h"
  19 #include "clang/Lex/Preprocessor.h"
  20 #include "clang/Lex/PreprocessorOptions.h"
  21 #include "llvm/ADT/SmallString.h"
  22 #include "llvm/Config/llvm-config.h"
  23 #include "llvm/Support/MemoryBuffer.h"
  24 #include "llvm/Support/Process.h"
  25 #include "gtest/gtest.h"
  26 #include <cstddef>
  27
  28 using namespace clang;
  29
  30 namespace clang {
  31 class SourceManagerTestHelper {
  32 public:
  33   static FileID makeFileID(int ID) { return FileID::get(ID); }
  34 };
  35 } // namespace clang
  36
  37 namespace {
  38
  39 // The test fixture.
  40 class SourceManagerTest : public ::testing::Test {
  41 protected:
  42   SourceManagerTest()
  43     : FileMgr(FileMgrOpts),
  44       DiagID(new DiagnosticIDs()),
  45       Diags(DiagID, new DiagnosticOptions, new IgnoringDiagConsumer()),
  46       SourceMgr(Diags, FileMgr),
  47       TargetOpts(new TargetOptions) {
  48     TargetOpts->Triple = "x86_64-apple-darwin11.1.0";
  49     Target = TargetInfo::CreateTargetInfo(Diags, TargetOpts);
  50   }
  51
  52   FileSystemOptions FileMgrOpts;
  53   FileManager FileMgr;
  54   IntrusiveRefCntPtr<DiagnosticIDs> DiagID;
  55   DiagnosticsEngine Diags;
  56   SourceManager SourceMgr;
  57   LangOptions LangOpts;
  58   std::shared_ptr<TargetOptions> TargetOpts;
  59   IntrusiveRefCntPtr<TargetInfo> Target;
  60 };
  61
  62 TEST_F(SourceManagerTest, isInMemoryBuffersNoSourceLocationInfo) {
  63   // Check for invalid source location for each method
  64   SourceLocation LocEmpty;
  65   bool isWrittenInBuiltInFileFalse = SourceMgr.isWrittenInBuiltinFile(LocEmpty);
  66   bool isWrittenInCommandLineFileFalse =
  67       SourceMgr.isWrittenInCommandLineFile(LocEmpty);
  68   bool isWrittenInScratchSpaceFalse =
  69       SourceMgr.isWrittenInScratchSpace(LocEmpty);
  70
  71   EXPECT_FALSE(isWrittenInBuiltInFileFalse);
  72   EXPECT_FALSE(isWrittenInCommandLineFileFalse);
  73   EXPECT_FALSE(isWrittenInScratchSpaceFalse);
  74
  75   // Check for valid source location per filename for each method
  76   const char *Source = "int x";
  77
  78   std::unique_ptr<llvm::MemoryBuffer> BuiltInBuf =
  79       llvm::MemoryBuffer::getMemBuffer(Source);
  80   FileEntryRef BuiltInFile =
  81       FileMgr.getVirtualFileRef("<built-in>", BuiltInBuf->getBufferSize(), 0);
  82   SourceMgr.overrideFileContents(BuiltInFile, std::move(BuiltInBuf));
  83   FileID BuiltInFileID =
  84       SourceMgr.getOrCreateFileID(BuiltInFile, SrcMgr::C_User);
  85   SourceMgr.setMainFileID(BuiltInFileID);
  86   SourceLocation LocBuiltIn =
  87       SourceMgr.getLocForStartOfFile(SourceMgr.getMainFileID());
  88   bool isWrittenInBuiltInFileTrue =
  89       SourceMgr.isWrittenInBuiltinFile(LocBuiltIn);
  90
  91   std::unique_ptr<llvm::MemoryBuffer> CommandLineBuf =
  92       llvm::MemoryBuffer::getMemBuffer(Source);
  93   FileEntryRef CommandLineFile = FileMgr.getVirtualFileRef(
  94       "<command line>", CommandLineBuf->getBufferSize(), 0);
  95   SourceMgr.overrideFileContents(CommandLineFile, std::move(CommandLineBuf));
  96   FileID CommandLineFileID =
  97       SourceMgr.getOrCreateFileID(CommandLineFile, SrcMgr::C_User);
  98   SourceMgr.setMainFileID(CommandLineFileID);
  99   SourceLocation LocCommandLine =
 100       SourceMgr.getLocForStartOfFile(SourceMgr.getMainFileID());
 101   bool isWrittenInCommandLineFileTrue =
 102       SourceMgr.isWrittenInCommandLineFile(LocCommandLine);
 103
 104   std::unique_ptr<llvm::MemoryBuffer> ScratchSpaceBuf =
 105       llvm::MemoryBuffer::getMemBuffer(Source);
 106   FileEntryRef ScratchSpaceFile = FileMgr.getVirtualFileRef(
 107       "<scratch space>", ScratchSpaceBuf->getBufferSize(), 0);
 108   SourceMgr.overrideFileContents(ScratchSpaceFile, std::move(ScratchSpaceBuf));
 109   FileID ScratchSpaceFileID =
 110       SourceMgr.getOrCreateFileID(ScratchSpaceFile, SrcMgr::C_User);
 111   SourceMgr.setMainFileID(ScratchSpaceFileID);
 112   SourceLocation LocScratchSpace =
 113       SourceMgr.getLocForStartOfFile(SourceMgr.getMainFileID());
 114   bool isWrittenInScratchSpaceTrue =
 115       SourceMgr.isWrittenInScratchSpace(LocScratchSpace);
 116
 117   EXPECT_TRUE(isWrittenInBuiltInFileTrue);
 118   EXPECT_TRUE(isWrittenInCommandLineFileTrue);
 119   EXPECT_TRUE(isWrittenInScratchSpaceTrue);
 120 }
 121
 122 TEST_F(SourceManagerTest, isInSystemHeader) {
 123   // Check for invalid source location
 124   SourceLocation LocEmpty;
 125   bool isInSystemHeaderFalse = SourceMgr.isInSystemHeader(LocEmpty);
 126   ASSERT_FALSE(isInSystemHeaderFalse);
 127 }
 128
 129 TEST_F(SourceManagerTest, isBeforeInTranslationUnit) {
 130   const char *source =
 131     "#define M(x) [x]\n"
 132     "M(foo)";
 133   std::unique_ptr<llvm::MemoryBuffer> Buf =
 134       llvm::MemoryBuffer::getMemBuffer(source);
 135   FileID mainFileID = SourceMgr.createFileID(std::move(Buf));
 136   SourceMgr.setMainFileID(mainFileID);
 137
 138   TrivialModuleLoader ModLoader;
 139   HeaderSearch HeaderInfo(std::make_shared<HeaderSearchOptions>(), SourceMgr,
 140                           Diags, LangOpts, &*Target);
 141   Preprocessor PP(std::make_shared<PreprocessorOptions>(), Diags, LangOpts,
 142                   SourceMgr, HeaderInfo, ModLoader,
 143                   /*IILookup =*/nullptr,
 144                   /*OwnsHeaderSearch =*/false);
 145   PP.Initialize(*Target);
 146   PP.EnterMainSourceFile();
 147
 148   std::vector<Token> toks;
 149   PP.LexTokensUntilEOF(&toks);
 150
 151   // Make sure we got the tokens that we expected.
 152   ASSERT_EQ(3U, toks.size());
 153   ASSERT_EQ(tok::l_square, toks[0].getKind());
 154   ASSERT_EQ(tok::identifier, toks[1].getKind());
 155   ASSERT_EQ(tok::r_square, toks[2].getKind());
 156
 157   SourceLocation lsqrLoc = toks[0].getLocation();
 158   SourceLocation idLoc = toks[1].getLocation();
 159   SourceLocation rsqrLoc = toks[2].getLocation();
 160
 161   SourceLocation macroExpStartLoc = SourceMgr.translateLineCol(mainFileID, 2, 1);
 162   SourceLocation macroExpEndLoc = SourceMgr.translateLineCol(mainFileID, 2, 6);
 163   ASSERT_TRUE(macroExpStartLoc.isFileID());
 164   ASSERT_TRUE(macroExpEndLoc.isFileID());
 165
 166   SmallString<32> str;
 167   ASSERT_EQ("M", PP.getSpelling(macroExpStartLoc, str));
 168   ASSERT_EQ(")", PP.getSpelling(macroExpEndLoc, str));
 169
 170   EXPECT_TRUE(SourceMgr.isBeforeInTranslationUnit(lsqrLoc, idLoc));
 171   EXPECT_TRUE(SourceMgr.isBeforeInTranslationUnit(idLoc, rsqrLoc));
 172   EXPECT_TRUE(SourceMgr.isBeforeInTranslationUnit(macroExpStartLoc, idLoc));
 173   EXPECT_TRUE(SourceMgr.isBeforeInTranslationUnit(idLoc, macroExpEndLoc));
 174 }
 175
 176 TEST_F(SourceManagerTest, isBeforeInTranslationUnitWithTokenSplit) {
 177   const char *main = R"cpp(
 178     #define ID(X) X
 179     ID(
 180       ID(a >> b)
 181       c
 182     )
 183   )cpp";
 184
 185   SourceMgr.setMainFileID(
 186       SourceMgr.createFileID(llvm::MemoryBuffer::getMemBuffer(main)));
 187
 188   TrivialModuleLoader ModLoader;
 189   HeaderSearch HeaderInfo(std::make_shared<HeaderSearchOptions>(), SourceMgr,
 190                           Diags, LangOpts, &*Target);
 191   Preprocessor PP(std::make_shared<PreprocessorOptions>(), Diags, LangOpts,
 192                   SourceMgr, HeaderInfo, ModLoader,
 193                   /*IILookup =*/nullptr,
 194                   /*OwnsHeaderSearch =*/false);
 195   PP.Initialize(*Target);
 196   PP.EnterMainSourceFile();
 197   llvm::SmallString<8> Scratch;
 198
 199   std::vector<Token> toks;
 200   PP.LexTokensUntilEOF(&toks);
 201
 202   // Make sure we got the tokens that we expected.
 203   ASSERT_EQ(4U, toks.size()) << "a >> b c";
 204   // Sanity check their order.
 205   for (unsigned I = 0; I < toks.size() - 1; ++I) {
 206     EXPECT_TRUE(SourceMgr.isBeforeInTranslationUnit(toks[I].getLocation(),
 207                                                     toks[I + 1].getLocation()));
 208     EXPECT_FALSE(SourceMgr.isBeforeInTranslationUnit(toks[I + 1].getLocation(),
 209                                                      toks[I].getLocation()));
 210   }
 211
 212   // Split the >> into two > tokens, as happens when parsing nested templates.
 213   unsigned RightShiftIndex = 1;
 214   SourceLocation RightShift = toks[RightShiftIndex].getLocation();
 215   EXPECT_EQ(">>", Lexer::getSpelling(SourceMgr.getSpellingLoc(RightShift),
 216                                      Scratch, SourceMgr, LangOpts));
 217   SourceLocation Greater1 = PP.SplitToken(RightShift, /*Length=*/1);
 218   SourceLocation Greater2 = RightShift.getLocWithOffset(1);
 219   EXPECT_TRUE(Greater1.isMacroID());
 220   EXPECT_EQ(">", Lexer::getSpelling(SourceMgr.getSpellingLoc(Greater1), Scratch,
 221                                     SourceMgr, LangOpts));
 222   EXPECT_EQ(">", Lexer::getSpelling(SourceMgr.getSpellingLoc(Greater2), Scratch,
 223                                     SourceMgr, LangOpts));
 224   EXPECT_EQ(SourceMgr.getImmediateExpansionRange(Greater1).getBegin(),
 225             RightShift);
 226
 227   for (unsigned I = 0; I < toks.size(); ++I) {
 228     SCOPED_TRACE("Token " + std::to_string(I));
 229     // Right-shift is the parent of Greater1, so it compares less.
 230     EXPECT_EQ(
 231         SourceMgr.isBeforeInTranslationUnit(toks[I].getLocation(), Greater1),
 232         I <= RightShiftIndex);
 233     EXPECT_EQ(
 234         SourceMgr.isBeforeInTranslationUnit(toks[I].getLocation(), Greater2),
 235         I <= RightShiftIndex);
 236     EXPECT_EQ(
 237         SourceMgr.isBeforeInTranslationUnit(Greater1, toks[I].getLocation()),
 238         RightShiftIndex < I);
 239     EXPECT_EQ(
 240         SourceMgr.isBeforeInTranslationUnit(Greater2, toks[I].getLocation()),
 241         RightShiftIndex < I);
 242   }
 243   EXPECT_TRUE(SourceMgr.isBeforeInTranslationUnit(Greater1, Greater2));
 244   EXPECT_FALSE(SourceMgr.isBeforeInTranslationUnit(Greater2, Greater1));
 245 }
 246
 247 TEST_F(SourceManagerTest, getColumnNumber) {
 248   const char *Source =
 249     "int x;\n"
 250     "int y;";
 251
 252   std::unique_ptr<llvm::MemoryBuffer> Buf =
 253       llvm::MemoryBuffer::getMemBuffer(Source);
 254   FileID MainFileID = SourceMgr.createFileID(std::move(Buf));
 255   SourceMgr.setMainFileID(MainFileID);
 256
 257   bool Invalid;
 258
 259   Invalid = false;
 260   EXPECT_EQ(1U, SourceMgr.getColumnNumber(MainFileID, 0, &Invalid));
 261   EXPECT_TRUE(!Invalid);
 262
 263   Invalid = false;
 264   EXPECT_EQ(5U, SourceMgr.getColumnNumber(MainFileID, 4, &Invalid));
 265   EXPECT_TRUE(!Invalid);
 266
 267   Invalid = false;
 268   EXPECT_EQ(1U, SourceMgr.getColumnNumber(MainFileID, 7, &Invalid));
 269   EXPECT_TRUE(!Invalid);
 270
 271   Invalid = false;
 272   EXPECT_EQ(5U, SourceMgr.getColumnNumber(MainFileID, 11, &Invalid));
 273   EXPECT_TRUE(!Invalid);
 274
 275   Invalid = false;
 276   EXPECT_EQ(7U, SourceMgr.getColumnNumber(MainFileID, strlen(Source),
 277                                          &Invalid));
 278   EXPECT_TRUE(!Invalid);
 279
 280   Invalid = false;
 281   SourceMgr.getColumnNumber(MainFileID, strlen(Source)+1, &Invalid);
 282   EXPECT_TRUE(Invalid);
 283
 284   // Test invalid files
 285   Invalid = false;
 286   SourceMgr.getColumnNumber(FileID(), 0, &Invalid);
 287   EXPECT_TRUE(Invalid);
 288
 289   Invalid = false;
 290   SourceMgr.getColumnNumber(FileID(), 1, &Invalid);
 291   EXPECT_TRUE(Invalid);
 292
 293   // Test with no invalid flag.
 294   EXPECT_EQ(1U, SourceMgr.getColumnNumber(MainFileID, 0, nullptr));
 295 }
 296
 297 TEST_F(SourceManagerTest, locationPrintTest) {
 298   const char *header = "#define IDENTITY(x) x\n";
 299
 300   const char *Source = "int x;\n"
 301                        "include \"test-header.h\"\n"
 302                        "IDENTITY(int y);\n"
 303                        "int z;";
 304
 305   std::unique_ptr<llvm::MemoryBuffer> HeaderBuf =
 306       llvm::MemoryBuffer::getMemBuffer(header);
 307   std::unique_ptr<llvm::MemoryBuffer> Buf =
 308       llvm::MemoryBuffer::getMemBuffer(Source);
 309
 310   FileEntryRef SourceFile =
 311       FileMgr.getVirtualFileRef("/mainFile.cpp", Buf->getBufferSize(), 0);
 312   SourceMgr.overrideFileContents(SourceFile, std::move(Buf));
 313
 314   FileEntryRef HeaderFile = FileMgr.getVirtualFileRef(
 315       "/test-header.h", HeaderBuf->getBufferSize(), 0);
 316   SourceMgr.overrideFileContents(HeaderFile, std::move(HeaderBuf));
 317
 318   FileID MainFileID = SourceMgr.getOrCreateFileID(SourceFile, SrcMgr::C_User);
 319   FileID HeaderFileID = SourceMgr.getOrCreateFileID(HeaderFile, SrcMgr::C_User);
 320   SourceMgr.setMainFileID(MainFileID);
 321
 322   auto BeginLoc = SourceMgr.getLocForStartOfFile(MainFileID);
 323   auto EndLoc = SourceMgr.getLocForEndOfFile(MainFileID);
 324
 325   auto BeginEOLLoc = SourceMgr.translateLineCol(MainFileID, 1, 7);
 326
 327   auto HeaderLoc = SourceMgr.getLocForStartOfFile(HeaderFileID);
 328
 329   EXPECT_EQ(BeginLoc.printToString(SourceMgr), "/mainFile.cpp:1:1");
 330   EXPECT_EQ(EndLoc.printToString(SourceMgr), "/mainFile.cpp:4:7");
 331
 332   EXPECT_EQ(BeginEOLLoc.printToString(SourceMgr), "/mainFile.cpp:1:7");
 333   EXPECT_EQ(HeaderLoc.printToString(SourceMgr), "/test-header.h:1:1");
 334
 335   EXPECT_EQ(SourceRange(BeginLoc, BeginLoc).printToString(SourceMgr),
 336             "</mainFile.cpp:1:1>");
 337   EXPECT_EQ(SourceRange(BeginLoc, BeginEOLLoc).printToString(SourceMgr),
 338             "</mainFile.cpp:1:1, col:7>");
 339   EXPECT_EQ(SourceRange(BeginLoc, EndLoc).printToString(SourceMgr),
 340             "</mainFile.cpp:1:1, line:4:7>");
 341   EXPECT_EQ(SourceRange(BeginLoc, HeaderLoc).printToString(SourceMgr),
 342             "</mainFile.cpp:1:1, /test-header.h:1:1>");
 343 }
 344
 345 TEST_F(SourceManagerTest, getInvalidBOM) {
 346   ASSERT_EQ(SrcMgr::ContentCache::getInvalidBOM(""), nullptr);
 347   ASSERT_EQ(SrcMgr::ContentCache::getInvalidBOM("\x00\x00\x00"), nullptr);
 348   ASSERT_EQ(SrcMgr::ContentCache::getInvalidBOM("\xFF\xFF\xFF"), nullptr);
 349   ASSERT_EQ(SrcMgr::ContentCache::getInvalidBOM("#include <iostream>"),
 350             nullptr);
 351
 352   ASSERT_EQ(StringRef(SrcMgr::ContentCache::getInvalidBOM(
 353                 "\xFE\xFF#include <iostream>")),
 354             "UTF-16 (BE)");
 355   ASSERT_EQ(StringRef(SrcMgr::ContentCache::getInvalidBOM(
 356                 "\xFF\xFE#include <iostream>")),
 357             "UTF-16 (LE)");
 358   ASSERT_EQ(StringRef(SrcMgr::ContentCache::getInvalidBOM(
 359                 "\x2B\x2F\x76#include <iostream>")),
 360             "UTF-7");
 361   ASSERT_EQ(StringRef(SrcMgr::ContentCache::getInvalidBOM(
 362                 "\xF7\x64\x4C#include <iostream>")),
 363             "UTF-1");
 364   ASSERT_EQ(StringRef(SrcMgr::ContentCache::getInvalidBOM(
 365                 "\xDD\x73\x66\x73#include <iostream>")),
 366             "UTF-EBCDIC");
 367   ASSERT_EQ(StringRef(SrcMgr::ContentCache::getInvalidBOM(
 368                 "\x0E\xFE\xFF#include <iostream>")),
 369             "SCSU");
 370   ASSERT_EQ(StringRef(SrcMgr::ContentCache::getInvalidBOM(
 371                 "\xFB\xEE\x28#include <iostream>")),
 372             "BOCU-1");
 373   ASSERT_EQ(StringRef(SrcMgr::ContentCache::getInvalidBOM(
 374                 "\x84\x31\x95\x33#include <iostream>")),
 375             "GB-18030");
 376   ASSERT_EQ(StringRef(SrcMgr::ContentCache::getInvalidBOM(
 377                 llvm::StringLiteral::withInnerNUL(
 378                     "\x00\x00\xFE\xFF#include <iostream>"))),
 379             "UTF-32 (BE)");
 380   ASSERT_EQ(StringRef(SrcMgr::ContentCache::getInvalidBOM(
 381                 llvm::StringLiteral::withInnerNUL(
 382                     "\xFF\xFE\x00\x00#include <iostream>"))),
 383             "UTF-32 (LE)");
 384 }
 385
 386 // Regression test - there was an out of bound access for buffers not terminated by zero.
 387 TEST_F(SourceManagerTest, getLineNumber) {
 388   const unsigned pageSize = llvm::sys::Process::getPageSizeEstimate();
 389   std::unique_ptr<char[]> source(new char[pageSize]);
 390   for(unsigned i = 0; i < pageSize; ++i) {
 391     source[i] = 'a';
 392   }
 393
 394   std::unique_ptr<llvm::MemoryBuffer> Buf =
 395       llvm::MemoryBuffer::getMemBuffer(
 396         llvm::MemoryBufferRef(
 397           llvm::StringRef(source.get(), 3), "whatever"
 398         ),
 399         false
 400       );
 401
 402   FileID mainFileID = SourceMgr.createFileID(std::move(Buf));
 403   SourceMgr.setMainFileID(mainFileID);
 404
 405   ASSERT_NO_FATAL_FAILURE(SourceMgr.getLineNumber(mainFileID, 1, nullptr));
 406 }
 407
 408 struct FakeExternalSLocEntrySource : ExternalSLocEntrySource {
 409   bool ReadSLocEntry(int ID) override { return {}; }
 410   int getSLocEntryID(SourceLocation::UIntTy SLocOffset) override { return 0; }
 411   std::pair<SourceLocation, StringRef> getModuleImportLoc(int ID) override {
 412     return {};
 413   }
 414 };
 415
 416 TEST_F(SourceManagerTest, loadedSLocEntryIsInTheSameTranslationUnit) {
 417   auto InSameTU = [=](int LID, int RID) {
 418     return SourceMgr.isInTheSameTranslationUnitImpl(
 419         std::make_pair(SourceManagerTestHelper::makeFileID(LID), 0),
 420         std::make_pair(SourceManagerTestHelper::makeFileID(RID), 0));
 421   };
 422
 423   FakeExternalSLocEntrySource ExternalSource;
 424   SourceMgr.setExternalSLocEntrySource(&ExternalSource);
 425
 426   unsigned ANumFileIDs = 10;
 427   auto [AFirstID, X] = SourceMgr.AllocateLoadedSLocEntries(ANumFileIDs, 10);
 428   int ALastID = AFirstID + ANumFileIDs - 1;
 429   // FileID(-11)..FileID(-2)
 430   ASSERT_EQ(AFirstID, -11);
 431   ASSERT_EQ(ALastID, -2);
 432
 433   unsigned BNumFileIDs = 20;
 434   auto [BFirstID, Y] = SourceMgr.AllocateLoadedSLocEntries(BNumFileIDs, 20);
 435   int BLastID = BFirstID + BNumFileIDs - 1;
 436   // FileID(-31)..FileID(-12)
 437   ASSERT_EQ(BFirstID, -31);
 438   ASSERT_EQ(BLastID, -12);
 439
 440   // Loaded vs local.
 441   EXPECT_FALSE(InSameTU(-2, 1));
 442
 443   // Loaded in the same allocation A.
 444   EXPECT_TRUE(InSameTU(-11, -2));
 445   EXPECT_TRUE(InSameTU(-11, -6));
 446
 447   // Loaded in the same allocation B.
 448   EXPECT_TRUE(InSameTU(-31, -12));
 449   EXPECT_TRUE(InSameTU(-31, -16));
 450
 451   // Loaded from different allocations A and B.
 452   EXPECT_FALSE(InSameTU(-12, -11));
 453 }
 454
 455 #if defined(LLVM_ON_UNIX)
 456
 457 // A single SourceManager instance is sometimes reused across multiple
 458 // compilations. This test makes sure we're resetting caches built for tracking
 459 // include locations that are based on FileIDs, to make sure we don't report
 460 // wrong include locations when FileIDs coincide between two different runs.
 461 TEST_F(SourceManagerTest, ResetsIncludeLocMap) {
 462   auto ParseFile = [&] {
 463     TrivialModuleLoader ModLoader;
 464     HeaderSearch HeaderInfo(std::make_shared<HeaderSearchOptions>(), SourceMgr,
 465                             Diags, LangOpts, &*Target);
 466     Preprocessor PP(std::make_shared<PreprocessorOptions>(), Diags, LangOpts,
 467                     SourceMgr, HeaderInfo, ModLoader,
 468                     /*IILookup =*/nullptr,
 469                     /*OwnsHeaderSearch =*/false);
 470     PP.Initialize(*Target);
 471     PP.EnterMainSourceFile();
 472     PP.LexTokensUntilEOF();
 473     EXPECT_FALSE(Diags.hasErrorOccurred());
 474   };
 475
 476   auto Buf = llvm::MemoryBuffer::getMemBuffer("");
 477   FileEntryRef HeaderFile =
 478       FileMgr.getVirtualFileRef("/foo.h", Buf->getBufferSize(), 0);
 479   SourceMgr.overrideFileContents(HeaderFile, std::move(Buf));
 480
 481   Buf = llvm::MemoryBuffer::getMemBuffer(R"cpp(#include "/foo.h")cpp");
 482   FileEntryRef BarFile =
 483       FileMgr.getVirtualFileRef("/bar.h", Buf->getBufferSize(), 0);
 484   SourceMgr.overrideFileContents(BarFile, std::move(Buf));
 485   SourceMgr.createFileID(BarFile, {}, clang::SrcMgr::C_User);
 486
 487   Buf = llvm::MemoryBuffer::getMemBuffer(R"cpp(#include "/foo.h")cpp");
 488   FileID MFID = SourceMgr.createFileID(std::move(Buf));
 489   SourceMgr.setMainFileID(MFID);
 490
 491   ParseFile();
 492   auto FooFID = SourceMgr.getOrCreateFileID(HeaderFile, clang::SrcMgr::C_User);
 493   auto IncFID = SourceMgr.getDecomposedIncludedLoc(FooFID).first;
 494   EXPECT_EQ(IncFID, MFID);
 495
 496   // Clean up source-manager state before we start next parse.
 497   SourceMgr.clearIDTables();
 498
 499   // Set up a new main file.
 500   Buf = llvm::MemoryBuffer::getMemBuffer(R"cpp(
 501   // silly comment 42
 502   #include "/bar.h")cpp");
 503   MFID = SourceMgr.createFileID(std::move(Buf));
 504   SourceMgr.setMainFileID(MFID);
 505
 506   ParseFile();
 507   // Make sure foo.h got the same file-id in both runs.
 508   EXPECT_EQ(FooFID,
 509             SourceMgr.getOrCreateFileID(HeaderFile, clang::SrcMgr::C_User));
 510   auto BarFID = SourceMgr.getOrCreateFileID(BarFile, clang::SrcMgr::C_User);
 511   IncFID = SourceMgr.getDecomposedIncludedLoc(FooFID).first;
 512   // Check that includer is bar.h during this run.
 513   EXPECT_EQ(IncFID, BarFID);
 514 }
 515
 516 TEST_F(SourceManagerTest, getMacroArgExpandedLocation) {
 517   const char *header =
 518     "#define FM(x,y) x\n";
 519
 520   const char *main =
 521     "#include \"/test-header.h\"\n"
 522     "#define VAL 0\n"
 523     "FM(VAL,0)\n"
 524     "FM(0,VAL)\n"
 525     "FM(FM(0,VAL),0)\n"
 526     "#define CONCAT(X, Y) X##Y\n"
 527     "CONCAT(1,1)\n";
 528
 529   std::unique_ptr<llvm::MemoryBuffer> HeaderBuf =
 530       llvm::MemoryBuffer::getMemBuffer(header);
 531   std::unique_ptr<llvm::MemoryBuffer> MainBuf =
 532       llvm::MemoryBuffer::getMemBuffer(main);
 533   FileID mainFileID = SourceMgr.createFileID(std::move(MainBuf));
 534   SourceMgr.setMainFileID(mainFileID);
 535
 536   FileEntryRef headerFile = FileMgr.getVirtualFileRef(
 537       "/test-header.h", HeaderBuf->getBufferSize(), 0);
 538   SourceMgr.overrideFileContents(headerFile, std::move(HeaderBuf));
 539
 540   TrivialModuleLoader ModLoader;
 541   HeaderSearch HeaderInfo(std::make_shared<HeaderSearchOptions>(), SourceMgr,
 542                           Diags, LangOpts, &*Target);
 543
 544   Preprocessor PP(std::make_shared<PreprocessorOptions>(), Diags, LangOpts,
 545                   SourceMgr, HeaderInfo, ModLoader,
 546                   /*IILookup =*/nullptr,
 547                   /*OwnsHeaderSearch =*/false);
 548   // Ensure we can get expanded locations in presence of implicit includes.
 549   // These are different than normal includes since predefines buffer doesn't
 550   // have a valid insertion location.
 551   PP.setPredefines("#include \"/implicit-header.h\"");
 552   FileMgr.getVirtualFileRef("/implicit-header.h", 0, 0);
 553   PP.Initialize(*Target);
 554   PP.EnterMainSourceFile();
 555
 556   std::vector<Token> toks;
 557   PP.LexTokensUntilEOF(&toks);
 558
 559   // Make sure we got the tokens that we expected.
 560   ASSERT_EQ(4U, toks.size());
 561   ASSERT_EQ(tok::numeric_constant, toks[0].getKind());
 562   ASSERT_EQ(tok::numeric_constant, toks[1].getKind());
 563   ASSERT_EQ(tok::numeric_constant, toks[2].getKind());
 564   ASSERT_EQ(tok::numeric_constant, toks[3].getKind());
 565
 566   SourceLocation defLoc = SourceMgr.translateLineCol(mainFileID, 2, 13);
 567   SourceLocation loc1 = SourceMgr.translateLineCol(mainFileID, 3, 8);
 568   SourceLocation loc2 = SourceMgr.translateLineCol(mainFileID, 4, 4);
 569   SourceLocation loc3 = SourceMgr.translateLineCol(mainFileID, 5, 7);
 570   SourceLocation defLoc2 = SourceMgr.translateLineCol(mainFileID, 6, 22);
 571   defLoc = SourceMgr.getMacroArgExpandedLocation(defLoc);
 572   loc1 = SourceMgr.getMacroArgExpandedLocation(loc1);
 573   loc2 = SourceMgr.getMacroArgExpandedLocation(loc2);
 574   loc3 = SourceMgr.getMacroArgExpandedLocation(loc3);
 575   defLoc2 = SourceMgr.getMacroArgExpandedLocation(defLoc2);
 576
 577   EXPECT_TRUE(defLoc.isFileID());
 578   EXPECT_TRUE(loc1.isFileID());
 579   EXPECT_TRUE(SourceMgr.isMacroArgExpansion(loc2));
 580   EXPECT_TRUE(SourceMgr.isMacroArgExpansion(loc3));
 581   EXPECT_EQ(loc2, toks[1].getLocation());
 582   EXPECT_EQ(loc3, toks[2].getLocation());
 583   EXPECT_TRUE(defLoc2.isFileID());
 584 }
 585
 586 namespace {
 587
 588 struct MacroAction {
 589   enum Kind { kExpansion, kDefinition, kUnDefinition};
 590
 591   SourceLocation Loc;
 592   std::string Name;
 593   LLVM_PREFERRED_TYPE(Kind)
 594   unsigned MAKind : 3;
 595
 596   MacroAction(SourceLocation Loc, StringRef Name, unsigned K)
 597       : Loc(Loc), Name(std::string(Name)), MAKind(K) {}
 598
 599   bool isExpansion() const { return MAKind == kExpansion; }
 600   bool isDefinition() const { return MAKind & kDefinition; }
 601   bool isUnDefinition() const { return MAKind & kUnDefinition; }
 602 };
 603
 604 class MacroTracker : public PPCallbacks {
 605   std::vector<MacroAction> &Macros;
 606
 607 public:
 608   explicit MacroTracker(std::vector<MacroAction> &Macros) : Macros(Macros) { }
 609
 610   void MacroDefined(const Token &MacroNameTok,
 611                     const MacroDirective *MD) override {
 612     Macros.push_back(MacroAction(MD->getLocation(),
 613                                  MacroNameTok.getIdentifierInfo()->getName(),
 614                                  MacroAction::kDefinition));
 615   }
 616   void MacroUndefined(const Token &MacroNameTok,
 617                       const MacroDefinition &MD,
 618                       const MacroDirective  *UD) override {
 619     Macros.push_back(
 620         MacroAction(UD ? UD->getLocation() : SourceLocation(),
 621                     MacroNameTok.getIdentifierInfo()->getName(),
 622                     UD ? MacroAction::kDefinition | MacroAction::kUnDefinition
 623                        : MacroAction::kUnDefinition));
 624   }
 625   void MacroExpands(const Token &MacroNameTok, const MacroDefinition &MD,
 626                     SourceRange Range, const MacroArgs *Args) override {
 627     Macros.push_back(MacroAction(MacroNameTok.getLocation(),
 628                                  MacroNameTok.getIdentifierInfo()->getName(),
 629                                  MacroAction::kExpansion));
 630   }
 631 };
 632
 633 }
 634
 635 TEST_F(SourceManagerTest, isBeforeInTranslationUnitWithMacroInInclude) {
 636   const char *header =
 637     "#define MACRO_IN_INCLUDE 0\n"
 638     "#define MACRO_DEFINED\n"
 639     "#undef MACRO_DEFINED\n"
 640     "#undef MACRO_UNDEFINED\n";
 641
 642   const char *main =
 643     "#define M(x) x\n"
 644     "#define INC \"/test-header.h\"\n"
 645     "#include M(INC)\n"
 646     "#define INC2 </test-header.h>\n"
 647     "#include M(INC2)\n";
 648
 649   std::unique_ptr<llvm::MemoryBuffer> HeaderBuf =
 650       llvm::MemoryBuffer::getMemBuffer(header);
 651   std::unique_ptr<llvm::MemoryBuffer> MainBuf =
 652       llvm::MemoryBuffer::getMemBuffer(main);
 653   SourceMgr.setMainFileID(SourceMgr.createFileID(std::move(MainBuf)));
 654
 655   FileEntryRef headerFile = FileMgr.getVirtualFileRef(
 656       "/test-header.h", HeaderBuf->getBufferSize(), 0);
 657   SourceMgr.overrideFileContents(headerFile, std::move(HeaderBuf));
 658
 659   TrivialModuleLoader ModLoader;
 660   HeaderSearch HeaderInfo(std::make_shared<HeaderSearchOptions>(), SourceMgr,
 661                           Diags, LangOpts, &*Target);
 662   Preprocessor PP(std::make_shared<PreprocessorOptions>(), Diags, LangOpts,
 663                   SourceMgr, HeaderInfo, ModLoader,
 664                   /*IILookup =*/nullptr,
 665                   /*OwnsHeaderSearch =*/false);
 666   PP.Initialize(*Target);
 667
 668   std::vector<MacroAction> Macros;
 669   PP.addPPCallbacks(std::make_unique<MacroTracker>(Macros));
 670
 671   PP.EnterMainSourceFile();
 672
 673   std::vector<Token> toks;
 674   PP.LexTokensUntilEOF(&toks);
 675
 676   // Make sure we got the tokens that we expected.
 677   ASSERT_EQ(0U, toks.size());
 678
 679   ASSERT_EQ(15U, Macros.size());
 680   // #define M(x) x
 681   ASSERT_TRUE(Macros[0].isDefinition());
 682   ASSERT_EQ("M", Macros[0].Name);
 683   // #define INC "/test-header.h"
 684   ASSERT_TRUE(Macros[1].isDefinition());
 685   ASSERT_EQ("INC", Macros[1].Name);
 686   // M expansion in #include M(INC)
 687   ASSERT_FALSE(Macros[2].isDefinition());
 688   ASSERT_EQ("M", Macros[2].Name);
 689   // INC expansion in #include M(INC)
 690   ASSERT_TRUE(Macros[3].isExpansion());
 691   ASSERT_EQ("INC", Macros[3].Name);
 692   // #define MACRO_IN_INCLUDE 0
 693   ASSERT_TRUE(Macros[4].isDefinition());
 694   ASSERT_EQ("MACRO_IN_INCLUDE", Macros[4].Name);
 695   // #define MACRO_DEFINED
 696   ASSERT_TRUE(Macros[5].isDefinition());
 697   ASSERT_FALSE(Macros[5].isUnDefinition());
 698   ASSERT_EQ("MACRO_DEFINED", Macros[5].Name);
 699   // #undef MACRO_DEFINED
 700   ASSERT_TRUE(Macros[6].isDefinition());
 701   ASSERT_TRUE(Macros[6].isUnDefinition());
 702   ASSERT_EQ("MACRO_DEFINED", Macros[6].Name);
 703   // #undef MACRO_UNDEFINED
 704   ASSERT_FALSE(Macros[7].isDefinition());
 705   ASSERT_TRUE(Macros[7].isUnDefinition());
 706   ASSERT_EQ("MACRO_UNDEFINED", Macros[7].Name);
 707   // #define INC2 </test-header.h>
 708   ASSERT_TRUE(Macros[8].isDefinition());
 709   ASSERT_EQ("INC2", Macros[8].Name);
 710   // M expansion in #include M(INC2)
 711   ASSERT_FALSE(Macros[9].isDefinition());
 712   ASSERT_EQ("M", Macros[9].Name);
 713   // INC2 expansion in #include M(INC2)
 714   ASSERT_TRUE(Macros[10].isExpansion());
 715   ASSERT_EQ("INC2", Macros[10].Name);
 716   // #define MACRO_IN_INCLUDE 0
 717   ASSERT_TRUE(Macros[11].isDefinition());
 718   ASSERT_EQ("MACRO_IN_INCLUDE", Macros[11].Name);
 719
 720   // The INC expansion in #include M(INC) comes before the first
 721   // MACRO_IN_INCLUDE definition of the included file.
 722   EXPECT_TRUE(SourceMgr.isBeforeInTranslationUnit(Macros[3].Loc, Macros[4].Loc));
 723
 724   // The INC2 expansion in #include M(INC2) comes before the second
 725   // MACRO_IN_INCLUDE definition of the included file.
 726   EXPECT_TRUE(SourceMgr.isBeforeInTranslationUnit(Macros[10].Loc, Macros[11].Loc));
 727 }
 728
 729 TEST_F(SourceManagerTest, isMainFile) {
 730   const char *Source = "int x;";
 731
 732   std::unique_ptr<llvm::MemoryBuffer> Buf =
 733       llvm::MemoryBuffer::getMemBuffer(Source);
 734   FileEntryRef SourceFile =
 735       FileMgr.getVirtualFileRef("mainFile.cpp", Buf->getBufferSize(), 0);
 736   SourceMgr.overrideFileContents(SourceFile, std::move(Buf));
 737
 738   std::unique_ptr<llvm::MemoryBuffer> Buf2 =
 739       llvm::MemoryBuffer::getMemBuffer(Source);
 740   FileEntryRef SecondFile =
 741       FileMgr.getVirtualFileRef("file2.cpp", Buf2->getBufferSize(), 0);
 742   SourceMgr.overrideFileContents(SecondFile, std::move(Buf2));
 743
 744   FileID MainFileID = SourceMgr.getOrCreateFileID(SourceFile, SrcMgr::C_User);
 745   SourceMgr.setMainFileID(MainFileID);
 746
 747   EXPECT_TRUE(SourceMgr.isMainFile(*SourceFile));
 748   EXPECT_TRUE(SourceMgr.isMainFile(*SourceFile));
 749   EXPECT_FALSE(SourceMgr.isMainFile(*SecondFile));
 750 }
 751
 752 #endif
 753
 754 } // anonymous namespace