Add 'detailed-ast' output as an alias for 'dump'

[steveire]

Summary

Future development can then dump other content than AST.

[steveire]

Format

[steveire]

Update tests

[aaron.ballman]

LGTM with some fixes to the wording.

clang-query/Query.cpp

57

Add full stop at the end of the sentence.

59

Typo: deatiled -> detailed

clang-query/QueryParser.cpp

119

This is reasonable, but as you add new output modes, hopefully this list won't need to be duplicated from above.

clang-query/Query.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_Dump };
+enum OutputKind { OK_Diag, OK_Print, OK_DetailedAST };
 
 enum QueryKind {
   QK_Invalid,
   QK_NoOp,
   QK_Help,
   QK_Let,
   QK_Match,
   QK_SetBool,

clang-query/Query.cpp

OS << "Available commands:\n\n"
         "  quit, q                           "
         "Terminates the query session.\n\n"
         "Several commands accept a <feature> parameter. The available features "
         "are:\n\n"
         "  print                             "
         "Pretty-print bound nodes.\n"
         "  diag                              "
         "Diagnostic location for bound nodes.\n"
+        "  detailed-ast                      "
+        "Detailed AST output for bound nodes.\n"
         "  dump                              "
-        "Detailed AST output for bound nodes.\n\n";
+        "Detailed AST output for bound nodes (alias of detailed-ast).\n\n";
   return true;
 }
 
 bool QuitQuery::run(llvm::raw_ostream &OS, QuerySession &QS) const {
   QS.Terminate = true;
   return true;
 }
 
for (auto MI = Matches.begin(), ME = Matches.end(); MI != ME; ++MI) {
           break;
         }
         case OK_Print: {
           OS << "Binding for \"" << BI->first << "\":\n";
           BI->second.print(OS, AST->getASTContext().getPrintingPolicy());
           OS << "\n";
           break;
         }
-        case OK_Dump: {
+        case OK_DetailedAST: {
           OS << "Binding for \"" << BI->first << "\":\n";
           BI->second.dump(OS, AST->getSourceManager());
           OS << "\n";
           break;
         }
         }
       }
 

clang-query/QueryParser.cpp

QueryRef QueryParser::parseSetBool(bool QuerySession::*Var) {
   return new SetQuery<bool>(Var, Value);
 }
 
 QueryRef QueryParser::parseSetOutputKind() {
   StringRef ValStr;
   unsigned OutKind = LexOrCompleteWord<unsigned>(this, ValStr)
                          .Case("diag", OK_Diag)
                          .Case("print", OK_Print)
-                         .Case("dump", OK_Dump)
+                         .Case("detailed-ast", OK_DetailedAST)
+                         .Case("dump", OK_DetailedAST)
                          .Default(~0u);
   if (OutKind == ~0u) {
-    return new InvalidQuery("expected 'diag', 'print' or 'dump', got '" +
-                            ValStr + "'");
+    return new InvalidQuery(
+        "expected 'diag', 'print', 'detailed-ast' or 'dump', got '" + ValStr +
+        "'");
   }
   return new SetQuery<OutputKind>(&QuerySession::OutKind, OutputKind(OutKind));
 }
 
 QueryRef QueryParser::endQuery(QueryRef Q) {
   const char *Extra = Begin;
   if (!lexWord().empty())
     return new InvalidQuery("unexpected extra input: '" +

unittests/clang-query/QueryEngineTest.cpp

EXPECT_TRUE(
       SetQuery<OutputKind>(&QuerySession::OutKind, OK_Print).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_Dump).run(OS, S));
+  EXPECT_TRUE(
+      SetQuery<OutputKind>(&QuerySession::OutKind, OK_DetailedAST).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("expected variable name", cast<InvalidQuery>(Q)->ErrStr);
 
   Q = parse("set foo bar");
   ASSERT_TRUE(isa<InvalidQuery>(Q));
   EXPECT_EQ("unknown variable: 'foo'", cast<InvalidQuery>(Q)->ErrStr);
 
   Q = parse("set output");
   ASSERT_TRUE(isa<InvalidQuery>(Q));
-  EXPECT_EQ("expected 'diag', 'print' or 'dump', got ''",
+  EXPECT_EQ("expected 'diag', 'print', 'detailed-ast' or 'dump', got ''",
             cast<InvalidQuery>(Q)->ErrStr);
 
   Q = parse("set bind-root true foo");
   ASSERT_TRUE(isa<InvalidQuery>(Q));
   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' or 'dump', got 'foo'",
+  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_Dump, cast<SetQuery<OutputKind> >(Q)->Value);
+  EXPECT_EQ(OK_DetailedAST, cast<SetQuery<OutputKind>>(Q)->Value);
+
+  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);
 
   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));