maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/clang/unittests/Lex/PPConditionalDirectiveRecor...

138 lines
5.0 KiB
C++
Raw Normal View History

Refactor recording the preprocessor conditional directive regions out of PreprocessingRecord and into its own class, PPConditionalDirectiveRecord. Decoupling allows a client to use the functionality of PPConditionalDirectiveRecord without needing a PreprocessingRecord. llvm-svn: 169229
2012-12-04 15:27:05 +08:00
//===- unittests/Lex/PPConditionalDirectiveRecordTest.cpp-PP directive tests =//
[preprocessor] Enhance PreprocessingRecord to keep track of locations of conditional directives. Introduce PreprocessingRecord::rangeIntersectsConditionalDirective() which returns true if a given range intersects with a conditional directive block. llvm-svn: 152018
2012-03-05 13:48:17 +08:00
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
Sort the #include lines for unittests/... I've tried to place sensible headers at the top as main-module headers. llvm-svn: 169243
2012-12-04 17:45:34 +08:00
#include "clang/Lex/PPConditionalDirectiveRecord.h"
[preprocessor] Enhance PreprocessingRecord to keep track of locations of conditional directives. Introduce PreprocessingRecord::rangeIntersectsConditionalDirective() which returns true if a given range intersects with a conditional directive block. llvm-svn: 152018
2012-03-05 13:48:17 +08:00
#include "clang/Basic/Diagnostic.h"
One last unit-test fix llvm-svn: 166513
2012-10-24 06:43:37 +08:00
#include "clang/Basic/DiagnosticOptions.h"
Sort the #include lines for unittests/... I've tried to place sensible headers at the top as main-module headers. llvm-svn: 169243
2012-12-04 17:45:34 +08:00
#include "clang/Basic/FileManager.h"
[preprocessor] Enhance PreprocessingRecord to keep track of locations of conditional directives. Introduce PreprocessingRecord::rangeIntersectsConditionalDirective() which returns true if a given range intersects with a conditional directive block. llvm-svn: 152018
2012-03-05 13:48:17 +08:00
#include "clang/Basic/LangOptions.h"
Reapply "Modules: Cache PCMs in memory and avoid a use-after-free" This reverts commit r298185, effectively reapplying r298165, after fixing the new unit tests (PR32338). The memory buffer generator doesn't null-terminate the MemoryBuffer it creates; this version of the commit informs getMemBuffer about that to avoid the assert. Original commit message follows: ---- Clang's internal build system for implicit modules uses lock files to ensure that after a process writes a PCM it will read the same one back in (without contention from other -cc1 commands). Since PCMs are read from disk repeatedly while invalidating, building, and importing, the lock is not released quickly. Furthermore, the LockFileManager is not robust in every environment. Other -cc1 commands can stall until timeout (after about eight minutes). This commit changes the lock file from being necessary for correctness to a (possibly dubious) performance hack. The remaining benefit is to reduce duplicate work in competing -cc1 commands which depend on the same module. Follow-up commits will change the internal build system to continue after a timeout, and reduce the timeout. Perhaps we should reconsider blocking at all. This also fixes a use-after-free, when one part of a compilation validates a PCM and starts using it, and another tries to swap out the PCM for something new. The PCMCache is a new type called MemoryBufferCache, which saves memory buffers based on their filename. Its ownership is shared by the CompilerInstance and ModuleManager. - The ModuleManager stores PCMs there that it loads from disk, never touching the disk if the cache is hot. - When modules fail to validate, they're removed from the cache. - When a CompilerInstance is spawned to build a new module, each already-loaded PCM is assumed to be valid, and is frozen to avoid the use-after-free. - Any newly-built module is written directly to the cache to avoid the round-trip to the filesystem, making lock files unnecessary for correctness. Original patch by Manman Ren; most testcases by Adrian Prantl! llvm-svn: 298278
2017-03-21 01:58:26 +08:00
#include "clang/Basic/MemoryBufferCache.h"
Really sort the #include lines in unittests/... I forgot to re-sort after fixing main module headers. llvm-svn: 169244
2012-12-04 17:53:37 +08:00
#include "clang/Basic/SourceManager.h"
[preprocessor] Enhance PreprocessingRecord to keep track of locations of conditional directives. Introduce PreprocessingRecord::rangeIntersectsConditionalDirective() which returns true if a given range intersects with a conditional directive block. llvm-svn: 152018
2012-03-05 13:48:17 +08:00
#include "clang/Basic/TargetInfo.h"
Sort the #include lines for unittests/... I've tried to place sensible headers at the top as main-module headers. llvm-svn: 169243
2012-12-04 17:45:34 +08:00
#include "clang/Basic/TargetOptions.h"
[preprocessor] Enhance PreprocessingRecord to keep track of locations of conditional directives. Introduce PreprocessingRecord::rangeIntersectsConditionalDirective() which returns true if a given range intersects with a conditional directive block. llvm-svn: 152018
2012-03-05 13:48:17 +08:00
#include "clang/Lex/HeaderSearch.h"
Update unit tests for HeaderSearch change llvm-svn: 166584
2012-10-25 00:24:38 +08:00
#include "clang/Lex/HeaderSearchOptions.h"
Sort the #include lines for unittests/... I've tried to place sensible headers at the top as main-module headers. llvm-svn: 169243
2012-12-04 17:45:34 +08:00
#include "clang/Lex/ModuleLoader.h"
[preprocessor] Enhance PreprocessingRecord to keep track of locations of conditional directives. Introduce PreprocessingRecord::rangeIntersectsConditionalDirective() which returns true if a given range intersects with a conditional directive block. llvm-svn: 152018
2012-03-05 13:48:17 +08:00
#include "clang/Lex/Preprocessor.h"
Teach the preprocessor to hold onto the preprocessor options. llvm-svn: 166599
2012-10-25 01:46:57 +08:00
#include "clang/Lex/PreprocessorOptions.h"
[preprocessor] Enhance PreprocessingRecord to keep track of locations of conditional directives. Introduce PreprocessingRecord::rangeIntersectsConditionalDirective() which returns true if a given range intersects with a conditional directive block. llvm-svn: 152018
2012-03-05 13:48:17 +08:00
#include "gtest/gtest.h"
using namespace clang;
namespace {
// The test fixture.
Refactor recording the preprocessor conditional directive regions out of PreprocessingRecord and into its own class, PPConditionalDirectiveRecord. Decoupling allows a client to use the functionality of PPConditionalDirectiveRecord without needing a PreprocessingRecord. llvm-svn: 169229
2012-12-04 15:27:05 +08:00
class PPConditionalDirectiveRecordTest : public ::testing::Test {
[preprocessor] Enhance PreprocessingRecord to keep track of locations of conditional directives. Introduce PreprocessingRecord::rangeIntersectsConditionalDirective() which returns true if a given range intersects with a conditional directive block. llvm-svn: 152018
2012-03-05 13:48:17 +08:00
protected:
Refactor recording the preprocessor conditional directive regions out of PreprocessingRecord and into its own class, PPConditionalDirectiveRecord. Decoupling allows a client to use the functionality of PPConditionalDirectiveRecord without needing a PreprocessingRecord. llvm-svn: 169229
2012-12-04 15:27:05 +08:00
PPConditionalDirectiveRecordTest()
[preprocessor] Enhance PreprocessingRecord to keep track of locations of conditional directives. Introduce PreprocessingRecord::rangeIntersectsConditionalDirective() which returns true if a given range intersects with a conditional directive block. llvm-svn: 152018
2012-03-05 13:48:17 +08:00
: FileMgr(FileMgrOpts),
DiagID(new DiagnosticIDs()),
One last unit-test fix llvm-svn: 166513
2012-10-24 06:43:37 +08:00
Diags(DiagID, new DiagnosticOptions, new IgnoringDiagConsumer()),
Fix the handling of target options in our unit tests. llvm-svn: 166079
2012-10-17 08:11:35 +08:00
SourceMgr(Diags, FileMgr),
TargetOpts(new TargetOptions)
{
TargetOpts->Triple = "x86_64-apple-darwin11.1.0";
Use non-intrusive refcounting for TargetOptions llvm-svn: 212388
2014-07-06 13:26:44 +08:00
Target = TargetInfo::CreateTargetInfo(Diags, TargetOpts);
[preprocessor] Enhance PreprocessingRecord to keep track of locations of conditional directives. Introduce PreprocessingRecord::rangeIntersectsConditionalDirective() which returns true if a given range intersects with a conditional directive block. llvm-svn: 152018
2012-03-05 13:48:17 +08:00
}
FileSystemOptions FileMgrOpts;
FileManager FileMgr;
IntrusiveRefCntPtr<DiagnosticIDs> DiagID;
DiagnosticsEngine Diags;
SourceManager SourceMgr;
LangOptions LangOpts;
Use non-intrusive refcounting for TargetOptions llvm-svn: 212388
2014-07-06 13:26:44 +08:00
std::shared_ptr<TargetOptions> TargetOpts;
[preprocessor] Enhance PreprocessingRecord to keep track of locations of conditional directives. Introduce PreprocessingRecord::rangeIntersectsConditionalDirective() which returns true if a given range intersects with a conditional directive block. llvm-svn: 152018
2012-03-05 13:48:17 +08:00
IntrusiveRefCntPtr<TargetInfo> Target;
};
Refactor recording the preprocessor conditional directive regions out of PreprocessingRecord and into its own class, PPConditionalDirectiveRecord. Decoupling allows a client to use the functionality of PPConditionalDirectiveRecord without needing a PreprocessingRecord. llvm-svn: 169229
2012-12-04 15:27:05 +08:00
TEST_F(PPConditionalDirectiveRecordTest, PPRecAPI) {
[preprocessor] Enhance PreprocessingRecord to keep track of locations of conditional directives. Introduce PreprocessingRecord::rangeIntersectsConditionalDirective() which returns true if a given range intersects with a conditional directive block. llvm-svn: 152018
2012-03-05 13:48:17 +08:00
const char *source =
"0 1\n"
"#if 1\n"
"2\n"
"#ifndef BB\n"
"3 4\n"
"#else\n"
"#endif\n"
"5\n"
"#endif\n"
"6\n"
"#if 1\n"
"7\n"
"#if 1\n"
"#endif\n"
"8\n"
"#endif\n"
"9\n";
Make TargetInfo store an actual DataLayout instead of a string. Use it to calculate UserLabelPrefix, instead of specifying it (often incorrectly). Note that the *actual* user label prefix has always come from the DataLayout, and is handled within LLVM. The main thing clang's TargetInfo::UserLabelPrefix did was to set the #define value. Having these be different from each-other is just silly. Differential Revision: http://reviews.llvm.org/D17183 llvm-svn: 262737
2016-03-05 03:00:41 +08:00
std::unique_ptr<llvm::MemoryBuffer> Buf =
llvm::MemoryBuffer::getMemBuffer(source);
unique_ptrify SourceManager::createFileID llvm-svn: 216715
2014-08-29 15:59:55 +08:00
SourceMgr.setMainFileID(SourceMgr.createFileID(std::move(Buf)));
[preprocessor] Enhance PreprocessingRecord to keep track of locations of conditional directives. Introduce PreprocessingRecord::rangeIntersectsConditionalDirective() which returns true if a given range intersects with a conditional directive block. llvm-svn: 152018
2012-03-05 13:48:17 +08:00
Add #pragma clang module build/endbuild pragmas for performing a module build as part of a compilation. This is intended for two purposes: 1) Writing self-contained test cases for modules: we can now write a single source file test that builds some number of module files on the side and imports them. 2) Debugging / test case reduction. A single-source testcase is much more amenable to reduction, compared to a VFS tarball or .pcm files. llvm-svn: 305101
2017-06-10 03:22:32 +08:00
TrivialModuleLoader ModLoader;
Reapply "Modules: Cache PCMs in memory and avoid a use-after-free" This reverts commit r298185, effectively reapplying r298165, after fixing the new unit tests (PR32338). The memory buffer generator doesn't null-terminate the MemoryBuffer it creates; this version of the commit informs getMemBuffer about that to avoid the assert. Original commit message follows: ---- Clang's internal build system for implicit modules uses lock files to ensure that after a process writes a PCM it will read the same one back in (without contention from other -cc1 commands). Since PCMs are read from disk repeatedly while invalidating, building, and importing, the lock is not released quickly. Furthermore, the LockFileManager is not robust in every environment. Other -cc1 commands can stall until timeout (after about eight minutes). This commit changes the lock file from being necessary for correctness to a (possibly dubious) performance hack. The remaining benefit is to reduce duplicate work in competing -cc1 commands which depend on the same module. Follow-up commits will change the internal build system to continue after a timeout, and reduce the timeout. Perhaps we should reconsider blocking at all. This also fixes a use-after-free, when one part of a compilation validates a PCM and starts using it, and another tries to swap out the PCM for something new. The PCMCache is a new type called MemoryBufferCache, which saves memory buffers based on their filename. Its ownership is shared by the CompilerInstance and ModuleManager. - The ModuleManager stores PCMs there that it loads from disk, never touching the disk if the cache is hot. - When modules fail to validate, they're removed from the cache. - When a CompilerInstance is spawned to build a new module, each already-loaded PCM is assumed to be valid, and is frozen to avoid the use-after-free. - Any newly-built module is written directly to the cache to avoid the round-trip to the filesystem, making lock files unnecessary for correctness. Original patch by Manman Ren; most testcases by Adrian Prantl! llvm-svn: 298278
2017-03-21 01:58:26 +08:00
MemoryBufferCache PCMCache;
shared_ptrify (from InclusiveRefCntPtr) HeaderSearchOptions llvm-svn: 291202
2017-01-06 09:04:46 +08:00
HeaderSearch HeaderInfo(std::make_shared<HeaderSearchOptions>(), SourceMgr,
Diags, LangOpts, Target.get());
Move PreprocessorOptions to std::shared_ptr from IntrusiveRefCntPtr llvm-svn: 291160
2017-01-06 03:11:36 +08:00
Preprocessor PP(std::make_shared<PreprocessorOptions>(), Diags, LangOpts,
Reapply "Modules: Cache PCMs in memory and avoid a use-after-free" This reverts commit r298185, effectively reapplying r298165, after fixing the new unit tests (PR32338). The memory buffer generator doesn't null-terminate the MemoryBuffer it creates; this version of the commit informs getMemBuffer about that to avoid the assert. Original commit message follows: ---- Clang's internal build system for implicit modules uses lock files to ensure that after a process writes a PCM it will read the same one back in (without contention from other -cc1 commands). Since PCMs are read from disk repeatedly while invalidating, building, and importing, the lock is not released quickly. Furthermore, the LockFileManager is not robust in every environment. Other -cc1 commands can stall until timeout (after about eight minutes). This commit changes the lock file from being necessary for correctness to a (possibly dubious) performance hack. The remaining benefit is to reduce duplicate work in competing -cc1 commands which depend on the same module. Follow-up commits will change the internal build system to continue after a timeout, and reduce the timeout. Perhaps we should reconsider blocking at all. This also fixes a use-after-free, when one part of a compilation validates a PCM and starts using it, and another tries to swap out the PCM for something new. The PCMCache is a new type called MemoryBufferCache, which saves memory buffers based on their filename. Its ownership is shared by the CompilerInstance and ModuleManager. - The ModuleManager stores PCMs there that it loads from disk, never touching the disk if the cache is hot. - When modules fail to validate, they're removed from the cache. - When a CompilerInstance is spawned to build a new module, each already-loaded PCM is assumed to be valid, and is frozen to avoid the use-after-free. - Any newly-built module is written directly to the cache to avoid the round-trip to the filesystem, making lock files unnecessary for correctness. Original patch by Manman Ren; most testcases by Adrian Prantl! llvm-svn: 298278
2017-03-21 01:58:26 +08:00
SourceMgr, PCMCache, HeaderInfo, ModLoader,
[C++11] Use 'nullptr'. Unittests edition. llvm-svn: 210423
2014-06-08 16:38:12 +08:00
/*IILookup =*/nullptr,
Factor TargetInfo pointer/DelayInitialization bool pair out of Preprocessor ctor The Preprocessor::Initialize() function already offers a clear interface to achieve this, further reducing the confusing number of states a newly constructed preprocessor can have. llvm-svn: 207825
2014-05-02 11:43:30 +08:00
/*OwnsHeaderSearch =*/false);
PP.Initialize(*Target);
Refactor recording the preprocessor conditional directive regions out of PreprocessingRecord and into its own class, PPConditionalDirectiveRecord. Decoupling allows a client to use the functionality of PPConditionalDirectiveRecord without needing a PreprocessingRecord. llvm-svn: 169229
2012-12-04 15:27:05 +08:00
PPConditionalDirectiveRecord *
PPRec = new PPConditionalDirectiveRecord(SourceMgr);
Unique_ptrify PPCallbacks ownership. Unique_ptr creation stil needs to be moved earlier at some of the call sites. llvm-svn: 217474
2014-09-10 12:53:53 +08:00
PP.addPPCallbacks(std::unique_ptr<PPCallbacks>(PPRec));
[preprocessor] Enhance PreprocessingRecord to keep track of locations of conditional directives. Introduce PreprocessingRecord::rangeIntersectsConditionalDirective() which returns true if a given range intersects with a conditional directive block. llvm-svn: 152018
2012-03-05 13:48:17 +08:00
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(10U, toks.size());
Refactor recording the preprocessor conditional directive regions out of PreprocessingRecord and into its own class, PPConditionalDirectiveRecord. Decoupling allows a client to use the functionality of PPConditionalDirectiveRecord without needing a PreprocessingRecord. llvm-svn: 169229
2012-12-04 15:27:05 +08:00
EXPECT_FALSE(PPRec->rangeIntersectsConditionalDirective(
[preprocessor] Enhance PreprocessingRecord to keep track of locations of conditional directives. Introduce PreprocessingRecord::rangeIntersectsConditionalDirective() which returns true if a given range intersects with a conditional directive block. llvm-svn: 152018
2012-03-05 13:48:17 +08:00
SourceRange(toks[0].getLocation(), toks[1].getLocation())));
Refactor recording the preprocessor conditional directive regions out of PreprocessingRecord and into its own class, PPConditionalDirectiveRecord. Decoupling allows a client to use the functionality of PPConditionalDirectiveRecord without needing a PreprocessingRecord. llvm-svn: 169229
2012-12-04 15:27:05 +08:00
EXPECT_TRUE(PPRec->rangeIntersectsConditionalDirective(
[preprocessor] Enhance PreprocessingRecord to keep track of locations of conditional directives. Introduce PreprocessingRecord::rangeIntersectsConditionalDirective() which returns true if a given range intersects with a conditional directive block. llvm-svn: 152018
2012-03-05 13:48:17 +08:00
SourceRange(toks[0].getLocation(), toks[2].getLocation())));
Refactor recording the preprocessor conditional directive regions out of PreprocessingRecord and into its own class, PPConditionalDirectiveRecord. Decoupling allows a client to use the functionality of PPConditionalDirectiveRecord without needing a PreprocessingRecord. llvm-svn: 169229
2012-12-04 15:27:05 +08:00
EXPECT_FALSE(PPRec->rangeIntersectsConditionalDirective(
[preprocessor] Enhance PreprocessingRecord to keep track of locations of conditional directives. Introduce PreprocessingRecord::rangeIntersectsConditionalDirective() which returns true if a given range intersects with a conditional directive block. llvm-svn: 152018
2012-03-05 13:48:17 +08:00
SourceRange(toks[3].getLocation(), toks[4].getLocation())));
Refactor recording the preprocessor conditional directive regions out of PreprocessingRecord and into its own class, PPConditionalDirectiveRecord. Decoupling allows a client to use the functionality of PPConditionalDirectiveRecord without needing a PreprocessingRecord. llvm-svn: 169229
2012-12-04 15:27:05 +08:00
EXPECT_TRUE(PPRec->rangeIntersectsConditionalDirective(
[preprocessor] Enhance PreprocessingRecord to keep track of locations of conditional directives. Introduce PreprocessingRecord::rangeIntersectsConditionalDirective() which returns true if a given range intersects with a conditional directive block. llvm-svn: 152018
2012-03-05 13:48:17 +08:00
SourceRange(toks[1].getLocation(), toks[5].getLocation())));
Refactor recording the preprocessor conditional directive regions out of PreprocessingRecord and into its own class, PPConditionalDirectiveRecord. Decoupling allows a client to use the functionality of PPConditionalDirectiveRecord without needing a PreprocessingRecord. llvm-svn: 169229
2012-12-04 15:27:05 +08:00
EXPECT_TRUE(PPRec->rangeIntersectsConditionalDirective(
[preprocessor] Enhance PreprocessingRecord to keep track of locations of conditional directives. Introduce PreprocessingRecord::rangeIntersectsConditionalDirective() which returns true if a given range intersects with a conditional directive block. llvm-svn: 152018
2012-03-05 13:48:17 +08:00
SourceRange(toks[2].getLocation(), toks[6].getLocation())));
Refactor recording the preprocessor conditional directive regions out of PreprocessingRecord and into its own class, PPConditionalDirectiveRecord. Decoupling allows a client to use the functionality of PPConditionalDirectiveRecord without needing a PreprocessingRecord. llvm-svn: 169229
2012-12-04 15:27:05 +08:00
EXPECT_FALSE(PPRec->rangeIntersectsConditionalDirective(
[preprocessor] Enhance PreprocessingRecord to keep track of locations of conditional directives. Introduce PreprocessingRecord::rangeIntersectsConditionalDirective() which returns true if a given range intersects with a conditional directive block. llvm-svn: 152018
2012-03-05 13:48:17 +08:00
SourceRange(toks[2].getLocation(), toks[5].getLocation())));
Refactor recording the preprocessor conditional directive regions out of PreprocessingRecord and into its own class, PPConditionalDirectiveRecord. Decoupling allows a client to use the functionality of PPConditionalDirectiveRecord without needing a PreprocessingRecord. llvm-svn: 169229
2012-12-04 15:27:05 +08:00
EXPECT_FALSE(PPRec->rangeIntersectsConditionalDirective(
[preprocessor] Enhance PreprocessingRecord to keep track of locations of conditional directives. Introduce PreprocessingRecord::rangeIntersectsConditionalDirective() which returns true if a given range intersects with a conditional directive block. llvm-svn: 152018
2012-03-05 13:48:17 +08:00
SourceRange(toks[0].getLocation(), toks[6].getLocation())));
Refactor recording the preprocessor conditional directive regions out of PreprocessingRecord and into its own class, PPConditionalDirectiveRecord. Decoupling allows a client to use the functionality of PPConditionalDirectiveRecord without needing a PreprocessingRecord. llvm-svn: 169229
2012-12-04 15:27:05 +08:00
EXPECT_TRUE(PPRec->rangeIntersectsConditionalDirective(
[preprocessor] Enhance PreprocessingRecord to keep track of locations of conditional directives. Introduce PreprocessingRecord::rangeIntersectsConditionalDirective() which returns true if a given range intersects with a conditional directive block. llvm-svn: 152018
2012-03-05 13:48:17 +08:00
SourceRange(toks[2].getLocation(), toks[8].getLocation())));
Refactor recording the preprocessor conditional directive regions out of PreprocessingRecord and into its own class, PPConditionalDirectiveRecord. Decoupling allows a client to use the functionality of PPConditionalDirectiveRecord without needing a PreprocessingRecord. llvm-svn: 169229
2012-12-04 15:27:05 +08:00
EXPECT_FALSE(PPRec->rangeIntersectsConditionalDirective(
[preprocessor] Enhance PreprocessingRecord to keep track of locations of conditional directives. Introduce PreprocessingRecord::rangeIntersectsConditionalDirective() which returns true if a given range intersects with a conditional directive block. llvm-svn: 152018
2012-03-05 13:48:17 +08:00
SourceRange(toks[0].getLocation(), toks[9].getLocation())));
Refactor recording the preprocessor conditional directive regions out of PreprocessingRecord and into its own class, PPConditionalDirectiveRecord. Decoupling allows a client to use the functionality of PPConditionalDirectiveRecord without needing a PreprocessingRecord. llvm-svn: 169229
2012-12-04 15:27:05 +08:00
EXPECT_TRUE(PPRec->areInDifferentConditionalDirectiveRegion(
[preprocessor] Enhance PreprocessingRecord to keep track of locations of conditional directives. Introduce PreprocessingRecord::rangeIntersectsConditionalDirective() which returns true if a given range intersects with a conditional directive block. llvm-svn: 152018
2012-03-05 13:48:17 +08:00
toks[0].getLocation(), toks[2].getLocation()));
Refactor recording the preprocessor conditional directive regions out of PreprocessingRecord and into its own class, PPConditionalDirectiveRecord. Decoupling allows a client to use the functionality of PPConditionalDirectiveRecord without needing a PreprocessingRecord. llvm-svn: 169229
2012-12-04 15:27:05 +08:00
EXPECT_FALSE(PPRec->areInDifferentConditionalDirectiveRegion(
[preprocessor] Enhance PreprocessingRecord to keep track of locations of conditional directives. Introduce PreprocessingRecord::rangeIntersectsConditionalDirective() which returns true if a given range intersects with a conditional directive block. llvm-svn: 152018
2012-03-05 13:48:17 +08:00
toks[3].getLocation(), toks[4].getLocation()));
Refactor recording the preprocessor conditional directive regions out of PreprocessingRecord and into its own class, PPConditionalDirectiveRecord. Decoupling allows a client to use the functionality of PPConditionalDirectiveRecord without needing a PreprocessingRecord. llvm-svn: 169229
2012-12-04 15:27:05 +08:00
EXPECT_TRUE(PPRec->areInDifferentConditionalDirectiveRegion(
[preprocessor] Enhance PreprocessingRecord to keep track of locations of conditional directives. Introduce PreprocessingRecord::rangeIntersectsConditionalDirective() which returns true if a given range intersects with a conditional directive block. llvm-svn: 152018
2012-03-05 13:48:17 +08:00
toks[1].getLocation(), toks[5].getLocation()));
Refactor recording the preprocessor conditional directive regions out of PreprocessingRecord and into its own class, PPConditionalDirectiveRecord. Decoupling allows a client to use the functionality of PPConditionalDirectiveRecord without needing a PreprocessingRecord. llvm-svn: 169229
2012-12-04 15:27:05 +08:00
EXPECT_TRUE(PPRec->areInDifferentConditionalDirectiveRegion(
[preprocessor] Enhance PreprocessingRecord to keep track of locations of conditional directives. Introduce PreprocessingRecord::rangeIntersectsConditionalDirective() which returns true if a given range intersects with a conditional directive block. llvm-svn: 152018
2012-03-05 13:48:17 +08:00
toks[2].getLocation(), toks[0].getLocation()));
Refactor recording the preprocessor conditional directive regions out of PreprocessingRecord and into its own class, PPConditionalDirectiveRecord. Decoupling allows a client to use the functionality of PPConditionalDirectiveRecord without needing a PreprocessingRecord. llvm-svn: 169229
2012-12-04 15:27:05 +08:00
EXPECT_FALSE(PPRec->areInDifferentConditionalDirectiveRegion(
[preprocessor] Enhance PreprocessingRecord to keep track of locations of conditional directives. Introduce PreprocessingRecord::rangeIntersectsConditionalDirective() which returns true if a given range intersects with a conditional directive block. llvm-svn: 152018
2012-03-05 13:48:17 +08:00
toks[4].getLocation(), toks[3].getLocation()));
Refactor recording the preprocessor conditional directive regions out of PreprocessingRecord and into its own class, PPConditionalDirectiveRecord. Decoupling allows a client to use the functionality of PPConditionalDirectiveRecord without needing a PreprocessingRecord. llvm-svn: 169229
2012-12-04 15:27:05 +08:00
EXPECT_TRUE(PPRec->areInDifferentConditionalDirectiveRegion(
[preprocessor] Enhance PreprocessingRecord to keep track of locations of conditional directives. Introduce PreprocessingRecord::rangeIntersectsConditionalDirective() which returns true if a given range intersects with a conditional directive block. llvm-svn: 152018
2012-03-05 13:48:17 +08:00
toks[5].getLocation(), toks[1].getLocation()));
}
} // anonymous namespace