[clang-query] Refactor Output settings to booleans

[steveire]

Summary

This will make it possible to add non-exclusive mode output.

[steveire]

Update tests

[aaron.ballman]

LGTM aside from minor commenting nits.

clang-query/Query.h

17

Spurious newline, or did clang-format insert this?

138

Missing full-stop at the end of the comment.

clang-query/Query.h

 //===--- Query.h - clang-query ----------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_QUERY_QUERY_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_QUERY_QUERY_H
 
+#include "QuerySession.h"
 #include "clang/ASTMatchers/Dynamic/VariantValue.h"
 #include "llvm/ADT/IntrusiveRefCntPtr.h"
 #include "llvm/ADT/Optional.h"
+
 #include <string>
 
 namespace clang {
 namespace query {
 
 enum OutputKind { OK_Diag, OK_Print, OK_DetailedAST };
 
 enum QueryKind {
template <typename T> struct SetQuery : Query {
   static bool classof(const Query *Q) {
     return Q->Kind == SetQueryKind<T>::value;
   }
 
   T QuerySession::*Var;
   T Value;
 };
 
+// Implements the exclusive 'set output dump|diag|print' options
+struct SetExclusiveOutputQuery : Query {
+  SetExclusiveOutputQuery(bool QuerySession::*Var)
+      : Query(QK_SetOutputKind), Var(Var) {}
+  bool run(llvm::raw_ostream &OS, QuerySession &QS) const override {
+    QS.DiagOutput = false;
+    QS.DetailedASTOutput = false;
+    QS.PrintOutput = false;
+    QS.*Var = true;
+    return true;
+  }
+
+  static bool classof(const Query *Q) { return Q->Kind == QK_SetOutputKind; }
+
+  bool QuerySession::*Var;
+};
+
 } // namespace query
 } // namespace clang
 
 #endif

clang-query/Query.cpp

if (QS.PrintMatcher) {
       OS << "  " << std::string(prefixText.size() + Source.size(), '=') << '\n';
     }
 
     for (auto MI = Matches.begin(), ME = Matches.end(); MI != ME; ++MI) {
       OS << "\nMatch #" << ++MatchCount << ":\n\n";
 
       for (auto BI = MI->getMap().begin(), BE = MI->getMap().end(); BI != BE;
            ++BI) {
-        switch (QS.OutKind) {
-        case OK_Diag: {
+        if (QS.DiagOutput) {
           clang::SourceRange R = BI->second.getSourceRange();
           if (R.isValid()) {
             TextDiagnostic TD(OS, AST->getASTContext().getLangOpts(),
                               &AST->getDiagnostics().getDiagnosticOptions());
             TD.emitDiagnostic(
                 FullSourceLoc(R.getBegin(), AST->getSourceManager()),
                 DiagnosticsEngine::Note, "\"" + BI->first + "\" binds here",
                 CharSourceRange::getTokenRange(R), None);
           }
-          break;
         }
-        case OK_Print: {
+        if (QS.PrintOutput) {
           OS << "Binding for \"" << BI->first << "\":\n";
           BI->second.print(OS, AST->getASTContext().getPrintingPolicy());
           OS << "\n";
-          break;
         }
-        case OK_DetailedAST: {
+        if (QS.DetailedASTOutput) {
           OS << "Binding for \"" << BI->first << "\":\n";
           BI->second.dump(OS, AST->getSourceManager());
           OS << "\n";
-          break;
-        }
         }
       }
 
       if (MI->getMap().empty())
         OS << "No bindings.\n";
     }
   }
 

clang-query/QueryParser.cpp

unsigned OutKind = LexOrCompleteWord<unsigned>(this, ValStr)
                          .Case("detailed-ast", OK_DetailedAST)
                          .Case("dump", OK_DetailedAST)
                          .Default(~0u);
   if (OutKind == ~0u) {
     return new InvalidQuery(
         "expected 'diag', 'print', 'detailed-ast' or 'dump', got '" + ValStr +
         "'");
   }
-  return new SetQuery<OutputKind>(&QuerySession::OutKind, OutputKind(OutKind));
+
+  switch (OutKind) {
+  case OK_DetailedAST:
+    return new SetExclusiveOutputQuery(&QuerySession::DetailedASTOutput);
+  case OK_Diag:
+    return new SetExclusiveOutputQuery(&QuerySession::DiagOutput);
+  case OK_Print:
+    return new SetExclusiveOutputQuery(&QuerySession::PrintOutput);
+  }
+
+  llvm_unreachable("Invalid output kind");
 }
 
 QueryRef QueryParser::endQuery(QueryRef Q) {
   const char *Extra = Begin;
   if (!lexWord().empty())
     return new InvalidQuery("unexpected extra input: '" +
                             StringRef(Extra, End - Extra) + "'");
   return Q;

clang-query/QuerySession.h

 class ASTUnit;
 
 namespace query {
 
 /// Represents the state for a particular clang-query session.
 class QuerySession {
 public:
   QuerySession(llvm::ArrayRef<std::unique_ptr<ASTUnit>> ASTs)
-      : ASTs(ASTs), OutKind(OK_Diag), BindRoot(true), PrintMatcher(false),
+      : ASTs(ASTs), PrintOutput(false), DiagOutput(true),
+        DetailedASTOutput(false), BindRoot(true), PrintMatcher(false),
         Terminate(false) {}
 
   llvm::ArrayRef<std::unique_ptr<ASTUnit>> ASTs;
-  OutputKind OutKind;
+
+  bool PrintOutput;
+  bool DiagOutput;
+  bool DetailedASTOutput;
+
   bool BindRoot;
   bool PrintMatcher;
   bool Terminate;
   llvm::StringMap<ast_matchers::dynamic::VariantValue> NamedValues;
 };
 
 } // namespace query
 } // namespace clang
 
 #endif

unittests/clang-query/QueryEngineTest.cpp

TEST_F(QueryEngineTest, Basic) {
 
   EXPECT_TRUE(OS.str().find("foo.cc:1:1: note: \"root\" binds here") !=
               std::string::npos);
   EXPECT_TRUE(OS.str().find("1 match.") != std::string::npos);
 
   Str.clear();
 
   EXPECT_TRUE(
-      SetQuery<OutputKind>(&QuerySession::OutKind, OK_Print).run(OS, S));
+      SetExclusiveOutputQuery(&QuerySession::PrintOutput).run(OS, S));
   EXPECT_TRUE(MatchQuery(FooMatcherString, FooMatcher).run(OS, S));
 
   EXPECT_TRUE(OS.str().find("Binding for \"root\":\nvoid foo1()") !=
               std::string::npos);
 
   Str.clear();
 
   EXPECT_TRUE(
-      SetQuery<OutputKind>(&QuerySession::OutKind, OK_DetailedAST).run(OS, S));
+      SetExclusiveOutputQuery(&QuerySession::DetailedASTOutput).run(OS, S));
   EXPECT_TRUE(MatchQuery(FooMatcherString, FooMatcher).run(OS, S));
 
   EXPECT_TRUE(OS.str().find("FunctionDecl") != std::string::npos);
 
   Str.clear();
 
   EXPECT_TRUE(SetQuery<bool>(&QuerySession::BindRoot, false).run(OS, S));
   EXPECT_TRUE(MatchQuery(FooMatcherString, FooMatcher).run(OS, S));

unittests/clang-query/QueryParserTest.cpp

TEST_F(QueryParserTest, Set) {
   EXPECT_EQ("unexpected extra input: ' foo'", cast<InvalidQuery>(Q)->ErrStr);
 
   Q = parse("set output foo");
   ASSERT_TRUE(isa<InvalidQuery>(Q));
   EXPECT_EQ("expected 'diag', 'print', 'detailed-ast' or 'dump', got 'foo'",
             cast<InvalidQuery>(Q)->ErrStr);
 
   Q = parse("set output dump");
-  ASSERT_TRUE(isa<SetQuery<OutputKind> >(Q));
-  EXPECT_EQ(&QuerySession::OutKind, cast<SetQuery<OutputKind> >(Q)->Var);
-  EXPECT_EQ(OK_DetailedAST, cast<SetQuery<OutputKind>>(Q)->Value);
+  ASSERT_TRUE(isa<SetExclusiveOutputQuery >(Q));
+  EXPECT_EQ(&QuerySession::DetailedASTOutput, cast<SetExclusiveOutputQuery>(Q)->Var);
 
   Q = parse("set output detailed-ast");
-  ASSERT_TRUE(isa<SetQuery<OutputKind>>(Q));
-  EXPECT_EQ(&QuerySession::OutKind, cast<SetQuery<OutputKind>>(Q)->Var);
-  EXPECT_EQ(OK_DetailedAST, cast<SetQuery<OutputKind>>(Q)->Value);
+  ASSERT_TRUE(isa<SetExclusiveOutputQuery>(Q));
+  EXPECT_EQ(&QuerySession::DetailedASTOutput, cast<SetExclusiveOutputQuery>(Q)->Var);
 
   Q = parse("set bind-root foo");
   ASSERT_TRUE(isa<InvalidQuery>(Q));
   EXPECT_EQ("expected 'true' or 'false', got 'foo'",
             cast<InvalidQuery>(Q)->ErrStr);
 
   Q = parse("set bind-root true");
   ASSERT_TRUE(isa<SetQuery<bool> >(Q));