Author: Sam McCall Date: 2022-04-06T21:36:57+02:00 New Revision: c03d6257c58ff357b03900fffee6bf75e175f497
URL: https://github.com/llvm/llvm-project/commit/c03d6257c58ff357b03900fffee6bf75e175f497 DIFF: https://github.com/llvm/llvm-project/commit/c03d6257c58ff357b03900fffee6bf75e175f497.diff LOG: [pseudo] Rename DirectiveMap -> DirectiveTree. NFC Addressing comment from previous review https://reviews.llvm.org/D121165?id=413636#inline-1160757 Added: clang-tools-extra/pseudo/include/clang-pseudo/DirectiveTree.h clang-tools-extra/pseudo/lib/DirectiveTree.cpp clang-tools-extra/pseudo/unittests/DirectiveTreeTest.cpp Modified: clang-tools-extra/pseudo/lib/CMakeLists.txt clang-tools-extra/pseudo/test/lex.c clang-tools-extra/pseudo/tool/ClangPseudo.cpp clang-tools-extra/pseudo/unittests/CMakeLists.txt Removed: clang-tools-extra/pseudo/include/clang-pseudo/DirectiveMap.h clang-tools-extra/pseudo/lib/DirectiveMap.cpp clang-tools-extra/pseudo/unittests/DirectiveMapTest.cpp ################################################################################ diff --git a/clang-tools-extra/pseudo/include/clang-pseudo/DirectiveMap.h b/clang-tools-extra/pseudo/include/clang-pseudo/DirectiveTree.h similarity index 88% rename from clang-tools-extra/pseudo/include/clang-pseudo/DirectiveMap.h rename to clang-tools-extra/pseudo/include/clang-pseudo/DirectiveTree.h index 67e815e67efdb..5cd41efcb2ace 100644 --- a/clang-tools-extra/pseudo/include/clang-pseudo/DirectiveMap.h +++ b/clang-tools-extra/pseudo/include/clang-pseudo/DirectiveTree.h @@ -1,4 +1,4 @@ -//===--- DirectiveMap.h - Find and strip preprocessor directives -*- C++-*-===// +//===--- DirectiveTree.h - Find and strip preprocessor directives *- C++-*-===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. @@ -25,8 +25,8 @@ // //===----------------------------------------------------------------------===// -#ifndef CLANG_PSEUDO_DIRECTIVEMAP_H -#define CLANG_PSEUDO_DIRECTIVEMAP_H +#ifndef CLANG_PSEUDO_DIRECTIVETREE_H +#define CLANG_PSEUDO_DIRECTIVETREE_H #include "clang-pseudo/Token.h" #include "clang/Basic/TokenKinds.h" @@ -55,7 +55,7 @@ namespace pseudo { /// /// Unlike the clang preprocessor, we model the full tree explicitly. /// This class does not recognize macro usage, only directives. -struct DirectiveMap { +struct DirectiveTree { /// A range of code (and possibly comments) containing no directives. struct Code { Token::Range Tokens; @@ -75,12 +75,12 @@ struct DirectiveMap { /// /// The first branch will have an #if type directive. /// Subsequent branches will have #else type directives. - std::vector<std::pair<Directive, DirectiveMap>> Branches; + std::vector<std::pair<Directive, DirectiveTree>> Branches; /// The directive terminating the conditional, should be #endif. Directive End; /// The index of the conditional branch we chose as active. /// None indicates no branch was taken (e.g. #if 0 ... #endif). - /// The initial map from of `parse()` has no branches marked as taken. + /// The initial tree from `parse()` has no branches marked as taken. /// See `chooseConditionalBranches()`. llvm::Optional<unsigned> Taken; }; @@ -90,17 +90,17 @@ struct DirectiveMap { std::vector<Chunk> Chunks; /// Extract preprocessor structure by examining the raw tokens. - static DirectiveMap parse(const TokenStream &); + static DirectiveTree parse(const TokenStream &); // FIXME: allow deriving a preprocessed stream }; -llvm::raw_ostream &operator<<(llvm::raw_ostream &, const DirectiveMap &); -llvm::raw_ostream &operator<<(llvm::raw_ostream &, const DirectiveMap::Chunk &); -llvm::raw_ostream &operator<<(llvm::raw_ostream &, const DirectiveMap::Code &); +llvm::raw_ostream &operator<<(llvm::raw_ostream &, const DirectiveTree &); +llvm::raw_ostream &operator<<(llvm::raw_ostream &, const DirectiveTree::Chunk &); +llvm::raw_ostream &operator<<(llvm::raw_ostream &, const DirectiveTree::Code &); llvm::raw_ostream &operator<<(llvm::raw_ostream &, - const DirectiveMap::Directive &); + const DirectiveTree::Directive &); llvm::raw_ostream &operator<<(llvm::raw_ostream &, - const DirectiveMap::Conditional &); + const DirectiveTree::Conditional &); /// Selects a "taken" branch for each conditional directive in the file. /// @@ -118,11 +118,11 @@ llvm::raw_ostream &operator<<(llvm::raw_ostream &, /// #endif /// /// The choices are stored in Conditional::Taken nodes. -void chooseConditionalBranches(DirectiveMap &, const TokenStream &Code); +void chooseConditionalBranches(DirectiveTree &, const TokenStream &Code); // FIXME: This approximates std::variant<Code, Directive, Conditional>. // Switch once we can use C++17. -class DirectiveMap::Chunk { +class DirectiveTree::Chunk { public: enum Kind { K_Empty, K_Code, K_Directive, K_Conditional }; Kind kind() const { @@ -165,4 +165,4 @@ class DirectiveMap::Chunk { } // namespace pseudo } // namespace clang -#endif // CLANG_PSEUDO_DIRECTIVEMAP_H +#endif // CLANG_PSEUDO_DIRECTIVETREE_H diff --git a/clang-tools-extra/pseudo/lib/CMakeLists.txt b/clang-tools-extra/pseudo/lib/CMakeLists.txt index e23093845660d..cc3658aa73cbe 100644 --- a/clang-tools-extra/pseudo/lib/CMakeLists.txt +++ b/clang-tools-extra/pseudo/lib/CMakeLists.txt @@ -1,7 +1,7 @@ set(LLVM_LINK_COMPONENTS Support) add_clang_library(clangPseudo - DirectiveMap.cpp + DirectiveTree.cpp Forest.cpp Grammar.cpp GrammarBNF.cpp diff --git a/clang-tools-extra/pseudo/lib/DirectiveMap.cpp b/clang-tools-extra/pseudo/lib/DirectiveTree.cpp similarity index 78% rename from clang-tools-extra/pseudo/lib/DirectiveMap.cpp rename to clang-tools-extra/pseudo/lib/DirectiveTree.cpp index f25231c9b7f28..f464e3bc3ba66 100644 --- a/clang-tools-extra/pseudo/lib/DirectiveMap.cpp +++ b/clang-tools-extra/pseudo/lib/DirectiveTree.cpp @@ -1,4 +1,4 @@ -//===--- DirectiveMap.cpp - Find and strip preprocessor directives --------===// +//===--- DirectiveTree.cpp - Find and strip preprocessor directives -------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. @@ -6,7 +6,7 @@ // //===----------------------------------------------------------------------===// -#include "clang-pseudo/DirectiveMap.h" +#include "clang-pseudo/DirectiveTree.h" #include "clang/Basic/IdentifierTable.h" #include "clang/Basic/TokenKinds.h" #include "llvm/Support/FormatVariadic.h" @@ -19,7 +19,7 @@ class DirectiveParser { public: explicit DirectiveParser(const TokenStream &Code) : Code(Code), Tok(&Code.front()) {} - void parse(DirectiveMap *Result) { parse(Result, /*TopLevel=*/true); } + void parse(DirectiveTree *Result) { parse(Result, /*TopLevel=*/true); } private: // Roles that a directive might take within a conditional block. @@ -42,10 +42,10 @@ class DirectiveParser { } } - // Parses tokens starting at Tok into Map. - // If we reach an End or Else directive that ends Map, returns it. + // Parses tokens starting at Tok into Tree. + // If we reach an End or Else directive that ends Tree, returns it. // If TopLevel is true, then we do not expect End and always return None. - llvm::Optional<DirectiveMap::Directive> parse(DirectiveMap *Map, + llvm::Optional<DirectiveTree::Directive> parse(DirectiveTree *Tree, bool TopLevel) { auto StartsDirective = [&, AllowDirectiveAt((const Token *)nullptr)]() mutable { @@ -66,29 +66,29 @@ class DirectiveParser { do ++Tok; while (Tok->Kind != tok::eof && !StartsDirective()); - Map->Chunks.push_back(DirectiveMap::Code{ + Tree->Chunks.push_back(DirectiveTree::Code{ Token::Range{Code.index(*Start), Code.index(*Tok)}}); continue; } // We have some kind of directive. - DirectiveMap::Directive Directive; + DirectiveTree::Directive Directive; parseDirective(&Directive); Cond Kind = classifyDirective(Directive.Kind); if (Kind == Cond::If) { // #if or similar, starting a nested conditional block. - DirectiveMap::Conditional Conditional; + DirectiveTree::Conditional Conditional; Conditional.Branches.emplace_back(); Conditional.Branches.back().first = std::move(Directive); parseConditional(&Conditional); - Map->Chunks.push_back(std::move(Conditional)); + Tree->Chunks.push_back(std::move(Conditional)); } else if ((Kind == Cond::Else || Kind == Cond::End) && !TopLevel) { // #endif or similar, ending this PStructure scope. // (#endif is unexpected at the top level, treat as simple directive). return std::move(Directive); } else { // #define or similar, a simple directive at the current scope. - Map->Chunks.push_back(std::move(Directive)); + Tree->Chunks.push_back(std::move(Directive)); } } return None; @@ -96,7 +96,7 @@ class DirectiveParser { // Parse the rest of a conditional section, after seeing the If directive. // Returns after consuming the End directive. - void parseConditional(DirectiveMap::Conditional *C) { + void parseConditional(DirectiveTree::Conditional *C) { assert(C->Branches.size() == 1 && C->Branches.front().second.Chunks.empty() && "Should be ready to parse first branch body"); @@ -119,7 +119,7 @@ class DirectiveParser { } // Parse a directive. Tok is the hash. - void parseDirective(DirectiveMap::Directive *D) { + void parseDirective(DirectiveTree::Directive *D) { assert(Tok->Kind == tok::hash); // Directive spans from the hash until the end of line or file. @@ -143,26 +143,26 @@ class DirectiveParser { } // namespace -DirectiveMap DirectiveMap::parse(const TokenStream &Code) { - DirectiveMap Result; +DirectiveTree DirectiveTree::parse(const TokenStream &Code) { + DirectiveTree Result; DirectiveParser(Code).parse(&Result); return Result; } -static void dump(llvm::raw_ostream &OS, const DirectiveMap &, unsigned Indent); +static void dump(llvm::raw_ostream &OS, const DirectiveTree &, unsigned Indent); static void dump(llvm::raw_ostream &OS, - const DirectiveMap::Directive &Directive, unsigned Indent, + const DirectiveTree::Directive &Directive, unsigned Indent, bool Taken = false) { OS.indent(Indent) << llvm::formatv( "#{0} ({1} tokens){2}\n", tok::getPPKeywordSpelling(Directive.Kind), Directive.Tokens.size(), Taken ? " TAKEN" : ""); } -static void dump(llvm::raw_ostream &OS, const DirectiveMap::Code &Code, +static void dump(llvm::raw_ostream &OS, const DirectiveTree::Code &Code, unsigned Indent) { OS.indent(Indent) << llvm::formatv("code ({0} tokens)\n", Code.Tokens.size()); } static void dump(llvm::raw_ostream &OS, - const DirectiveMap::Conditional &Conditional, + const DirectiveTree::Conditional &Conditional, unsigned Indent) { for (unsigned I = 0; I < Conditional.Branches.size(); ++I) { const auto &Branch = Conditional.Branches[I]; @@ -172,23 +172,23 @@ static void dump(llvm::raw_ostream &OS, dump(OS, Conditional.End, Indent); } -static void dump(llvm::raw_ostream &OS, const DirectiveMap::Chunk &Chunk, +static void dump(llvm::raw_ostream &OS, const DirectiveTree::Chunk &Chunk, unsigned Indent) { switch (Chunk.kind()) { - case DirectiveMap::Chunk::K_Empty: + case DirectiveTree::Chunk::K_Empty: llvm_unreachable("invalid chunk"); - case DirectiveMap::Chunk::K_Code: - return dump(OS, (const DirectiveMap::Code &)Chunk, Indent); - case DirectiveMap::Chunk::K_Directive: - return dump(OS, (const DirectiveMap::Directive &)Chunk, Indent); - case DirectiveMap::Chunk::K_Conditional: - return dump(OS, (const DirectiveMap::Conditional &)Chunk, Indent); + case DirectiveTree::Chunk::K_Code: + return dump(OS, (const DirectiveTree::Code &)Chunk, Indent); + case DirectiveTree::Chunk::K_Directive: + return dump(OS, (const DirectiveTree::Directive &)Chunk, Indent); + case DirectiveTree::Chunk::K_Conditional: + return dump(OS, (const DirectiveTree::Conditional &)Chunk, Indent); } } -static void dump(llvm::raw_ostream &OS, const DirectiveMap &Map, +static void dump(llvm::raw_ostream &OS, const DirectiveTree &Tree, unsigned Indent) { - for (const auto &Chunk : Map.Chunks) + for (const auto &Chunk : Tree.Chunks) dump(OS, Chunk, Indent); } @@ -198,11 +198,11 @@ static void dump(llvm::raw_ostream &OS, const DirectiveMap &Map, dump(OS, T, 0); \ return OS; \ } -OSTREAM_DUMP(DirectiveMap) -OSTREAM_DUMP(DirectiveMap::Chunk) -OSTREAM_DUMP(DirectiveMap::Directive) -OSTREAM_DUMP(DirectiveMap::Conditional) -OSTREAM_DUMP(DirectiveMap::Code) +OSTREAM_DUMP(DirectiveTree) +OSTREAM_DUMP(DirectiveTree::Chunk) +OSTREAM_DUMP(DirectiveTree::Directive) +OSTREAM_DUMP(DirectiveTree::Conditional) +OSTREAM_DUMP(DirectiveTree::Code) #undef OSTREAM_DUMP namespace { @@ -223,7 +223,7 @@ class BranchChooser { public: BranchChooser(const TokenStream &Code) : Code(Code) {} - void choose(DirectiveMap &M) { walk(M); } + void choose(DirectiveTree &M) { walk(M); } private: // Describes code seen by making particular branch choices. Higher is better. @@ -246,7 +246,7 @@ class BranchChooser { } }; - Score walk(DirectiveMap::Code &C) { + Score walk(DirectiveTree::Code &C) { Score S; for (const Token &T : Code.tokens(C.Tokens)) if (T.Kind != tok::comment) @@ -254,35 +254,35 @@ class BranchChooser { return S; } - Score walk(DirectiveMap::Directive &D) { + Score walk(DirectiveTree::Directive &D) { Score S; S.Directives = 1; S.Errors = D.Kind == tok::pp_error; return S; } - Score walk(DirectiveMap::Chunk &C) { + Score walk(DirectiveTree::Chunk &C) { switch (C.kind()) { - case DirectiveMap::Chunk::K_Code: - return walk((DirectiveMap::Code &)C); - case DirectiveMap::Chunk::K_Directive: - return walk((DirectiveMap::Directive &)C); - case DirectiveMap::Chunk::K_Conditional: - return walk((DirectiveMap::Conditional &)C); - case DirectiveMap::Chunk::K_Empty: + case DirectiveTree::Chunk::K_Code: + return walk((DirectiveTree::Code &)C); + case DirectiveTree::Chunk::K_Directive: + return walk((DirectiveTree::Directive &)C); + case DirectiveTree::Chunk::K_Conditional: + return walk((DirectiveTree::Conditional &)C); + case DirectiveTree::Chunk::K_Empty: break; } llvm_unreachable("bad chunk kind"); } - Score walk(DirectiveMap &M) { + Score walk(DirectiveTree &M) { Score S; - for (DirectiveMap::Chunk &C : M.Chunks) + for (DirectiveTree::Chunk &C : M.Chunks) S += walk(C); return S; } - Score walk(DirectiveMap::Conditional &C) { + Score walk(DirectiveTree::Conditional &C) { Score Best; bool MayTakeTrivial = true; bool TookTrivial = false; @@ -314,7 +314,7 @@ class BranchChooser { // Return true if the directive starts an always-taken conditional branch, // false if the branch is never taken, and None otherwise. - llvm::Optional<bool> isTakenWhenReached(const DirectiveMap::Directive &Dir) { + llvm::Optional<bool> isTakenWhenReached(const DirectiveTree::Directive &Dir) { switch (Dir.Kind) { case clang::tok::pp_if: case clang::tok::pp_elif: @@ -343,8 +343,8 @@ class BranchChooser { } // namespace -void chooseConditionalBranches(DirectiveMap &Map, const TokenStream &Code) { - BranchChooser{Code}.choose(Map); +void chooseConditionalBranches(DirectiveTree &Tree, const TokenStream &Code) { + BranchChooser{Code}.choose(Tree); } } // namespace pseudo diff --git a/clang-tools-extra/pseudo/test/lex.c b/clang-tools-extra/pseudo/test/lex.c index 0bba84c91f405..c1bf9296a8cce 100644 --- a/clang-tools-extra/pseudo/test/lex.c +++ b/clang-tools-extra/pseudo/test/lex.c @@ -39,14 +39,14 @@ TOKEN-NEXT: hash 5:0 "#" flags=1 TOKEN-NEXT: raw_identifier 5:0 "endif" TOKEN-NEXT: r_brace 6:0 "}" flags=1 -RUN: clang-pseudo -source %s -print-directive-map | FileCheck %s -check-prefix=PPS --strict-whitespace - PPS: code (5 tokens) -PPS-NEXT: #ifndef (3 tokens) TAKEN -PPS-NEXT: code (4 tokens) -PPS-NEXT: #else (2 tokens) -PPS-NEXT: code (3 tokens) -PPS-NEXT: #endif (2 tokens) -PPS-NEXT: code (2 tokens) +RUN: clang-pseudo -source %s -print-directive-tree | FileCheck %s -check-prefix=PPT --strict-whitespace + PPT: code (5 tokens) +PPT-NEXT: #ifndef (3 tokens) TAKEN +PPT-NEXT: code (4 tokens) +PPT-NEXT: #else (2 tokens) +PPT-NEXT: code (3 tokens) +PPT-NEXT: #endif (2 tokens) +PPT-NEXT: code (2 tokens) ^ including this block comment *******************************************************************************/ diff --git a/clang-tools-extra/pseudo/tool/ClangPseudo.cpp b/clang-tools-extra/pseudo/tool/ClangPseudo.cpp index fd5eb60d5eb3d..deac9f2cca23f 100644 --- a/clang-tools-extra/pseudo/tool/ClangPseudo.cpp +++ b/clang-tools-extra/pseudo/tool/ClangPseudo.cpp @@ -6,7 +6,7 @@ // //===----------------------------------------------------------------------===// -#include "clang-pseudo/DirectiveMap.h" +#include "clang-pseudo/DirectiveTree.h" #include "clang-pseudo/Grammar.h" #include "clang-pseudo/LRGraph.h" #include "clang-pseudo/LRTable.h" @@ -33,7 +33,7 @@ static opt<std::string> Source("source", desc("Source file")); static opt<bool> PrintSource("print-source", desc("Print token stream")); static opt<bool> PrintTokens("print-tokens", desc("Print detailed token info")); static opt<bool> - PrintDirectiveMap("print-directive-map", + PrintDirectiveTree("print-directive-tree", desc("Print directive structure of source code")); static std::string readOrDie(llvm::StringRef Path) { @@ -74,10 +74,10 @@ int main(int argc, char *argv[]) { std::string Text = readOrDie(Source); clang::LangOptions LangOpts; // FIXME: use real options. auto Stream = clang::pseudo::lex(Text, LangOpts); - auto Structure = clang::pseudo::DirectiveMap::parse(Stream); + auto Structure = clang::pseudo::DirectiveTree::parse(Stream); clang::pseudo::chooseConditionalBranches(Structure, Stream); - if (PrintDirectiveMap) + if (PrintDirectiveTree) llvm::outs() << Structure; if (PrintSource) Stream.print(llvm::outs()); diff --git a/clang-tools-extra/pseudo/unittests/CMakeLists.txt b/clang-tools-extra/pseudo/unittests/CMakeLists.txt index 7b06e5bead519..6bc3dec26f2d5 100644 --- a/clang-tools-extra/pseudo/unittests/CMakeLists.txt +++ b/clang-tools-extra/pseudo/unittests/CMakeLists.txt @@ -4,7 +4,7 @@ set(LLVM_LINK_COMPONENTS add_custom_target(ClangPseudoUnitTests) add_unittest(ClangPseudoUnitTests ClangPseudoTests - DirectiveMapTest.cpp + DirectiveTreeTest.cpp ForestTest.cpp GrammarTest.cpp LRTableTest.cpp diff --git a/clang-tools-extra/pseudo/unittests/DirectiveMapTest.cpp b/clang-tools-extra/pseudo/unittests/DirectiveTreeTest.cpp similarity index 81% rename from clang-tools-extra/pseudo/unittests/DirectiveMapTest.cpp rename to clang-tools-extra/pseudo/unittests/DirectiveTreeTest.cpp index 010451fd7dc3f..476726c7fedc1 100644 --- a/clang-tools-extra/pseudo/unittests/DirectiveMapTest.cpp +++ b/clang-tools-extra/pseudo/unittests/DirectiveTreeTest.cpp @@ -1,4 +1,4 @@ -//===--- DirectiveMapTest.cpp ---------------------------------------------===// +//===--- DirectiveTreeTest.cpp --------------------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. @@ -6,7 +6,7 @@ // //===----------------------------------------------------------------------===// -#include "clang-pseudo/DirectiveMap.h" +#include "clang-pseudo/DirectiveTree.h" #include "clang-pseudo/Token.h" #include "clang/Basic/LangOptions.h" @@ -25,7 +25,7 @@ using testing::ElementsAre; using testing::Matcher; using testing::Pair; using testing::StrEq; -using Chunk = DirectiveMap::Chunk; +using Chunk = DirectiveTree::Chunk; MATCHER_P2(tokensAre, TS, Tokens, "tokens are " + std::string(Tokens)) { std::vector<llvm::StringRef> Texts; @@ -37,7 +37,7 @@ MATCHER_P2(tokensAre, TS, Tokens, "tokens are " + std::string(Tokens)) { MATCHER_P(chunkKind, K, "") { return arg.kind() == K; } -TEST(DirectiveMap, Parse) { +TEST(DirectiveTree, Parse) { LangOptions Opts; std::string Code = R"cpp( #include <foo.h> @@ -56,30 +56,30 @@ TEST(DirectiveMap, Parse) { )cpp"; TokenStream S = cook(lex(Code, Opts), Opts); - DirectiveMap PP = DirectiveMap::parse(S); + DirectiveTree PP = DirectiveTree::parse(S); ASSERT_THAT(PP.Chunks, ElementsAre(chunkKind(Chunk::K_Directive), chunkKind(Chunk::K_Code), chunkKind(Chunk::K_Conditional), chunkKind(Chunk::K_Code))); - EXPECT_THAT((const DirectiveMap::Directive &)PP.Chunks[0], + EXPECT_THAT((const DirectiveTree::Directive &)PP.Chunks[0], tokensAre(S, "# include < foo . h >")); - EXPECT_THAT((const DirectiveMap::Code &)PP.Chunks[1], + EXPECT_THAT((const DirectiveTree::Code &)PP.Chunks[1], tokensAre(S, "int main ( ) {")); - EXPECT_THAT((const DirectiveMap::Code &)PP.Chunks[3], tokensAre(S, "}")); + EXPECT_THAT((const DirectiveTree::Code &)PP.Chunks[3], tokensAre(S, "}")); - const DirectiveMap::Conditional &Ifdef(PP.Chunks[2]); + const DirectiveTree::Conditional &Ifdef(PP.Chunks[2]); EXPECT_THAT(Ifdef.Branches, ElementsAre(Pair(tokensAre(S, "# ifdef HAS_FOO"), _), Pair(tokensAre(S, "# elif NEEDS_FOO"), _))); EXPECT_THAT(Ifdef.End, tokensAre(S, "# endif")); - const DirectiveMap &HasFoo(Ifdef.Branches[0].second); - const DirectiveMap &NeedsFoo(Ifdef.Branches[1].second); + const DirectiveTree &HasFoo(Ifdef.Branches[0].second); + const DirectiveTree &NeedsFoo(Ifdef.Branches[1].second); EXPECT_THAT(HasFoo.Chunks, ElementsAre(chunkKind(Chunk::K_Conditional))); - const DirectiveMap::Conditional &If(HasFoo.Chunks[0]); + const DirectiveTree::Conditional &If(HasFoo.Chunks[0]); EXPECT_THAT(If.Branches, ElementsAre(Pair(tokensAre(S, "# if HAS_BAR"), _), Pair(tokensAre(S, "# else"), _))); EXPECT_THAT(If.Branches[0].second.Chunks, @@ -88,12 +88,12 @@ TEST(DirectiveMap, Parse) { ElementsAre(chunkKind(Chunk::K_Code))); EXPECT_THAT(NeedsFoo.Chunks, ElementsAre(chunkKind(Chunk::K_Directive))); - const DirectiveMap::Directive &Error(NeedsFoo.Chunks[0]); + const DirectiveTree::Directive &Error(NeedsFoo.Chunks[0]); EXPECT_THAT(Error, tokensAre(S, "# error missing_foo")); EXPECT_EQ(Error.Kind, tok::pp_error); } -TEST(DirectiveMap, ParseUgly) { +TEST(DirectiveTree, ParseUgly) { LangOptions Opts; std::string Code = R"cpp( /*A*/ # /*B*/ \ @@ -103,19 +103,19 @@ BAR /*D*/ /*E*/ )cpp"; TokenStream S = cook(lex(Code, Opts), Opts); - DirectiveMap PP = DirectiveMap::parse(S); + DirectiveTree PP = DirectiveTree::parse(S); ASSERT_THAT(PP.Chunks, ElementsAre(chunkKind(Chunk::K_Code), chunkKind(Chunk::K_Directive), chunkKind(Chunk::K_Code))); - EXPECT_THAT((const DirectiveMap::Code &)PP.Chunks[0], tokensAre(S, "/*A*/")); - const DirectiveMap::Directive &Define(PP.Chunks[1]); + EXPECT_THAT((const DirectiveTree::Code &)PP.Chunks[0], tokensAre(S, "/*A*/")); + const DirectiveTree::Directive &Define(PP.Chunks[1]); EXPECT_EQ(Define.Kind, tok::pp_define); EXPECT_THAT(Define, tokensAre(S, "# /*B*/ /*C*/ define BAR /*D*/")); - EXPECT_THAT((const DirectiveMap::Code &)PP.Chunks[2], tokensAre(S, "/*E*/")); + EXPECT_THAT((const DirectiveTree::Code &)PP.Chunks[2], tokensAre(S, "/*E*/")); } -TEST(DirectiveMap, ParseBroken) { +TEST(DirectiveTree, ParseBroken) { LangOptions Opts; std::string Code = R"cpp( a @@ -124,17 +124,17 @@ TEST(DirectiveMap, ParseBroken) { b )cpp"; TokenStream S = cook(lex(Code, Opts), Opts); - DirectiveMap PP = DirectiveMap::parse(S); + DirectiveTree PP = DirectiveTree::parse(S); ASSERT_THAT(PP.Chunks, ElementsAre(chunkKind(Chunk::K_Code), chunkKind(Chunk::K_Directive), chunkKind(Chunk::K_Conditional))); - EXPECT_THAT((const DirectiveMap::Code &)PP.Chunks[0], tokensAre(S, "a")); - const DirectiveMap::Directive &Endif(PP.Chunks[1]); + EXPECT_THAT((const DirectiveTree::Code &)PP.Chunks[0], tokensAre(S, "a")); + const DirectiveTree::Directive &Endif(PP.Chunks[1]); EXPECT_EQ(Endif.Kind, tok::pp_endif); EXPECT_THAT(Endif, tokensAre(S, "# endif // mismatched")); - const DirectiveMap::Conditional &X(PP.Chunks[2]); + const DirectiveTree::Conditional &X(PP.Chunks[2]); EXPECT_EQ(1u, X.Branches.size()); // The (only) branch of the broken conditional section runs until eof. EXPECT_EQ(tok::pp_if, X.Branches.front().first.Kind); @@ -145,7 +145,7 @@ TEST(DirectiveMap, ParseBroken) { EXPECT_EQ(0u, X.End.Tokens.size()); } -TEST(DirectiveMap, ChooseBranches) { +TEST(DirectiveTree, ChooseBranches) { LangOptions Opts; const std::string Cases[] = { R"cpp( @@ -280,12 +280,12 @@ TEST(DirectiveMap, ChooseBranches) { for (const auto &Code : Cases) { TokenStream S = cook(lex(Code, Opts), Opts); - std::function<void(const DirectiveMap &)> Verify = - [&](const DirectiveMap &M) { + std::function<void(const DirectiveTree &)> Verify = + [&](const DirectiveTree &M) { for (const auto &C : M.Chunks) { - if (C.kind() != DirectiveMap::Chunk::K_Conditional) + if (C.kind() != DirectiveTree::Chunk::K_Conditional) continue; - const DirectiveMap::Conditional &Cond(C); + const DirectiveTree::Conditional &Cond(C); for (unsigned I = 0; I < Cond.Branches.size(); ++I) { auto Directive = S.tokens(Cond.Branches[I].first.Tokens); EXPECT_EQ(I == Cond.Taken, Directive.back().text() == "// TAKEN") @@ -295,9 +295,9 @@ TEST(DirectiveMap, ChooseBranches) { } }; - DirectiveMap Map = DirectiveMap::parse(S); - chooseConditionalBranches(Map, S); - Verify(Map); + DirectiveTree Tree = DirectiveTree::parse(S); + chooseConditionalBranches(Tree, S); + Verify(Tree); } } _______________________________________________ cfe-commits mailing list cfe-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits