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