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
26using namespace llvm;
27using namespace clang;
28
29namespace {
30
31// The test fixture.
32class SourceManagerTest : public ::testing::Test {
33protected:
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
54class 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
72TEST_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
124TEST_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
175TEST_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
243namespace {
244
245struct 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
254class MacroTracker : public PPCallbacks {
255  std::vector<MacroAction> &Macros;
256
257public:
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
276TEST_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