unittests/Basic/SourceManagerTest.cpp

   1 //===- unittests/Basic/SourceManagerTest.cpp ------ SourceManager tests ---===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "clang/Basic/SourceManager.h"
  11 #include "clang/Basic/Diagnostic.h"
  12 #include "clang/Basic/DiagnosticOptions.h"
  13 #include "clang/Basic/FileManager.h"
  14 #include "clang/Basic/LangOptions.h"
  15 #include "clang/Basic/TargetInfo.h"
  16 #include "clang/Basic/TargetOptions.h"
  17 #include "clang/Lex/HeaderSearch.h"
  18 #include "clang/Lex/HeaderSearchOptions.h"
  19 #include "clang/Lex/ModuleLoader.h"
  20 #include "clang/Lex/Preprocessor.h"
  21 #include "clang/Lex/PreprocessorOptions.h"
  22 #include "llvm/ADT/SmallString.h"
  23 #include "llvm/Config/config.h"
  24 #include "gtest/gtest.h"
  25
  26 using namespace llvm;
  27 using namespace clang;
  28
  29 namespace {
  30
  31 // The test fixture.
  32 class SourceManagerTest : public ::testing::Test {
  33 protected:
  34   SourceManagerTest()
  35     : FileMgr(FileMgrOpts),
  36       DiagID(new DiagnosticIDs()),
  37       Diags(DiagID, new DiagnosticOptions, new IgnoringDiagConsumer()),
  38       SourceMgr(Diags, FileMgr),
  39       TargetOpts(new TargetOptions) {
  40     TargetOpts->Triple = "x86_64-apple-darwin11.1.0";
  41     Target = TargetInfo::CreateTargetInfo(Diags, &*TargetOpts);
  42   }
  43
  44   FileSystemOptions FileMgrOpts;
  45   FileManager FileMgr;
  46   IntrusiveRefCntPtr<DiagnosticIDs> DiagID;
  47   DiagnosticsEngine Diags;
  48   SourceManager SourceMgr;
  49   LangOptions LangOpts;
  50   IntrusiveRefCntPtr<TargetOptions> TargetOpts;
  51   IntrusiveRefCntPtr<TargetInfo> Target;
  52 };
  53
  54 class VoidModuleLoader : public ModuleLoader {
  55   virtual ModuleLoadResult loadModule(SourceLocation ImportLoc,
  56                                       ModuleIdPath Path,
  57                                       Module::NameVisibilityKind Visibility,
  58                                       bool IsInclusionDirective) {
  59     return ModuleLoadResult();
  60   }
  61
  62   virtual void makeModuleVisible(Module *Mod,
  63                                  Module::NameVisibilityKind Visibility,
  64                                  SourceLocation ImportLoc,
  65                                  bool Complain) { }
  66 };
  67
  68 TEST_F(SourceManagerTest, isBeforeInTranslationUnit) {
  69   const char *source =
  70     "#define M(x) [x]\n"
  71     "M(foo)";
  72   MemoryBuffer *buf = MemoryBuffer::getMemBuffer(source);
  73   FileID mainFileID = SourceMgr.createMainFileIDForMemBuffer(buf);
  74
  75   VoidModuleLoader ModLoader;
  76   HeaderSearch HeaderInfo(new HeaderSearchOptions, FileMgr, Diags, LangOpts,
  77                           &*Target);
  78   Preprocessor PP(new PreprocessorOptions(), Diags, LangOpts, Target.getPtr(),
  79                   SourceMgr, HeaderInfo, ModLoader,
  80                   /*IILookup =*/ 0,
  81                   /*OwnsHeaderSearch =*/false,
  82                   /*DelayInitialization =*/ false);
  83   PP.EnterMainSourceFile();
  84
  85   std::vector<Token> toks;
  86   while (1) {
  87     Token tok;
  88     PP.Lex(tok);
  89     if (tok.is(tok::eof))
  90       break;
  91     toks.push_back(tok);
  92   }
  93
  94   // Make sure we got the tokens that we expected.
  95   ASSERT_EQ(3U, toks.size());
  96   ASSERT_EQ(tok::l_square, toks[0].getKind());
  97   ASSERT_EQ(tok::identifier, toks[1].getKind());
  98   ASSERT_EQ(tok::r_square, toks[2].getKind());
  99
 100   SourceLocation lsqrLoc = toks[0].getLocation();
 101   SourceLocation idLoc = toks[1].getLocation();
 102   SourceLocation rsqrLoc = toks[2].getLocation();
 103
 104   SourceLocation macroExpStartLoc = SourceMgr.translateLineCol(mainFileID, 2, 1);
 105   SourceLocation macroExpEndLoc = SourceMgr.translateLineCol(mainFileID, 2, 6);
 106   ASSERT_TRUE(macroExpStartLoc.isFileID());
 107   ASSERT_TRUE(macroExpEndLoc.isFileID());
 108
 109   SmallString<32> str;
 110   ASSERT_EQ("M", PP.getSpelling(macroExpStartLoc, str));
 111   ASSERT_EQ(")", PP.getSpelling(macroExpEndLoc, str));
 112
 113   EXPECT_TRUE(SourceMgr.isBeforeInTranslationUnit(lsqrLoc, idLoc));
 114   EXPECT_TRUE(SourceMgr.isBeforeInTranslationUnit(idLoc, rsqrLoc));
 115   EXPECT_TRUE(SourceMgr.isBeforeInTranslationUnit(macroExpStartLoc, idLoc));
 116   EXPECT_TRUE(SourceMgr.isBeforeInTranslationUnit(idLoc, macroExpEndLoc));
 117 }
 118
 119 TEST_F(SourceManagerTest, getColumnNumber) {
 120   const char *Source =
 121     "int x;\n"
 122     "int y;";
 123
 124   MemoryBuffer *Buf = MemoryBuffer::getMemBuffer(Source);
 125   FileID MainFileID = SourceMgr.createMainFileIDForMemBuffer(Buf);
 126
 127   bool Invalid;
 128
 129   Invalid = false;
 130   EXPECT_EQ(1U, SourceMgr.getColumnNumber(MainFileID, 0, &Invalid));
 131   EXPECT_TRUE(!Invalid);
 132
 133   Invalid = false;
 134   EXPECT_EQ(5U, SourceMgr.getColumnNumber(MainFileID, 4, &Invalid));
 135   EXPECT_TRUE(!Invalid);
 136
 137   Invalid = false;
 138   EXPECT_EQ(1U, SourceMgr.getColumnNumber(MainFileID, 7, &Invalid));
 139   EXPECT_TRUE(!Invalid);
 140
 141   Invalid = false;
 142   EXPECT_EQ(5U, SourceMgr.getColumnNumber(MainFileID, 11, &Invalid));
 143   EXPECT_TRUE(!Invalid);
 144
 145   Invalid = false;
 146   EXPECT_EQ(7U, SourceMgr.getColumnNumber(MainFileID, strlen(Source),
 147                                          &Invalid));
 148   EXPECT_TRUE(!Invalid);
 149
 150   Invalid = false;
 151   SourceMgr.getColumnNumber(MainFileID, strlen(Source)+1, &Invalid);
 152   EXPECT_TRUE(Invalid);
 153
 154   // Test invalid files
 155   Invalid = false;
 156   SourceMgr.getColumnNumber(FileID(), 0, &Invalid);
 157   EXPECT_TRUE(Invalid);
 158
 159   Invalid = false;
 160   SourceMgr.getColumnNumber(FileID(), 1, &Invalid);
 161   EXPECT_TRUE(Invalid);
 162
 163   // Test with no invalid flag.
 164   EXPECT_EQ(1U, SourceMgr.getColumnNumber(MainFileID, 0, NULL));
 165 }
 166
 167 #if defined(LLVM_ON_UNIX)
 168
 169 TEST_F(SourceManagerTest, getMacroArgExpandedLocation) {
 170   const char *header =
 171     "#define FM(x,y) x\n";
 172
 173   const char *main =
 174     "#include \"/test-header.h\"\n"
 175     "#define VAL 0\n"
 176     "FM(VAL,0)\n"
 177     "FM(0,VAL)\n"
 178     "FM(FM(0,VAL),0)\n"
 179     "#define CONCAT(X, Y) X##Y\n"
 180     "CONCAT(1,1)\n";
 181
 182   MemoryBuffer *headerBuf = MemoryBuffer::getMemBuffer(header);
 183   MemoryBuffer *mainBuf = MemoryBuffer::getMemBuffer(main);
 184   FileID mainFileID = SourceMgr.createMainFileIDForMemBuffer(mainBuf);
 185
 186   const FileEntry *headerFile = FileMgr.getVirtualFile("/test-header.h",
 187                                                  headerBuf->getBufferSize(), 0);
 188   SourceMgr.overrideFileContents(headerFile, headerBuf);
 189
 190   VoidModuleLoader ModLoader;
 191   HeaderSearch HeaderInfo(new HeaderSearchOptions, FileMgr, Diags, LangOpts,
 192                           &*Target);
 193   Preprocessor PP(new PreprocessorOptions(), Diags, LangOpts, Target.getPtr(),
 194                   SourceMgr, HeaderInfo, ModLoader,
 195                   /*IILookup =*/ 0,
 196                   /*OwnsHeaderSearch =*/false,
 197                   /*DelayInitialization =*/ false);
 198   PP.EnterMainSourceFile();
 199
 200   std::vector<Token> toks;
 201   while (1) {
 202     Token tok;
 203     PP.Lex(tok);
 204     if (tok.is(tok::eof))
 205       break;
 206     toks.push_back(tok);
 207   }
 208
 209   // Make sure we got the tokens that we expected.
 210   ASSERT_EQ(4U, toks.size());
 211   ASSERT_EQ(tok::numeric_constant, toks[0].getKind());
 212   ASSERT_EQ(tok::numeric_constant, toks[1].getKind());
 213   ASSERT_EQ(tok::numeric_constant, toks[2].getKind());
 214   ASSERT_EQ(tok::numeric_constant, toks[3].getKind());
 215
 216   SourceLocation defLoc = SourceMgr.translateLineCol(mainFileID, 2, 13);
 217   SourceLocation loc1 = SourceMgr.translateLineCol(mainFileID, 3, 8);
 218   SourceLocation loc2 = SourceMgr.translateLineCol(mainFileID, 4, 4);
 219   SourceLocation loc3 = SourceMgr.translateLineCol(mainFileID, 5, 7);
 220   SourceLocation defLoc2 = SourceMgr.translateLineCol(mainFileID, 6, 22);
 221   defLoc = SourceMgr.getMacroArgExpandedLocation(defLoc);
 222   loc1 = SourceMgr.getMacroArgExpandedLocation(loc1);
 223   loc2 = SourceMgr.getMacroArgExpandedLocation(loc2);
 224   loc3 = SourceMgr.getMacroArgExpandedLocation(loc3);
 225   defLoc2 = SourceMgr.getMacroArgExpandedLocation(defLoc2);
 226
 227   EXPECT_TRUE(defLoc.isFileID());
 228   EXPECT_TRUE(loc1.isFileID());
 229   EXPECT_TRUE(SourceMgr.isMacroArgExpansion(loc2));
 230   EXPECT_TRUE(SourceMgr.isMacroArgExpansion(loc3));
 231   EXPECT_EQ(loc2, toks[1].getLocation());
 232   EXPECT_EQ(loc3, toks[2].getLocation());
 233   EXPECT_TRUE(defLoc2.isFileID());
 234 }
 235
 236 namespace {
 237
 238 struct MacroAction {
 239   SourceLocation Loc;
 240   std::string Name;
 241   bool isDefinition; // if false, it is expansion.
 242
 243   MacroAction(SourceLocation Loc, StringRef Name, bool isDefinition)
 244     : Loc(Loc), Name(Name), isDefinition(isDefinition) { }
 245 };
 246
 247 class MacroTracker : public PPCallbacks {
 248   std::vector<MacroAction> &Macros;
 249
 250 public:
 251   explicit MacroTracker(std::vector<MacroAction> &Macros) : Macros(Macros) { }
 252
 253   virtual void MacroDefined(const Token &MacroNameTok,
 254                             const MacroDirective *MD) {
 255     Macros.push_back(MacroAction(MD->getLocation(),
 256                                  MacroNameTok.getIdentifierInfo()->getName(),
 257                                  true));
 258   }
 259   virtual void MacroExpands(const Token &MacroNameTok, const MacroDirective *MD,
 260                             SourceRange Range, const MacroArgs *Args) {
 261     Macros.push_back(MacroAction(MacroNameTok.getLocation(),
 262                                  MacroNameTok.getIdentifierInfo()->getName(),
 263                                  false));
 264   }
 265 };
 266
 267 }
 268
 269 TEST_F(SourceManagerTest, isBeforeInTranslationUnitWithMacroInInclude) {
 270   const char *header =
 271     "#define MACRO_IN_INCLUDE 0\n";
 272
 273   const char *main =
 274     "#define M(x) x\n"
 275     "#define INC \"/test-header.h\"\n"
 276     "#include M(INC)\n"
 277     "#define INC2 </test-header.h>\n"
 278     "#include M(INC2)\n";
 279
 280   MemoryBuffer *headerBuf = MemoryBuffer::getMemBuffer(header);
 281   MemoryBuffer *mainBuf = MemoryBuffer::getMemBuffer(main);
 282   SourceMgr.createMainFileIDForMemBuffer(mainBuf);
 283
 284   const FileEntry *headerFile = FileMgr.getVirtualFile("/test-header.h",
 285                                                  headerBuf->getBufferSize(), 0);
 286   SourceMgr.overrideFileContents(headerFile, headerBuf);
 287
 288   VoidModuleLoader ModLoader;
 289   HeaderSearch HeaderInfo(new HeaderSearchOptions, FileMgr, Diags, LangOpts,
 290                           &*Target);
 291   Preprocessor PP(new PreprocessorOptions(), Diags, LangOpts, Target.getPtr(),
 292                   SourceMgr, HeaderInfo, ModLoader,
 293                   /*IILookup =*/ 0,
 294                   /*OwnsHeaderSearch =*/false,
 295                   /*DelayInitialization =*/ false);
 296
 297   std::vector<MacroAction> Macros;
 298   PP.addPPCallbacks(new MacroTracker(Macros));
 299
 300   PP.EnterMainSourceFile();
 301
 302   std::vector<Token> toks;
 303   while (1) {
 304     Token tok;
 305     PP.Lex(tok);
 306     if (tok.is(tok::eof))
 307       break;
 308     toks.push_back(tok);
 309   }
 310
 311   // Make sure we got the tokens that we expected.
 312   ASSERT_EQ(0U, toks.size());
 313
 314   ASSERT_EQ(9U, Macros.size());
 315   // #define M(x) x
 316   ASSERT_TRUE(Macros[0].isDefinition);
 317   ASSERT_EQ("M", Macros[0].Name);
 318   // #define INC "/test-header.h"
 319   ASSERT_TRUE(Macros[1].isDefinition);
 320   ASSERT_EQ("INC", Macros[1].Name);
 321   // M expansion in #include M(INC)
 322   ASSERT_FALSE(Macros[2].isDefinition);
 323   ASSERT_EQ("M", Macros[2].Name);
 324   // INC expansion in #include M(INC)
 325   ASSERT_FALSE(Macros[3].isDefinition);
 326   ASSERT_EQ("INC", Macros[3].Name);
 327   // #define MACRO_IN_INCLUDE 0
 328   ASSERT_TRUE(Macros[4].isDefinition);
 329   ASSERT_EQ("MACRO_IN_INCLUDE", Macros[4].Name);
 330   // #define INC2 </test-header.h>
 331   ASSERT_TRUE(Macros[5].isDefinition);
 332   ASSERT_EQ("INC2", Macros[5].Name);
 333   // M expansion in #include M(INC2)
 334   ASSERT_FALSE(Macros[6].isDefinition);
 335   ASSERT_EQ("M", Macros[6].Name);
 336   // INC2 expansion in #include M(INC2)
 337   ASSERT_FALSE(Macros[7].isDefinition);
 338   ASSERT_EQ("INC2", Macros[7].Name);
 339   // #define MACRO_IN_INCLUDE 0
 340   ASSERT_TRUE(Macros[8].isDefinition);
 341   ASSERT_EQ("MACRO_IN_INCLUDE", Macros[8].Name);
 342
 343   // The INC expansion in #include M(INC) comes before the first
 344   // MACRO_IN_INCLUDE definition of the included file.
 345   EXPECT_TRUE(SourceMgr.isBeforeInTranslationUnit(Macros[3].Loc, Macros[4].Loc));
 346
 347   // The INC2 expansion in #include M(INC2) comes before the second
 348   // MACRO_IN_INCLUDE definition of the included file.
 349   EXPECT_TRUE(SourceMgr.isBeforeInTranslationUnit(Macros[7].Loc, Macros[8].Loc));
 350 }
 351
 352 #endif
 353
 354 } // anonymous namespace