• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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:
SourceManagerTest()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 {
loadModule(SourceLocation ImportLoc,ModuleIdPath Path,Module::NameVisibilityKind Visibility,bool IsInclusionDirective)55   ModuleLoadResult loadModule(SourceLocation ImportLoc,
56                               ModuleIdPath Path,
57                               Module::NameVisibilityKind Visibility,
58                               bool IsInclusionDirective) override {
59     return ModuleLoadResult();
60   }
61 
makeModuleVisible(Module * Mod,Module::NameVisibilityKind Visibility,SourceLocation ImportLoc)62   void makeModuleVisible(Module *Mod,
63                          Module::NameVisibilityKind Visibility,
64                          SourceLocation ImportLoc) override { }
65 
loadGlobalModuleIndex(SourceLocation TriggerLoc)66   GlobalModuleIndex *loadGlobalModuleIndex(SourceLocation TriggerLoc) override
67     { return nullptr; }
lookupMissingImports(StringRef Name,SourceLocation TriggerLoc)68   bool lookupMissingImports(StringRef Name, SourceLocation TriggerLoc) override
69     { return 0; }
70 };
71 
TEST_F(SourceManagerTest,isBeforeInTranslationUnit)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 
TEST_F(SourceManagerTest,getColumnNumber)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 
TEST_F(SourceManagerTest,getMacroArgExpandedLocation)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 
MacroAction__anone0033f160111::__anone0033f160211::MacroAction250   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:
MacroTracker(std::vector<MacroAction> & Macros)258   explicit MacroTracker(std::vector<MacroAction> &Macros) : Macros(Macros) { }
259 
MacroDefined(const Token & MacroNameTok,const MacroDirective * MD)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   }
MacroExpands(const Token & MacroNameTok,const MacroDefinition & MD,SourceRange Range,const MacroArgs * Args)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 
TEST_F(SourceManagerTest,isBeforeInTranslationUnitWithMacroInInclude)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