unittests/Basic/SourceManagerTest.cpp - clang - Git at Google


            
            //===- 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 "gtest/gtest.h"


            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>");

            
            }


            #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);

            
              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(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));

            
            }


            #endif


            } // anonymous namespace
	//===- 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 "gtest/gtest.h"

	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>");
	}

	#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);
	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(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));
	}

	#endif

	} // anonymous namespace