e881d85371
This patch is a part of the upstreaming efforts. Cling has the ability to spawn
child interpreters (mainly for auto completions). The child interpreter import
Decls using the ASTImporter which casuses the assertion here
65eb74e94b/clang/include/clang/Basic/SourceLocation.h (L322)
The patch is co-developed with V. Vassilev.
Differential revision: https://reviews.llvm.org/D88780
587 lines
21 KiB
C++
587 lines
21 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, isInMemoryBuffersNoSourceLocationInfo) {
|
|
// Check for invalid source location for each method
|
|
SourceLocation LocEmpty;
|
|
bool isWrittenInBuiltInFileFalse = SourceMgr.isWrittenInBuiltinFile(LocEmpty);
|
|
bool isWrittenInCommandLineFileFalse =
|
|
SourceMgr.isWrittenInCommandLineFile(LocEmpty);
|
|
bool isWrittenInScratchSpaceFalse =
|
|
SourceMgr.isWrittenInScratchSpace(LocEmpty);
|
|
|
|
EXPECT_FALSE(isWrittenInBuiltInFileFalse);
|
|
EXPECT_FALSE(isWrittenInCommandLineFileFalse);
|
|
EXPECT_FALSE(isWrittenInScratchSpaceFalse);
|
|
|
|
// Check for valid source location per filename for each method
|
|
const char *Source = "int x";
|
|
|
|
std::unique_ptr<llvm::MemoryBuffer> BuiltInBuf =
|
|
llvm::MemoryBuffer::getMemBuffer(Source);
|
|
const FileEntry *BuiltInFile =
|
|
FileMgr.getVirtualFile("<built-in>", BuiltInBuf->getBufferSize(), 0);
|
|
SourceMgr.overrideFileContents(BuiltInFile, std::move(BuiltInBuf));
|
|
FileID BuiltInFileID =
|
|
SourceMgr.getOrCreateFileID(BuiltInFile, SrcMgr::C_User);
|
|
SourceMgr.setMainFileID(BuiltInFileID);
|
|
SourceLocation LocBuiltIn =
|
|
SourceMgr.getLocForStartOfFile(SourceMgr.getMainFileID());
|
|
bool isWrittenInBuiltInFileTrue =
|
|
SourceMgr.isWrittenInBuiltinFile(LocBuiltIn);
|
|
|
|
std::unique_ptr<llvm::MemoryBuffer> CommandLineBuf =
|
|
llvm::MemoryBuffer::getMemBuffer(Source);
|
|
const FileEntry *CommandLineFile = FileMgr.getVirtualFile(
|
|
"<command line>", CommandLineBuf->getBufferSize(), 0);
|
|
SourceMgr.overrideFileContents(CommandLineFile, std::move(CommandLineBuf));
|
|
FileID CommandLineFileID =
|
|
SourceMgr.getOrCreateFileID(CommandLineFile, SrcMgr::C_User);
|
|
SourceMgr.setMainFileID(CommandLineFileID);
|
|
SourceLocation LocCommandLine =
|
|
SourceMgr.getLocForStartOfFile(SourceMgr.getMainFileID());
|
|
bool isWrittenInCommandLineFileTrue =
|
|
SourceMgr.isWrittenInCommandLineFile(LocCommandLine);
|
|
|
|
std::unique_ptr<llvm::MemoryBuffer> ScratchSpaceBuf =
|
|
llvm::MemoryBuffer::getMemBuffer(Source);
|
|
const FileEntry *ScratchSpaceFile = FileMgr.getVirtualFile(
|
|
"<scratch space>", ScratchSpaceBuf->getBufferSize(), 0);
|
|
SourceMgr.overrideFileContents(ScratchSpaceFile, std::move(ScratchSpaceBuf));
|
|
FileID ScratchSpaceFileID =
|
|
SourceMgr.getOrCreateFileID(ScratchSpaceFile, SrcMgr::C_User);
|
|
SourceMgr.setMainFileID(ScratchSpaceFileID);
|
|
SourceLocation LocScratchSpace =
|
|
SourceMgr.getLocForStartOfFile(SourceMgr.getMainFileID());
|
|
bool isWrittenInScratchSpaceTrue =
|
|
SourceMgr.isWrittenInScratchSpace(LocScratchSpace);
|
|
|
|
EXPECT_TRUE(isWrittenInBuiltInFileTrue);
|
|
EXPECT_TRUE(isWrittenInCommandLineFileTrue);
|
|
EXPECT_TRUE(isWrittenInScratchSpaceTrue);
|
|
}
|
|
|
|
TEST_F(SourceManagerTest, isInSystemHeader) {
|
|
// Check for invalid source location
|
|
SourceLocation LocEmpty;
|
|
bool isInSystemHeaderFalse = SourceMgr.isInSystemHeader(LocEmpty);
|
|
ASSERT_FALSE(isInSystemHeaderFalse);
|
|
}
|
|
|
|
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
|