520 lines
18 KiB
C++
520 lines
18 KiB
C++
|
//===- unittests/Basic/SourceManagerTest.cpp ------ SourceManager tests ---===//
|
||
|
|
//
|
||
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
||
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
||
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
||
|
|
//
|
||
|
|
//===----------------------------------------------------------------------===//
|
||
|
|
|
||
|
|
#include "clang/Basic/SourceManager.h"
|
||
|
|
#include "clang/Basic/Diagnostic.h"
|
||
|
|
#include "clang/Basic/DiagnosticOptions.h"
|
||
|
|
#include "clang/Basic/FileManager.h"
|
||
|
|
#include "clang/Basic/LangOptions.h"
|
||
|
|
#include "clang/Basic/TargetInfo.h"
|
||
|
|
#include "clang/Basic/TargetOptions.h"
|
||
|
|
#include "clang/Lex/HeaderSearch.h"
|
||
|
|
#include "clang/Lex/HeaderSearchOptions.h"
|
||
|
|
#include "clang/Lex/ModuleLoader.h"
|
||
|
|
#include "clang/Lex/Preprocessor.h"
|
||
|
|
#include "clang/Lex/PreprocessorOptions.h"
|
||
|
|
#include "llvm/ADT/SmallString.h"
|
||
|
|
#include "llvm/Config/llvm-config.h"
|
||
|
|
#include "llvm/Support/Process.h"
|
||
|
|
#include "gtest/gtest.h"
|
||
|
|
#include <cstddef>
|
||
|
|
|
||
|
|
using namespace clang;
|
||
|
|
|
||
|
|
namespace {
|
||
|
|
|
||
|
|
// The test fixture.
|
||
|
|
class SourceManagerTest : public ::testing::Test {
|
||
|
|
protected:
|
||
|
|
SourceManagerTest()
|
||
|
|
: FileMgr(FileMgrOpts),
|
||
|
|
DiagID(new DiagnosticIDs()),
|
||
|
|
Diags(DiagID, new DiagnosticOptions, new IgnoringDiagConsumer()),
|
||
|
|
SourceMgr(Diags, FileMgr),
|
||
|
|
TargetOpts(new TargetOptions) {
|
||
|
|
TargetOpts->Triple = "x86_64-apple-darwin11.1.0";
|
||
|
|
Target = TargetInfo::CreateTargetInfo(Diags, TargetOpts);
|
||
|
|
}
|
||
|
|
|
||
|
|
FileSystemOptions FileMgrOpts;
|
||
|
|
FileManager FileMgr;
|
||
|
|
IntrusiveRefCntPtr<DiagnosticIDs> DiagID;
|
||
|
|
DiagnosticsEngine Diags;
|
||
|
|
SourceManager SourceMgr;
|
||
|
|
LangOptions LangOpts;
|
||
|
|
std::shared_ptr<TargetOptions> TargetOpts;
|
||
|
|
IntrusiveRefCntPtr<TargetInfo> Target;
|
||
|
|
};
|
||
|
|
|
||
|
|
TEST_F(SourceManagerTest, isBeforeInTranslationUnit) {
|
||
|
|
const char *source =
|
||
|
|
"#define M(x) [x]\n"
|
||
|
|
"M(foo)";
|
||
|
|
std::unique_ptr<llvm::MemoryBuffer> Buf =
|
||
|
|
llvm::MemoryBuffer::getMemBuffer(source);
|
||
|
|
FileID mainFileID = SourceMgr.createFileID(std::move(Buf));
|
||
|
|
SourceMgr.setMainFileID(mainFileID);
|
||
|
|
|
||
|
|
TrivialModuleLoader ModLoader;
|
||
|
|
HeaderSearch HeaderInfo(std::make_shared<HeaderSearchOptions>(), SourceMgr,
|
||
|
|
Diags, LangOpts, &*Target);
|
||
|
|
Preprocessor PP(std::make_shared<PreprocessorOptions>(), Diags, LangOpts,
|
||
|
|
SourceMgr, HeaderInfo, ModLoader,
|
||
|
|
/*IILookup =*/nullptr,
|
||
|
|
/*OwnsHeaderSearch =*/false);
|
||
|
|
PP.Initialize(*Target);
|
||
|
|
PP.EnterMainSourceFile();
|
||
|
|
|
||
|
|
std::vector<Token> toks;
|
||
|
|
while (1) {
|
||
|
|
Token tok;
|
||
|
|
PP.Lex(tok);
|
||
|
|
if (tok.is(tok::eof))
|
||
|
|
break;
|
||
|
|
toks.push_back(tok);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Make sure we got the tokens that we expected.
|
||
|
|
ASSERT_EQ(3U, toks.size());
|
||
|
|
ASSERT_EQ(tok::l_square, toks[0].getKind());
|
||
|
|
ASSERT_EQ(tok::identifier, toks[1].getKind());
|
||
|
|
ASSERT_EQ(tok::r_square, toks[2].getKind());
|
||
|
|
|
||
|
|
SourceLocation lsqrLoc = toks[0].getLocation();
|
||
|
|
SourceLocation idLoc = toks[1].getLocation();
|
||
|
|
SourceLocation rsqrLoc = toks[2].getLocation();
|
||
|
|
|
||
|
|
SourceLocation macroExpStartLoc = SourceMgr.translateLineCol(mainFileID, 2, 1);
|
||
|
|
SourceLocation macroExpEndLoc = SourceMgr.translateLineCol(mainFileID, 2, 6);
|
||
|
|
ASSERT_TRUE(macroExpStartLoc.isFileID());
|
||
|
|
ASSERT_TRUE(macroExpEndLoc.isFileID());
|
||
|
|
|
||
|
|
SmallString<32> str;
|
||
|
|
ASSERT_EQ("M", PP.getSpelling(macroExpStartLoc, str));
|
||
|
|
ASSERT_EQ(")", PP.getSpelling(macroExpEndLoc, str));
|
||
|
|
|
||
|
|
EXPECT_TRUE(SourceMgr.isBeforeInTranslationUnit(lsqrLoc, idLoc));
|
||
|
|
EXPECT_TRUE(SourceMgr.isBeforeInTranslationUnit(idLoc, rsqrLoc));
|
||
|
|
EXPECT_TRUE(SourceMgr.isBeforeInTranslationUnit(macroExpStartLoc, idLoc));
|
||
|
|
EXPECT_TRUE(SourceMgr.isBeforeInTranslationUnit(idLoc, macroExpEndLoc));
|
||
|
|
}
|
||
|
|
|
||
|
|
TEST_F(SourceManagerTest, getColumnNumber) {
|
||
|
|
const char *Source =
|
||
|
|
"int x;\n"
|
||
|
|
"int y;";
|
||
|
|
|
||
|
|
std::unique_ptr<llvm::MemoryBuffer> Buf =
|
||
|
|
llvm::MemoryBuffer::getMemBuffer(Source);
|
||
|
|
FileID MainFileID = SourceMgr.createFileID(std::move(Buf));
|
||
|
|
SourceMgr.setMainFileID(MainFileID);
|
||
|
|
|
||
|
|
bool Invalid;
|
||
|
|
|
||
|
|
Invalid = false;
|
||
|
|
EXPECT_EQ(1U, SourceMgr.getColumnNumber(MainFileID, 0, &Invalid));
|
||
|
|
EXPECT_TRUE(!Invalid);
|
||
|
|
|
||
|
|
Invalid = false;
|
||
|
|
EXPECT_EQ(5U, SourceMgr.getColumnNumber(MainFileID, 4, &Invalid));
|
||
|
|
EXPECT_TRUE(!Invalid);
|
||
|
|
|
||
|
|
Invalid = false;
|
||
|
|
EXPECT_EQ(1U, SourceMgr.getColumnNumber(MainFileID, 7, &Invalid));
|
||
|
|
EXPECT_TRUE(!Invalid);
|
||
|
|
|
||
|
|
Invalid = false;
|
||
|
|
EXPECT_EQ(5U, SourceMgr.getColumnNumber(MainFileID, 11, &Invalid));
|
||
|
|
EXPECT_TRUE(!Invalid);
|
||
|
|
|
||
|
|
Invalid = false;
|
||
|
|
EXPECT_EQ(7U, SourceMgr.getColumnNumber(MainFileID, strlen(Source),
|
||
|
|
&Invalid));
|
||
|
|
EXPECT_TRUE(!Invalid);
|
||
|
|
|
||
|
|
Invalid = false;
|
||
|
|
SourceMgr.getColumnNumber(MainFileID, strlen(Source)+1, &Invalid);
|
||
|
|
EXPECT_TRUE(Invalid);
|
||
|
|
|
||
|
|
// Test invalid files
|
||
|
|
Invalid = false;
|
||
|
|
SourceMgr.getColumnNumber(FileID(), 0, &Invalid);
|
||
|
|
EXPECT_TRUE(Invalid);
|
||
|
|
|
||
|
|
Invalid = false;
|
||
|
|
SourceMgr.getColumnNumber(FileID(), 1, &Invalid);
|
||
|
|
EXPECT_TRUE(Invalid);
|
||
|
|
|
||
|
|
// Test with no invalid flag.
|
||
|
|
EXPECT_EQ(1U, SourceMgr.getColumnNumber(MainFileID, 0, nullptr));
|
||
|
|
}
|
||
|
|
|
||
|
|
TEST_F(SourceManagerTest, locationPrintTest) {
|
||
|
|
const char *header = "#define IDENTITY(x) x\n";
|
||
|
|
|
||
|
|
const char *Source = "int x;\n"
|
||
|
|
"include \"test-header.h\"\n"
|
||
|
|
"IDENTITY(int y);\n"
|
||
|
|
"int z;";
|
||
|
|
|
||
|
|
std::unique_ptr<llvm::MemoryBuffer> HeaderBuf =
|
||
|
|
llvm::MemoryBuffer::getMemBuffer(header);
|
||
|
|
std::unique_ptr<llvm::MemoryBuffer> Buf =
|
||
|
|
llvm::MemoryBuffer::getMemBuffer(Source);
|
||
|
|
|
||
|
|
const FileEntry *SourceFile =
|
||
|
|
FileMgr.getVirtualFile("/mainFile.cpp", Buf->getBufferSize(), 0);
|
||
|
|
SourceMgr.overrideFileContents(SourceFile, std::move(Buf));
|
||
|
|
|
||
|
|
const FileEntry *HeaderFile =
|
||
|
|
FileMgr.getVirtualFile("/test-header.h", HeaderBuf->getBufferSize(), 0);
|
||
|
|
SourceMgr.overrideFileContents(HeaderFile, std::move(HeaderBuf));
|
||
|
|
|
||
|
|
FileID MainFileID = SourceMgr.getOrCreateFileID(SourceFile, SrcMgr::C_User);
|
||
|
|
FileID HeaderFileID = SourceMgr.getOrCreateFileID(HeaderFile, SrcMgr::C_User);
|
||
|
|
SourceMgr.setMainFileID(MainFileID);
|
||
|
|
|
||
|
|
auto BeginLoc = SourceMgr.getLocForStartOfFile(MainFileID);
|
||
|
|
auto EndLoc = SourceMgr.getLocForEndOfFile(MainFileID);
|
||
|
|
|
||
|
|
auto BeginEOLLoc = SourceMgr.translateLineCol(MainFileID, 1, 7);
|
||
|
|
|
||
|
|
auto HeaderLoc = SourceMgr.getLocForStartOfFile(HeaderFileID);
|
||
|
|
|
||
|
|
EXPECT_EQ(BeginLoc.printToString(SourceMgr), "/mainFile.cpp:1:1");
|
||
|
|
EXPECT_EQ(EndLoc.printToString(SourceMgr), "/mainFile.cpp:4:7");
|
||
|
|
|
||
|
|
EXPECT_EQ(BeginEOLLoc.printToString(SourceMgr), "/mainFile.cpp:1:7");
|
||
|
|
EXPECT_EQ(HeaderLoc.printToString(SourceMgr), "/test-header.h:1:1");
|
||
|
|
|
||
|
|
EXPECT_EQ(SourceRange(BeginLoc, BeginLoc).printToString(SourceMgr),
|
||
|
|
"</mainFile.cpp:1:1>");
|
||
|
|
EXPECT_EQ(SourceRange(BeginLoc, BeginEOLLoc).printToString(SourceMgr),
|
||
|
|
"</mainFile.cpp:1:1, col:7>");
|
||
|
|
EXPECT_EQ(SourceRange(BeginLoc, EndLoc).printToString(SourceMgr),
|
||
|
|
"</mainFile.cpp:1:1, line:4:7>");
|
||
|
|
EXPECT_EQ(SourceRange(BeginLoc, HeaderLoc).printToString(SourceMgr),
|
||
|
|
"</mainFile.cpp:1:1, /test-header.h:1:1>");
|
||
|
|
}
|
||
|
|
|
||
|
|
TEST_F(SourceManagerTest, getInvalidBOM) {
|
||
|
|
ASSERT_EQ(SrcMgr::ContentCache::getInvalidBOM(""), nullptr);
|
||
|
|
ASSERT_EQ(SrcMgr::ContentCache::getInvalidBOM("\x00\x00\x00"), nullptr);
|
||
|
|
ASSERT_EQ(SrcMgr::ContentCache::getInvalidBOM("\xFF\xFF\xFF"), nullptr);
|
||
|
|
ASSERT_EQ(SrcMgr::ContentCache::getInvalidBOM("#include <iostream>"),
|
||
|
|
nullptr);
|
||
|
|
|
||
|
|
ASSERT_EQ(StringRef(SrcMgr::ContentCache::getInvalidBOM(
|
||
|
|
"\xFE\xFF#include <iostream>")),
|
||
|
|
"UTF-16 (BE)");
|
||
|
|
ASSERT_EQ(StringRef(SrcMgr::ContentCache::getInvalidBOM(
|
||
|
|
"\xFF\xFE#include <iostream>")),
|
||
|
|
"UTF-16 (LE)");
|
||
|
|
ASSERT_EQ(StringRef(SrcMgr::ContentCache::getInvalidBOM(
|
||
|
|
"\x2B\x2F\x76#include <iostream>")),
|
||
|
|
"UTF-7");
|
||
|
|
ASSERT_EQ(StringRef(SrcMgr::ContentCache::getInvalidBOM(
|
||
|
|
"\xF7\x64\x4C#include <iostream>")),
|
||
|
|
"UTF-1");
|
||
|
|
ASSERT_EQ(StringRef(SrcMgr::ContentCache::getInvalidBOM(
|
||
|
|
"\xDD\x73\x66\x73#include <iostream>")),
|
||
|
|
"UTF-EBCDIC");
|
||
|
|
ASSERT_EQ(StringRef(SrcMgr::ContentCache::getInvalidBOM(
|
||
|
|
"\x0E\xFE\xFF#include <iostream>")),
|
||
|
|
"SCSU");
|
||
|
|
ASSERT_EQ(StringRef(SrcMgr::ContentCache::getInvalidBOM(
|
||
|
|
"\xFB\xEE\x28#include <iostream>")),
|
||
|
|
"BOCU-1");
|
||
|
|
ASSERT_EQ(StringRef(SrcMgr::ContentCache::getInvalidBOM(
|
||
|
|
"\x84\x31\x95\x33#include <iostream>")),
|
||
|
|
"GB-18030");
|
||
|
|
ASSERT_EQ(StringRef(SrcMgr::ContentCache::getInvalidBOM(
|
||
|
|
llvm::StringLiteral::withInnerNUL(
|
||
|
|
"\x00\x00\xFE\xFF#include <iostream>"))),
|
||
|
|
"UTF-32 (BE)");
|
||
|
|
ASSERT_EQ(StringRef(SrcMgr::ContentCache::getInvalidBOM(
|
||
|
|
llvm::StringLiteral::withInnerNUL(
|
||
|
|
"\xFF\xFE\x00\x00#include <iostream>"))),
|
||
|
|
"UTF-32 (LE)");
|
||
|
|
}
|
||
|
|
|
||
|
|
// Regression test - there was an out of bound access for buffers not terminated by zero.
|
||
|
|
TEST_F(SourceManagerTest, getLineNumber) {
|
||
|
|
const unsigned pageSize = llvm::sys::Process::getPageSizeEstimate();
|
||
|
|
std::unique_ptr<char[]> source(new char[pageSize]);
|
||
|
|
for(unsigned i = 0; i < pageSize; ++i) {
|
||
|
|
source[i] = 'a';
|
||
|
|
}
|
||
|
|
|
||
|
|
std::unique_ptr<llvm::MemoryBuffer> Buf =
|
||
|
|
llvm::MemoryBuffer::getMemBuffer(
|
||
|
|
llvm::MemoryBufferRef(
|
||
|
|
llvm::StringRef(source.get(), 3), "whatever"
|
||
|
|
),
|
||
|
|
false
|
||
|
|
);
|
||
|
|
|
||
|
|
FileID mainFileID = SourceMgr.createFileID(std::move(Buf));
|
||
|
|
SourceMgr.setMainFileID(mainFileID);
|
||
|
|
|
||
|
|
ASSERT_NO_FATAL_FAILURE(SourceMgr.getLineNumber(mainFileID, 1, nullptr));
|
||
|
|
}
|
||
|
|
|
||
|
|
#if defined(LLVM_ON_UNIX)
|
||
|
|
|
||
|
|
TEST_F(SourceManagerTest, getMacroArgExpandedLocation) {
|
||
|
|
const char *header =
|
||
|
|
"#define FM(x,y) x\n";
|
||
|
|
|
||
|
|
const char *main =
|
||
|
|
"#include \"/test-header.h\"\n"
|
||
|
|
"#define VAL 0\n"
|
||
|
|
"FM(VAL,0)\n"
|
||
|
|
"FM(0,VAL)\n"
|
||
|
|
"FM(FM(0,VAL),0)\n"
|
||
|
|
"#define CONCAT(X, Y) X##Y\n"
|
||
|
|
"CONCAT(1,1)\n";
|
||
|
|
|
||
|
|
std::unique_ptr<llvm::MemoryBuffer> HeaderBuf =
|
||
|
|
llvm::MemoryBuffer::getMemBuffer(header);
|
||
|
|
std::unique_ptr<llvm::MemoryBuffer> MainBuf =
|
||
|
|
llvm::MemoryBuffer::getMemBuffer(main);
|
||
|
|
FileID mainFileID = SourceMgr.createFileID(std::move(MainBuf));
|
||
|
|
SourceMgr.setMainFileID(mainFileID);
|
||
|
|
|
||
|
|
const FileEntry *headerFile = FileMgr.getVirtualFile("/test-header.h",
|
||
|
|
HeaderBuf->getBufferSize(), 0);
|
||
|
|
SourceMgr.overrideFileContents(headerFile, std::move(HeaderBuf));
|
||
|
|
|
||
|
|
TrivialModuleLoader ModLoader;
|
||
|
|
HeaderSearch HeaderInfo(std::make_shared<HeaderSearchOptions>(), SourceMgr,
|
||
|
|
Diags, LangOpts, &*Target);
|
||
|
|
|
||
|
|
Preprocessor PP(std::make_shared<PreprocessorOptions>(), Diags, LangOpts,
|
||
|
|
SourceMgr, HeaderInfo, ModLoader,
|
||
|
|
/*IILookup =*/nullptr,
|
||
|
|
/*OwnsHeaderSearch =*/false);
|
||
|
|
// Ensure we can get expanded locations in presence of implicit includes.
|
||
|
|
// These are different than normal includes since predefines buffer doesn't
|
||
|
|
// have a valid insertion location.
|
||
|
|
PP.setPredefines("#include \"/implicit-header.h\"");
|
||
|
|
FileMgr.getVirtualFile("/implicit-header.h", 0, 0);
|
||
|
|
PP.Initialize(*Target);
|
||
|
|
PP.EnterMainSourceFile();
|
||
|
|
|
||
|
|
std::vector<Token> toks;
|
||
|
|
while (1) {
|
||
|
|
Token tok;
|
||
|
|
PP.Lex(tok);
|
||
|
|
if (tok.is(tok::eof))
|
||
|
|
break;
|
||
|
|
toks.push_back(tok);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Make sure we got the tokens that we expected.
|
||
|
|
ASSERT_EQ(4U, toks.size());
|
||
|
|
ASSERT_EQ(tok::numeric_constant, toks[0].getKind());
|
||
|
|
ASSERT_EQ(tok::numeric_constant, toks[1].getKind());
|
||
|
|
ASSERT_EQ(tok::numeric_constant, toks[2].getKind());
|
||
|
|
ASSERT_EQ(tok::numeric_constant, toks[3].getKind());
|
||
|
|
|
||
|
|
SourceLocation defLoc = SourceMgr.translateLineCol(mainFileID, 2, 13);
|
||
|
|
SourceLocation loc1 = SourceMgr.translateLineCol(mainFileID, 3, 8);
|
||
|
|
SourceLocation loc2 = SourceMgr.translateLineCol(mainFileID, 4, 4);
|
||
|
|
SourceLocation loc3 = SourceMgr.translateLineCol(mainFileID, 5, 7);
|
||
|
|
SourceLocation defLoc2 = SourceMgr.translateLineCol(mainFileID, 6, 22);
|
||
|
|
defLoc = SourceMgr.getMacroArgExpandedLocation(defLoc);
|
||
|
|
loc1 = SourceMgr.getMacroArgExpandedLocation(loc1);
|
||
|
|
loc2 = SourceMgr.getMacroArgExpandedLocation(loc2);
|
||
|
|
loc3 = SourceMgr.getMacroArgExpandedLocation(loc3);
|
||
|
|
defLoc2 = SourceMgr.getMacroArgExpandedLocation(defLoc2);
|
||
|
|
|
||
|
|
EXPECT_TRUE(defLoc.isFileID());
|
||
|
|
EXPECT_TRUE(loc1.isFileID());
|
||
|
|
EXPECT_TRUE(SourceMgr.isMacroArgExpansion(loc2));
|
||
|
|
EXPECT_TRUE(SourceMgr.isMacroArgExpansion(loc3));
|
||
|
|
EXPECT_EQ(loc2, toks[1].getLocation());
|
||
|
|
EXPECT_EQ(loc3, toks[2].getLocation());
|
||
|
|
EXPECT_TRUE(defLoc2.isFileID());
|
||
|
|
}
|
||
|
|
|
||
|
|
namespace {
|
||
|
|
|
||
|
|
struct MacroAction {
|
||
|
|
enum Kind { kExpansion, kDefinition, kUnDefinition};
|
||
|
|
|
||
|
|
SourceLocation Loc;
|
||
|
|
std::string Name;
|
||
|
|
unsigned MAKind : 3;
|
||
|
|
|
||
|
|
MacroAction(SourceLocation Loc, StringRef Name, unsigned K)
|
||
|
|
: Loc(Loc), Name(std::string(Name)), MAKind(K) {}
|
||
|
|
|
||
|
|
bool isExpansion() const { return MAKind == kExpansion; }
|
||
|
|
bool isDefinition() const { return MAKind & kDefinition; }
|
||
|
|
bool isUnDefinition() const { return MAKind & kUnDefinition; }
|
||
|
|
};
|
||
|
|
|
||
|
|
class MacroTracker : public PPCallbacks {
|
||
|
|
std::vector<MacroAction> &Macros;
|
||
|
|
|
||
|
|
public:
|
||
|
|
explicit MacroTracker(std::vector<MacroAction> &Macros) : Macros(Macros) { }
|
||
|
|
|
||
|
|
void MacroDefined(const Token &MacroNameTok,
|
||
|
|
const MacroDirective *MD) override {
|
||
|
|
Macros.push_back(MacroAction(MD->getLocation(),
|
||
|
|
MacroNameTok.getIdentifierInfo()->getName(),
|
||
|
|
MacroAction::kDefinition));
|
||
|
|
}
|
||
|
|
void MacroUndefined(const Token &MacroNameTok,
|
||
|
|
const MacroDefinition &MD,
|
||
|
|
const MacroDirective *UD) override {
|
||
|
|
Macros.push_back(
|
||
|
|
MacroAction(UD ? UD->getLocation() : SourceLocation(),
|
||
|
|
MacroNameTok.getIdentifierInfo()->getName(),
|
||
|
|
UD ? MacroAction::kDefinition | MacroAction::kUnDefinition
|
||
|
|
: MacroAction::kUnDefinition));
|
||
|
|
}
|
||
|
|
void MacroExpands(const Token &MacroNameTok, const MacroDefinition &MD,
|
||
|
|
SourceRange Range, const MacroArgs *Args) override {
|
||
|
|
Macros.push_back(MacroAction(MacroNameTok.getLocation(),
|
||
|
|
MacroNameTok.getIdentifierInfo()->getName(),
|
||
|
|
MacroAction::kExpansion));
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
TEST_F(SourceManagerTest, isBeforeInTranslationUnitWithMacroInInclude) {
|
||
|
|
const char *header =
|
||
|
|
"#define MACRO_IN_INCLUDE 0\n"
|
||
|
|
"#define MACRO_DEFINED\n"
|
||
|
|
"#undef MACRO_DEFINED\n"
|
||
|
|
"#undef MACRO_UNDEFINED\n";
|
||
|
|
|
||
|
|
const char *main =
|
||
|
|
"#define M(x) x\n"
|
||
|
|
"#define INC \"/test-header.h\"\n"
|
||
|
|
"#include M(INC)\n"
|
||
|
|
"#define INC2 </test-header.h>\n"
|
||
|
|
"#include M(INC2)\n";
|
||
|
|
|
||
|
|
std::unique_ptr<llvm::MemoryBuffer> HeaderBuf =
|
||
|
|
llvm::MemoryBuffer::getMemBuffer(header);
|
||
|
|
std::unique_ptr<llvm::MemoryBuffer> MainBuf =
|
||
|
|
llvm::MemoryBuffer::getMemBuffer(main);
|
||
|
|
SourceMgr.setMainFileID(SourceMgr.createFileID(std::move(MainBuf)));
|
||
|
|
|
||
|
|
const FileEntry *headerFile = FileMgr.getVirtualFile("/test-header.h",
|
||
|
|
HeaderBuf->getBufferSize(), 0);
|
||
|
|
SourceMgr.overrideFileContents(headerFile, std::move(HeaderBuf));
|
||
|
|
|
||
|
|
TrivialModuleLoader ModLoader;
|
||
|
|
HeaderSearch HeaderInfo(std::make_shared<HeaderSearchOptions>(), SourceMgr,
|
||
|
|
Diags, LangOpts, &*Target);
|
||
|
|
Preprocessor PP(std::make_shared<PreprocessorOptions>(), Diags, LangOpts,
|
||
|
|
SourceMgr, HeaderInfo, ModLoader,
|
||
|
|
/*IILookup =*/nullptr,
|
||
|
|
/*OwnsHeaderSearch =*/false);
|
||
|
|
PP.Initialize(*Target);
|
||
|
|
|
||
|
|
std::vector<MacroAction> Macros;
|
||
|
|
PP.addPPCallbacks(std::make_unique<MacroTracker>(Macros));
|
||
|
|
|
||
|
|
PP.EnterMainSourceFile();
|
||
|
|
|
||
|
|
std::vector<Token> toks;
|
||
|
|
while (1) {
|
||
|
|
Token tok;
|
||
|
|
PP.Lex(tok);
|
||
|
|
if (tok.is(tok::eof))
|
||
|
|
break;
|
||
|
|
toks.push_back(tok);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Make sure we got the tokens that we expected.
|
||
|
|
ASSERT_EQ(0U, toks.size());
|
||
|
|
|
||
|
|
ASSERT_EQ(15U, Macros.size());
|
||
|
|
// #define M(x) x
|
||
|
|
ASSERT_TRUE(Macros[0].isDefinition());
|
||
|
|
ASSERT_EQ("M", Macros[0].Name);
|
||
|
|
// #define INC "/test-header.h"
|
||
|
|
ASSERT_TRUE(Macros[1].isDefinition());
|
||
|
|
ASSERT_EQ("INC", Macros[1].Name);
|
||
|
|
// M expansion in #include M(INC)
|
||
|
|
ASSERT_FALSE(Macros[2].isDefinition());
|
||
|
|
ASSERT_EQ("M", Macros[2].Name);
|
||
|
|
// INC expansion in #include M(INC)
|
||
|
|
ASSERT_TRUE(Macros[3].isExpansion());
|
||
|
|
ASSERT_EQ("INC", Macros[3].Name);
|
||
|
|
// #define MACRO_IN_INCLUDE 0
|
||
|
|
ASSERT_TRUE(Macros[4].isDefinition());
|
||
|
|
ASSERT_EQ("MACRO_IN_INCLUDE", Macros[4].Name);
|
||
|
|
// #define MACRO_DEFINED
|
||
|
|
ASSERT_TRUE(Macros[5].isDefinition());
|
||
|
|
ASSERT_FALSE(Macros[5].isUnDefinition());
|
||
|
|
ASSERT_EQ("MACRO_DEFINED", Macros[5].Name);
|
||
|
|
// #undef MACRO_DEFINED
|
||
|
|
ASSERT_TRUE(Macros[6].isDefinition());
|
||
|
|
ASSERT_TRUE(Macros[6].isUnDefinition());
|
||
|
|
ASSERT_EQ("MACRO_DEFINED", Macros[6].Name);
|
||
|
|
// #undef MACRO_UNDEFINED
|
||
|
|
ASSERT_FALSE(Macros[7].isDefinition());
|
||
|
|
ASSERT_TRUE(Macros[7].isUnDefinition());
|
||
|
|
ASSERT_EQ("MACRO_UNDEFINED", Macros[7].Name);
|
||
|
|
// #define INC2 </test-header.h>
|
||
|
|
ASSERT_TRUE(Macros[8].isDefinition());
|
||
|
|
ASSERT_EQ("INC2", Macros[8].Name);
|
||
|
|
// M expansion in #include M(INC2)
|
||
|
|
ASSERT_FALSE(Macros[9].isDefinition());
|
||
|
|
ASSERT_EQ("M", Macros[9].Name);
|
||
|
|
// INC2 expansion in #include M(INC2)
|
||
|
|
ASSERT_TRUE(Macros[10].isExpansion());
|
||
|
|
ASSERT_EQ("INC2", Macros[10].Name);
|
||
|
|
// #define MACRO_IN_INCLUDE 0
|
||
|
|
ASSERT_TRUE(Macros[11].isDefinition());
|
||
|
|
ASSERT_EQ("MACRO_IN_INCLUDE", Macros[11].Name);
|
||
|
|
|
||
|
|
// The INC expansion in #include M(INC) comes before the first
|
||
|
|
// MACRO_IN_INCLUDE definition of the included file.
|
||
|
|
EXPECT_TRUE(SourceMgr.isBeforeInTranslationUnit(Macros[3].Loc, Macros[4].Loc));
|
||
|
|
|
||
|
|
// The INC2 expansion in #include M(INC2) comes before the second
|
||
|
|
// MACRO_IN_INCLUDE definition of the included file.
|
||
|
|
EXPECT_TRUE(SourceMgr.isBeforeInTranslationUnit(Macros[10].Loc, Macros[11].Loc));
|
||
|
|
}
|
||
|
|
|
||
|
|
TEST_F(SourceManagerTest, isMainFile) {
|
||
|
|
const char *Source = "int x;";
|
||
|
|
|
||
|
|
std::unique_ptr<llvm::MemoryBuffer> Buf =
|
||
|
|
llvm::MemoryBuffer::getMemBuffer(Source);
|
||
|
|
const FileEntry *SourceFile =
|
||
|
|
FileMgr.getVirtualFile("mainFile.cpp", Buf->getBufferSize(), 0);
|
||
|
|
SourceMgr.overrideFileContents(SourceFile, std::move(Buf));
|
||
|
|
|
||
|
|
std::unique_ptr<llvm::MemoryBuffer> Buf2 =
|
||
|
|
llvm::MemoryBuffer::getMemBuffer(Source);
|
||
|
|
const FileEntry *SecondFile =
|
||
|
|
FileMgr.getVirtualFile("file2.cpp", Buf2->getBufferSize(), 0);
|
||
|
|
SourceMgr.overrideFileContents(SecondFile, std::move(Buf2));
|
||
|
|
|
||
|
|
FileID MainFileID = SourceMgr.getOrCreateFileID(SourceFile, SrcMgr::C_User);
|
||
|
|
SourceMgr.setMainFileID(MainFileID);
|
||
|
|
|
||
|
|
EXPECT_TRUE(SourceMgr.isMainFile(*SourceFile));
|
||
|
|
EXPECT_TRUE(SourceMgr.isMainFile(*SourceFile));
|
||
|
|
EXPECT_FALSE(SourceMgr.isMainFile(*SecondFile));
|
||
|
|
}
|
||
|
|
|
||
|
|
#endif
|
||
|
|
|
||
|
|
} // anonymous namespace
|