[pseudo] Use C++17 variant to simplify the DirectiveTree::Chunk class, NFC.

[sammccall]

Nice!

clang-tools-extra/pseudo/lib/DirectiveTree.cpp

187

Or Dumper{OS}(T)

212–213

walk/choose seem redundant now, inline?

clang-tools-extra/pseudo/unittests/DirectiveTreeTest.cpp

47–55

nit: directiveChunk() etc would be more natural, matching adjective order in English

124

Nit: I'd always use auto& with std::get as the type is obvious

[hokein]

address comments.

clang-tools-extra/pseudo/include/clang-pseudo/DirectiveTree.h

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef CLANG_PSEUDO_DIRECTIVETREE_H
 #define CLANG_PSEUDO_DIRECTIVETREE_H
 
 #include "clang-pseudo/Token.h"
 #include "clang/Basic/TokenKinds.h"
+#include <variant>
 #include <vector>
 
 namespace clang {
 class LangOptions;
 namespace pseudo {
 
 /// Describes the structure of a source file, as seen by the preprocessor.
 ///
struct Conditional {
     /// The index of the conditional branch we chose as active.
     /// None indicates no branch was taken (e.g. #if 0 ... #endif).
     /// The initial tree from `parse()` has no branches marked as taken.
     /// See `chooseConditionalBranches()`.
     llvm::Optional<unsigned> Taken;
   };
 
   /// Some piece of the file. {One of Code, Directive, Conditional}.
-  class Chunk; // Defined below.
+  using Chunk = std::variant<Code, Directive, Conditional>;
   std::vector<Chunk> Chunks;
 
   /// Extract preprocessor structure by examining the raw tokens.
   static DirectiveTree parse(const TokenStream &);
 
   /// Produce a parseable token stream by stripping all directive tokens.
   ///
   /// Conditional sections are replaced by the taken branch, if any.
   /// This tree must describe the provided token stream.
   TokenStream stripDirectives(const TokenStream &) const;
 };
 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 DirectiveTree::Directive &);
 llvm::raw_ostream &operator<<(llvm::raw_ostream &,
                               const DirectiveTree::Conditional &);
 
 /// Selects a "taken" branch for each conditional directive in the file.
 ///
 /// The choice is somewhat arbitrary, but aims to produce a useful parse:
 ///  - idioms like `#if 0` are respected
 ///  - we avoid paths that reach `#error`
 ///  - we try to maximize the amount of code seen
 /// The choice may also be "no branch taken".
 ///
 /// Choices are also made for conditionals themselves inside not-taken branches:
 ///   #if 1 // taken!
 ///   #else // not taken
 ///      #if 1 // taken!
 ///      #endif
 ///   #endif
 ///
 /// The choices are stored in Conditional::Taken nodes.
 void chooseConditionalBranches(DirectiveTree &, const TokenStream &Code);
 
-// FIXME: This approximates std::variant<Code, Directive, Conditional>.
-//         Switch once we can use C++17.
-class DirectiveTree::Chunk {
-public:
-  enum Kind { K_Empty, K_Code, K_Directive, K_Conditional };
-  Kind kind() const {
-    return CodeVariant          ? K_Code
-           : DirectiveVariant   ? K_Directive
-           : ConditionalVariant ? K_Conditional
-                                : K_Empty;
-  }
-
-  Chunk() = delete;
-  Chunk(const Chunk &) = delete;
-  Chunk(Chunk &&) = default;
-  Chunk &operator=(const Chunk &) = delete;
-  Chunk &operator=(Chunk &&) = default;
-  ~Chunk() = default;
-
-  // T => Chunk constructor.
-  Chunk(Code C) : CodeVariant(std::move(C)) {}
-  Chunk(Directive C) : DirectiveVariant(std::move(C)) {}
-  Chunk(Conditional C) : ConditionalVariant(std::move(C)) {}
-
-  // Chunk => T& and const T& conversions.
-#define CONVERSION(CONST, V)                                                   \
-  explicit operator CONST V &() CONST { return *V##Variant; }
-  CONVERSION(const, Code);
-  CONVERSION(, Code);
-  CONVERSION(const, Directive);
-  CONVERSION(, Directive);
-  CONVERSION(const, Conditional);
-  CONVERSION(, Conditional);
-#undef CONVERSION
-
-private:
-  // Wasteful, a union variant would be better!
-  llvm::Optional<Code> CodeVariant;
-  llvm::Optional<Directive> DirectiveVariant;
-  llvm::Optional<Conditional> ConditionalVariant;
-};
-
 } // namespace pseudo
 } // namespace clang
 
 #endif // CLANG_PSEUDO_DIRECTIVETREE_H

clang-tools-extra/pseudo/lib/DirectiveTree.cpp

 //===--- 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.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "clang-pseudo/DirectiveTree.h"
 #include "clang/Basic/IdentifierTable.h"
 #include "clang/Basic/TokenKinds.h"
 #include "llvm/Support/FormatVariadic.h"
+#include <variant>
 
 namespace clang {
 namespace pseudo {
 namespace {
 
 class DirectiveParser {
 public:
   explicit DirectiveParser(const TokenStream &Code)
if (!Tokens.empty())
       D->Kind = PPKeywords.get(Tokens.front().text()).getPPKeywordID();
   }
 
   const TokenStream &Code;
   const Token *Tok;
   clang::IdentifierTable PPKeywords;
 };
 
-} // namespace
+struct Dumper {
+  llvm::raw_ostream &OS;
+  unsigned Indent = 0;
 
-DirectiveTree DirectiveTree::parse(const TokenStream &Code) {
-  DirectiveTree Result;
-  DirectiveParser(Code).parse(&Result);
-  return Result;
-}
-
-static void dump(llvm::raw_ostream &OS, const DirectiveTree &, unsigned Indent);
-static void dump(llvm::raw_ostream &OS,
-                 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" : "");
+  Dumper(llvm::raw_ostream& OS) : OS(OS) {}
+  void operator()(const DirectiveTree& Tree) {
+    for (const auto& Chunk : Tree.Chunks)
+      std::visit(*this, Chunk);
   }
-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 DirectiveTree::Conditional &Conditional,
-                 unsigned Indent) {
+  void operator()(const DirectiveTree::Conditional &Conditional) {
     for (unsigned I = 0; I < Conditional.Branches.size(); ++I) {
       const auto &Branch = Conditional.Branches[I];
-    dump(OS, Branch.first, Indent, Conditional.Taken == I);
-    dump(OS, Branch.second, Indent + 2);
+      (*this)(Branch.first, Conditional.Taken == I);
+      Indent += 2;
+      (*this)(Branch.second);
+      Indent -= 2;
     }
-  dump(OS, Conditional.End, Indent);
+    (*this)(Conditional.End);
   }
-
-static void dump(llvm::raw_ostream &OS, const DirectiveTree::Chunk &Chunk,
-                 unsigned Indent) {
-  switch (Chunk.kind()) {
-  case DirectiveTree::Chunk::K_Empty:
-    llvm_unreachable("invalid chunk");
-  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);
+  void operator()(const DirectiveTree::Directive &Directive,
+                  bool Taken = false) {
+    OS.indent(Indent) << llvm::formatv(
+        "#{0} ({1} tokens){2}\n", tok::getPPKeywordSpelling(Directive.Kind),
+        Directive.Tokens.size(), Taken ? " TAKEN" : "");
   }
+  void operator()(const DirectiveTree::Code &Code) {
+    OS.indent(Indent) << llvm::formatv("code ({0} tokens)\n",
+                                       Code.Tokens.size());
   }
+};
+} // namespace
 
-static void dump(llvm::raw_ostream &OS, const DirectiveTree &Tree,
-                 unsigned Indent) {
-  for (const auto &Chunk : Tree.Chunks)
-    dump(OS, Chunk, Indent);
+DirectiveTree DirectiveTree::parse(const TokenStream &Code) {
+  DirectiveTree Result;
+  DirectiveParser(Code).parse(&Result);
+  return Result;
 }
 
 // Define operator<< in terms of dump() functions above.
 #define OSTREAM_DUMP(Type)                                                     \
   llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const Type &T) {        \
-    dump(OS, T, 0);                                                            \
+    Dumper{OS}(T);                                                         \
     return OS;                                                                 \
   }
 OSTREAM_DUMP(DirectiveTree)
-OSTREAM_DUMP(DirectiveTree::Chunk)
 OSTREAM_DUMP(DirectiveTree::Directive)
 OSTREAM_DUMP(DirectiveTree::Conditional)
 OSTREAM_DUMP(DirectiveTree::Code)
 #undef OSTREAM_DUMP
 
 namespace {
 // Makes choices about conditional branches.
 //
 // Generally it tries to maximize the amount of useful code we see.
 //
 // Caveat: each conditional is evaluated independently. Consider this code:
 //   #ifdef WINDOWS
 //     bool isWindows = true;
 //   #endif
 //   #ifndef WINDOWS
 //     bool isWindows = false;
 //   #endif
 // We take both branches and define isWindows twice. We could track more state
 // in order to produce a consistent view, but this is complex.
 class BranchChooser {
 public:
   BranchChooser(const TokenStream &Code) : Code(Code) {}
 
-  void choose(DirectiveTree &M) { walk(M); }
-
-private:
   // Describes code seen by making particular branch choices. Higher is better.
   struct Score {
     int Tokens = 0; // excluding comments and directives
     int Directives = 0;
     int Errors = 0; // #error directives
 
     bool operator>(const Score &Other) const {
       // Seeing errors is bad, other things are good.
       return std::make_tuple(-Errors, Tokens, Directives) >
              std::make_tuple(-Other.Errors, Other.Tokens, Other.Directives);
     }
 
     Score &operator+=(const Score &Other) {
       Tokens += Other.Tokens;
       Directives += Other.Directives;
       Errors += Other.Errors;
       return *this;
     }
   };
 
-  Score walk(DirectiveTree::Code &C) {
+  Score operator()(DirectiveTree::Code &C) {
     Score S;
     for (const Token &T : Code.tokens(C.Tokens))
       if (T.Kind != tok::comment)
         ++S.Tokens;
     return S;
   }
 
-  Score walk(DirectiveTree::Directive &D) {
+  Score operator()(DirectiveTree::Directive &D) {
     Score S;
     S.Directives = 1;
     S.Errors = D.Kind == tok::pp_error;
     return S;
   }
 
-  Score walk(DirectiveTree::Chunk &C) {
-    switch (C.kind()) {
-    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(DirectiveTree &M) {
-    Score S;
-    for (DirectiveTree::Chunk &C : M.Chunks)
-      S += walk(C);
-    return S;
-  }
-
-  Score walk(DirectiveTree::Conditional &C) {
+  Score operator()(DirectiveTree::Conditional &C) {
     Score Best;
     bool MayTakeTrivial = true;
     bool TookTrivial = false;
 
     for (unsigned I = 0; I < C.Branches.size(); ++I) {
       // Walk the branch to make its nested choices in any case.
       Score BranchScore = walk(C.Branches[I].second);
       // If we already took an #if 1, don't consider any other branches.
for (unsigned I = 0; I < C.Branches.size(); ++I) {
       // Is this the best branch so far? (Including if it's #if 1).
       if (TookTrivial || !C.Taken || BranchScore > Best) {
         Best = BranchScore;
         C.Taken = I;
       }
     }
     return Best;
   }
+  Score walk(DirectiveTree &M) {
+    Score S;
+    for (auto &C : M.Chunks)
+      S += std::visit(*this, C);
+    return S;
+  }
 
+private:
   // 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 DirectiveTree::Directive &Dir) {
     switch (Dir.Kind) {
     case clang::tok::pp_if:
     case clang::tok::pp_elif:
       break; // handled below
     case clang::tok::pp_else:
private:
   }
 
   const TokenStream &Code;
 };
 
 } // namespace
 
 void chooseConditionalBranches(DirectiveTree &Tree, const TokenStream &Code) {
-  BranchChooser{Code}.choose(Tree);
+  BranchChooser{Code}.walk(Tree);
 }
 
 namespace {
 class Preprocessor {
   const TokenStream &In;
   TokenStream &Out;
 
 public:
   Preprocessor(const TokenStream &In, TokenStream &Out) : In(In), Out(Out) {}
   ~Preprocessor() { Out.finalize(); }
 
   void walk(const DirectiveTree &T) {
     for (const auto &C : T.Chunks)
-      walk(C);
-  }
-
-  void walk(const DirectiveTree::Chunk &C) {
-    switch (C.kind()) {
-    case DirectiveTree::Chunk::K_Code:
-      return walk((const DirectiveTree::Code &)C);
-    case DirectiveTree::Chunk::K_Directive:
-      return walk((const DirectiveTree::Directive &)C);
-    case DirectiveTree::Chunk::K_Conditional:
-      return walk((const DirectiveTree::Conditional &)C);
-    case DirectiveTree::Chunk::K_Empty:
-      break;
-    }
-    llvm_unreachable("bad chunk kind");
+      std::visit(*this, C);
   }
 
-  void walk(const DirectiveTree::Code &C) {
+  void operator()(const DirectiveTree::Code &C) {
     for (const auto &Tok : In.tokens(C.Tokens))
       Out.push(Tok);
   }
 
-  void walk(const DirectiveTree::Directive &) {}
+  void operator()(const DirectiveTree::Directive &) {}
 
-  void walk(const DirectiveTree::Conditional &C) {
+  void operator()(const DirectiveTree::Conditional &C) {
     if (C.Taken)
       walk(C.Branches[*C.Taken].second);
   }
 };
 } // namespace
 
 TokenStream DirectiveTree::stripDirectives(const TokenStream &In) const {
   TokenStream Out;
   Preprocessor(In, Out).walk(*this);
   return Out;
 }
 
 } // namespace pseudo
 } // namespace clang

clang-tools-extra/pseudo/unittests/DirectiveTreeTest.cpp

 
 // Matches tokens covered a directive chunk (with a Tokens property) against a
 // string, similar to tokens() above.
 // e.g. EXPECT_THAT(SomeDirective, tokensAre(Stream, "# include < vector >"));
 MATCHER_P2(tokensAre, TS, Tokens, "tokens are " + std::string(Tokens)) {
   return testing::Matches(tokens(Tokens))(TS.tokens(arg.Tokens));
 }
 
-MATCHER_P(chunkKind, K, "") { return arg.kind() == K; }
+MATCHER(directiveChunk, "") {
+  return std::holds_alternative<DirectiveTree::Directive>(arg);
+}
+MATCHER(codeChunk, "") {
+  return std::holds_alternative<DirectiveTree::Code>(arg);
+}
+MATCHER(conditionalChunk, "") {
+  return std::holds_alternative<DirectiveTree::Conditional>(arg);
+}
 
 TEST(DirectiveTree, Parse) {
   LangOptions Opts;
   std::string Code = R"cpp(
   #include <foo.h>
 
   int main() {
   #ifdef HAS_FOO
   #if HAS_BAR
     foo(bar);
   #else
     foo(0)
   #endif
   #elif NEEDS_FOO
     #error missing_foo
   #endif
   }
   )cpp";
 
   TokenStream S = cook(lex(Code, Opts), Opts);
   DirectiveTree PP = DirectiveTree::parse(S);
+  ASSERT_THAT(PP.Chunks, ElementsAre(directiveChunk(), codeChunk(),
+                                     conditionalChunk(), codeChunk()));
 
-  ASSERT_THAT(PP.Chunks, ElementsAre(chunkKind(Chunk::K_Directive),
-                                     chunkKind(Chunk::K_Code),
-                                     chunkKind(Chunk::K_Conditional),
-                                     chunkKind(Chunk::K_Code)));
-
-  EXPECT_THAT((const DirectiveTree::Directive &)PP.Chunks[0],
+  EXPECT_THAT(std::get<DirectiveTree::Directive>(PP.Chunks[0]),
               tokensAre(S, "# include < foo . h >"));
-  EXPECT_THAT((const DirectiveTree::Code &)PP.Chunks[1],
+  EXPECT_THAT(std::get<DirectiveTree::Code>(PP.Chunks[1]),
               tokensAre(S, "int main ( ) {"));
-  EXPECT_THAT((const DirectiveTree::Code &)PP.Chunks[3], tokensAre(S, "}"));
+  EXPECT_THAT(std::get<DirectiveTree::Code>(PP.Chunks[3]), tokensAre(S, "}"));
 
-  const DirectiveTree::Conditional &Ifdef(PP.Chunks[2]);
+  const auto &Ifdef = std::get<DirectiveTree::Conditional>(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 DirectiveTree &HasFoo(Ifdef.Branches[0].second);
   const DirectiveTree &NeedsFoo(Ifdef.Branches[1].second);
 
-  EXPECT_THAT(HasFoo.Chunks, ElementsAre(chunkKind(Chunk::K_Conditional)));
-  const DirectiveTree::Conditional &If(HasFoo.Chunks[0]);
+  EXPECT_THAT(HasFoo.Chunks, ElementsAre(conditionalChunk()));
+  const auto &If = std::get<DirectiveTree::Conditional>(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,
-              ElementsAre(chunkKind(Chunk::K_Code)));
-  EXPECT_THAT(If.Branches[1].second.Chunks,
-              ElementsAre(chunkKind(Chunk::K_Code)));
+  EXPECT_THAT(If.Branches[0].second.Chunks, ElementsAre(codeChunk()));
+  EXPECT_THAT(If.Branches[1].second.Chunks, ElementsAre(codeChunk()));
 
-  EXPECT_THAT(NeedsFoo.Chunks, ElementsAre(chunkKind(Chunk::K_Directive)));
-  const DirectiveTree::Directive &Error(NeedsFoo.Chunks[0]);
+  EXPECT_THAT(NeedsFoo.Chunks, ElementsAre(directiveChunk()));
+  const auto &Error = std::get<DirectiveTree::Directive>(NeedsFoo.Chunks[0]);
   EXPECT_THAT(Error, tokensAre(S, "# error missing_foo"));
   EXPECT_EQ(Error.Kind, tok::pp_error);
 }
 
 TEST(DirectiveTree, ParseUgly) {
   LangOptions Opts;
   std::string Code = R"cpp(
   /*A*/ # /*B*/ \
    /*C*/ \
 define \
 BAR /*D*/
 /*E*/
 )cpp";
   TokenStream S = cook(lex(Code, Opts), Opts);
   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 DirectiveTree::Code &)PP.Chunks[0], tokensAre(S, "/*A*/"));
-  const DirectiveTree::Directive &Define(PP.Chunks[1]);
+  ASSERT_THAT(PP.Chunks,
+              ElementsAre(codeChunk(), directiveChunk(), codeChunk()));
+  EXPECT_THAT(std::get<DirectiveTree::Code>(PP.Chunks[0]),
+              tokensAre(S, "/*A*/"));
+  const auto &Define = std::get<DirectiveTree::Directive>(PP.Chunks[1]);
   EXPECT_EQ(Define.Kind, tok::pp_define);
   EXPECT_THAT(Define, tokensAre(S, "# /*B*/ /*C*/ define BAR /*D*/"));
-  EXPECT_THAT((const DirectiveTree::Code &)PP.Chunks[2], tokensAre(S, "/*E*/"));
+  EXPECT_THAT(std::get<DirectiveTree::Code>(PP.Chunks[2]),
+              tokensAre(S, "/*E*/"));
 }
 
 TEST(DirectiveTree, ParseBroken) {
   LangOptions Opts;
   std::string Code = R"cpp(
   a
   #endif // mismatched
   #if X
   b
 )cpp";
   TokenStream S = cook(lex(Code, Opts), Opts);
   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 DirectiveTree::Code &)PP.Chunks[0], tokensAre(S, "a"));
-  const DirectiveTree::Directive &Endif(PP.Chunks[1]);
+  ASSERT_THAT(PP.Chunks,
+              ElementsAre(codeChunk(), directiveChunk(), conditionalChunk()));
+  EXPECT_THAT(std::get<DirectiveTree::Code>(PP.Chunks[0]), tokensAre(S, "a"));
+  const auto &Endif = std::get<DirectiveTree::Directive>(PP.Chunks[1]);
   EXPECT_EQ(Endif.Kind, tok::pp_endif);
   EXPECT_THAT(Endif, tokensAre(S, "# endif // mismatched"));
 
-  const DirectiveTree::Conditional &X(PP.Chunks[2]);
+  const auto &X = std::get<DirectiveTree::Conditional>(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);
-  EXPECT_THAT(X.Branches.front().second.Chunks,
-              ElementsAre(chunkKind(Chunk::K_Code)));
+  EXPECT_THAT(X.Branches.front().second.Chunks, ElementsAre(codeChunk()));
   // The missing terminating directive is marked as pp_not_keyword.
   EXPECT_EQ(tok::pp_not_keyword, X.End.Kind);
   EXPECT_EQ(0u, X.End.Tokens.size());
 }
 
 TEST(DirectiveTree, ChooseBranches) {
   LangOptions Opts;
   const std::string Cases[] = {
const std::string Cases[] = {
       )cpp",
   };
   for (const auto &Code : Cases) {
     TokenStream S = cook(lex(Code, Opts), Opts);
 
     std::function<void(const DirectiveTree &)> Verify =
         [&](const DirectiveTree &M) {
           for (const auto &C : M.Chunks) {
-            if (C.kind() != DirectiveTree::Chunk::K_Conditional)
+            if (!std::holds_alternative<DirectiveTree::Conditional>(C))
               continue;
-            const DirectiveTree::Conditional &Cond(C);
+            const DirectiveTree::Conditional &Cond =
+                std::get<DirectiveTree::Conditional>(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")
                   << "At line " << Directive.front().Line << " of: " << Code;
               Verify(Cond.Branches[I].second);
             }
           }
         };
TEST(DirectiveTree, StripDirectives) {
   TokenStream S = lex(Code, Opts);
 
   DirectiveTree Tree = DirectiveTree::parse(S);
   chooseConditionalBranches(Tree, S);
   EXPECT_THAT(Tree.stripDirectives(S).tokens(),
               tokens("a a a b b b c c c e e e f f f h h h j j j"));
 
   const DirectiveTree &Part =
-      ((const DirectiveTree::Conditional &)Tree.Chunks[4]).Branches[0].second;
+      std::get<DirectiveTree::Conditional>(Tree.Chunks[4]).Branches[0].second;
   EXPECT_THAT(Part.stripDirectives(S).tokens(),
               tokens("c c c e e e f f f h h h"));
 }
 
 } // namespace
 } // namespace pseudo
 } // namespace clang