Add new 'let' command to bind arbitrary values into constants.

[sbenza]

Summary

Add new 'let' command to bind arbitrary values into constants.
These constants can then be used in the matcher expressions.

[pcc]

clang-query/Query.cpp

131

Is this path reachable? If not, we should either remove it or come up with a command syntax for erasing named values.

clang-query/QueryParser.cpp

143

Can you keep these in alphabetical order, please?

192

Ditto.

clang-query/tool/ClangQuery.cpp

129

You could pass in a lambda here instead.

[sbenza]

Added unlet command. Minor fixes.

clang-query/Query.cpp

131

It was not reachable.
Added the 'unlet' command and updated all the tests for it.

clang-query/QueryParser.cpp

143

Done.
I assumed it wasn't ordered because NoOp is before Help.

192

Done.

clang-query/tool/ClangQuery.cpp

129

My bad. I assumed it needed a function pointer.
Fixed.

[pcc]

clang-query/Query.h

34

Sorry, missed this one -- alphabetical order, please.

clang-query/QueryParser.cpp

71

You could factor this code out into a completeWord function.

261

It would be nice to support completion for value names here.

267

Can you please use 'endQuery' here so that extra input causes an error?

[sbenza]

Minor fixes

clang-query/Query.h

34

Done.

clang-query/QueryParser.cpp

71

How would it help with this change?

261

Yes.
When I added the named values in dynamic::Parser I added a TODO for completion.
The Sema should provide completion for named values, which will allow for completion here and when building matchers.
My next change will add that to dynamic::Parser.

267

Done.

[pcc]

clang-query/Query.cpp

131

Sorry, one thing I forgot to mention before: is this the correct behavior if the value does not exist in the map? Should we be printing an error message in that case?

clang-query/QueryParser.cpp

71

I meant that it could help with implementing completion, but if you want to do that separately, that's fine.

261

OK, sounds good.

unittests/clang-query/QueryParserTest.cpp

123

Please also test that extra stuff after the unlet query causes an error.

[sbenza]

clang-query/Query.cpp

131

I don't know.
I would say it is not an error because the end state is the same as it would have been if it existed in the map.

unittests/clang-query/QueryParserTest.cpp

123

I'm sorry, but I don't know what extra stuff you are referring to.

[pcc]

clang-query/Query.cpp

131

That seems reasonable.

unittests/clang-query/QueryParserTest.cpp

123

Sorry if I wasn't clear. I meant that if for example the query was something like "unlet x foo" we should reject it because of the extra input "foo" at the end.

[sbenza]

Added another test for unlet

unittests/clang-query/QueryParserTest.cpp

123

Done.

[pcc]

unittests/clang-query/QueryEngineTest.cpp

139

Can you please move this test to QueryParserTest?

[sbenza]

Moved test case to QueryParserTest

[pcc]

LGTM

[sbenza]

Submitted as r206984

clang-query/Query.h

 };
 
 enum QueryKind {
   QK_Invalid,
   QK_NoOp,
   QK_Help,
   QK_Match,
   QK_SetBool,
-  QK_SetOutputKind
+  QK_SetOutputKind,
+  QK_Let,
 };
 
 class QuerySession;
 
 struct Query : llvm::RefCountedBase<Query> {
   Query(QueryKind Kind) : Kind(Kind) {}
   virtual ~Query();
 
MatchQuery(const ast_matchers::dynamic::DynTypedMatcher &Matcher)
       : Query(QK_Match), Matcher(Matcher) {}
   bool run(llvm::raw_ostream &OS, QuerySession &QS) const override;
 
   ast_matchers::dynamic::DynTypedMatcher Matcher;
 
   static bool classof(const Query *Q) { return Q->Kind == QK_Match; }
 };
 
+struct LetQuery : Query {
+  LetQuery(StringRef Name, const ast_matchers::dynamic::VariantValue &Value)
+      : Query(QK_Let), Name(Name), Value(Value) {}
+  bool run(llvm::raw_ostream &OS, QuerySession &QS) const override;
+
+  std::string Name;
+  ast_matchers::dynamic::VariantValue Value;
+
+  static bool classof(const Query *Q) { return Q->Kind == QK_Let; }
+};
+
 template <typename T> struct SetQueryKind {};
 
 template <> struct SetQueryKind<bool> {
   static const QueryKind value = QK_SetBool;
 };
 
 template <> struct SetQueryKind<OutputKind> {
   static const QueryKind value = QK_SetOutputKind;

clang-query/Query.cpp

 struct CollectBoundNodes : MatchFinder::MatchCallback {
   std::vector<BoundNodes> &Bindings;
   CollectBoundNodes(std::vector<BoundNodes> &Bindings) : Bindings(Bindings) {}
   void run(const MatchFinder::MatchResult &Result) {
     Bindings.push_back(Result.Nodes);
   }
 };
 
-}
+}  // namespace
 
 bool MatchQuery::run(llvm::raw_ostream &OS, QuerySession &QS) const {
   unsigned MatchCount = 0;
 
   for (llvm::ArrayRef<ASTUnit *>::iterator I = QS.ASTs.begin(),
                                            E = QS.ASTs.end();
        I != E; ++I) {
     ASTUnit *AST = *I;
for (std::vector<BoundNodes>::iterator MI = Matches.begin(),
         OS << "No bindings.\n";
     }
   }
 
   OS << MatchCount << (MatchCount == 1 ? " match.\n" : " matches.\n");
   return true;
 }
 
+bool LetQuery::run(llvm::raw_ostream &OS, QuerySession &QS) const {
+  if (Value) {
+    QS.NamedValues[Name] = Value;
+  } else {
+    QS.NamedValues.erase(Name);
+  }
+  return true;
+}
+
 #ifndef _MSC_VER
 const QueryKind SetQueryKind<bool>::value;
 const QueryKind SetQueryKind<OutputKind>::value;
 #endif
 
 } // namespace query
 } // namespace clang

clang-query/QueryParser.h

 //===--- QueryParser.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_PARSER_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_QUERY_QUERY_PARSER_H
 
 #include "Query.h"
+#include "QuerySession.h"
 #include "llvm/LineEditor/LineEditor.h"
 #include <stddef.h>
 
 namespace clang {
 namespace query {
 
 class QuerySession;
 
 class QueryParser {
 public:
   /// Parse \a Line as a query.
   ///
   /// \return A QueryRef representing the query, which may be an InvalidQuery.
-  static QueryRef parse(StringRef Line);
+  static QueryRef parse(StringRef Line, const QuerySession &QS);
 
   /// Compute a list of completions for \a Line assuming a cursor at
   /// \param Pos characters past the start of \a Line, ordered from most
   /// likely to least likely.
   ///
   /// \return A vector of completions for \a Line.
-  static std::vector<llvm::LineEditor::Completion> complete(StringRef Line,
-                                                            size_t Pos);
+  static std::vector<llvm::LineEditor::Completion>
+  complete(StringRef Line, size_t Pos, const QuerySession &QS);
 
 private:
-  QueryParser(StringRef Line)
-      : Begin(Line.data()), End(Line.data() + Line.size()), CompletionPos(0) {}
+  QueryParser(StringRef Line, const QuerySession &QS)
+      : Begin(Line.data()), End(Line.data() + Line.size()), CompletionPos(0),
+        QS(QS) {}
 
   StringRef lexWord();
 
   template <typename T> struct LexOrCompleteWord;
   template <typename T> LexOrCompleteWord<T> lexOrCompleteWord(StringRef &Str);
 
   QueryRef parseSetBool(bool QuerySession::*Var);
   QueryRef parseSetOutputKind();
+  QueryRef completeMatcherExpression();
 
   QueryRef endQuery(QueryRef Q);
 
   /// \brief Parse [\p Begin,\p End).
   ///
   /// \return A reference to the parsed query object, which may be an
   /// \c InvalidQuery if a parse error occurs.
   QueryRef doParse();
 
   const char *Begin;
   const char *End;
 
   const char *CompletionPos;
   std::vector<llvm::LineEditor::Completion> Completions;
+
+  const QuerySession &QS;
 };
 
 } // namespace query
 } // namespace clang
 
 #endif

clang-query/QueryParser.cpp

template <typename T> struct QueryParser::LexOrCompleteWord {
 
   template <unsigned N>
   LexOrCompleteWord &Case(const char (&S)[N], const T &Value,
                           bool IsCompletion = true) {
     StringRef CaseStr(S, N - 1);
 
     if (WordCompletionPos == StringRef::npos)
       Switch.Case(S, Value);
     else if (N != 1 && IsCompletion && WordCompletionPos <= CaseStr.size() &&
              CaseStr.substr(0, WordCompletionPos) ==
                  Word.substr(0, WordCompletionPos))
       P->Completions.push_back(LineEditor::Completion(
           (CaseStr.substr(WordCompletionPos) + " ").str(), CaseStr));
     return *this;
   }
 
   T Default(const T& Value) const {

 QueryRef QueryParser::endQuery(QueryRef Q) {
   const char *Extra = Begin;
   if (!lexWord().empty())
     return new InvalidQuery("unexpected extra input: '" +
                             StringRef(Extra, End - Extra) + "'");
   return Q;
 }
 
+namespace {
+
 enum ParsedQueryKind {
   PQK_Invalid,
   PQK_NoOp,
   PQK_Help,
   PQK_Match,
-  PQK_Set
+  PQK_Set,
+  PQK_Let,
 };
 
 enum ParsedQueryVariable {
   PQV_Invalid,
   PQV_Output,
   PQV_BindRoot
 };
 
+QueryRef makeInvalidQueryFromDiagnostics(const Diagnostics &Diag) {
+  std::string ErrStr;
+  llvm::raw_string_ostream OS(ErrStr);
+  Diag.printToStreamFull(OS);
+  return new InvalidQuery(OS.str());
+}
+
+class QuerySessionSema : public Parser::RegistrySema {
+public:
+  QuerySessionSema(const QuerySession &QS) : QS(QS) {}
+
+  ast_matchers::dynamic::VariantValue getNamedValue(StringRef Name) override {
+    return QS.NamedValues.lookup(Name);
+  }
+
+private:
+  const QuerySession &QS;
+};
+
+}  // namespace
+
+QueryRef QueryParser::completeMatcherExpression() {
+  std::vector<MatcherCompletion> Comps = Parser::completeExpression(
+      StringRef(Begin, End - Begin), CompletionPos - Begin);
+  for (std::vector<MatcherCompletion>::iterator I = Comps.begin(),
+                                                E = Comps.end();
+       I != E; ++I) {
+    Completions.push_back(LineEditor::Completion(I->TypedText, I->MatcherDecl));
+  }
+  return QueryRef();
+}
+
 QueryRef QueryParser::doParse() {
   StringRef CommandStr;
   ParsedQueryKind QKind = lexOrCompleteWord<ParsedQueryKind>(CommandStr)
                               .Case("", PQK_NoOp)
                               .Case("help", PQK_Help)
                               .Case("m", PQK_Match, /*IsCompletion=*/false)
                               .Case("match", PQK_Match)
                               .Case("set", PQK_Set)
+                              .Case("let", PQK_Let)
                               .Default(PQK_Invalid);
 
+  QuerySessionSema S(QS);
+
   switch (QKind) {
   case PQK_NoOp:
     return new NoOpQuery;
 
   case PQK_Help:
     return endQuery(new HelpQuery);
 
   case PQK_Match: {
     if (CompletionPos) {
-      std::vector<MatcherCompletion> Comps = Parser::completeExpression(
-          StringRef(Begin, End - Begin), CompletionPos - Begin);
-      for (std::vector<MatcherCompletion>::iterator I = Comps.begin(),
-                                                    E = Comps.end();
-           I != E; ++I) {
-        Completions.push_back(
-            LineEditor::Completion(I->TypedText, I->MatcherDecl));
-      }
-      return QueryRef();
+      return completeMatcherExpression();
     } else {
       Diagnostics Diag;
-      Optional<DynTypedMatcher> Matcher =
-          Parser::parseMatcherExpression(StringRef(Begin, End - Begin), &Diag);
+      Optional<DynTypedMatcher> Matcher = Parser::parseMatcherExpression(
+          StringRef(Begin, End - Begin), &S, &Diag);
       if (!Matcher) {
-        std::string ErrStr;
-        llvm::raw_string_ostream OS(ErrStr);
-        Diag.printToStreamFull(OS);
-        return new InvalidQuery(OS.str());
+        return makeInvalidQueryFromDiagnostics(Diag);
       }
       return new MatchQuery(*Matcher);
     }
   }
 
+  case PQK_Let: {
+    StringRef Name = lexWord();
+
+    if (CompletionPos) {
+      return completeMatcherExpression();
+    } else {
+      Diagnostics Diag;
+      ast_matchers::dynamic::VariantValue Value;
+      if (!Parser::parseExpression(StringRef(Begin, End - Begin), &S, &Value,
+                                   &Diag)) {
+        return makeInvalidQueryFromDiagnostics(Diag);
+      }
+
+      return new LetQuery(Name, Value);
+    }
+  }
+
   case PQK_Set: {
     StringRef VarStr;
     ParsedQueryVariable Var = lexOrCompleteWord<ParsedQueryVariable>(VarStr)
                                   .Case("output", PQV_Output)
                                   .Case("bind-root", PQV_BindRoot)
                                   .Default(PQV_Invalid);
     if (VarStr.empty())
       return new InvalidQuery("expected variable name");
case PQV_BindRoot:
       break;
     case PQV_Invalid:
       llvm_unreachable("Invalid query kind");
     }
 
     return endQuery(Q);
   }
 
   case PQK_Invalid:
     return new InvalidQuery("unknown command: " + CommandStr);
   }
 
   llvm_unreachable("Invalid query kind");
 }
 
-QueryRef QueryParser::parse(StringRef Line) {
-  return QueryParser(Line).doParse();
+QueryRef QueryParser::parse(StringRef Line, const QuerySession &QS) {
+  return QueryParser(Line, QS).doParse();
 }
 
-std::vector<LineEditor::Completion> QueryParser::complete(StringRef Line,
-                                                          size_t Pos) {
-  QueryParser P(Line);
+std::vector<LineEditor::Completion>
+QueryParser::complete(StringRef Line, size_t Pos, const QuerySession &QS) {
+  QueryParser P(Line, QS);
   P.CompletionPos = Line.data() + Pos;
 
   P.doParse();
   return P.Completions;
 }
 
 } // namespace query
 } // namespace clang

clang-query/QuerySession.h

 //===--- QuerySession.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_SESSION_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANG_QUERY_QUERY_SESSION_H
 
 #include "Query.h"
+#include "clang/ASTMatchers/Dynamic/VariantValue.h"
 #include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/StringMap.h"
 
 namespace clang {
 
 class ASTUnit;
 
 namespace query {
 
 /// Represents the state for a particular clang-query session.
 class QuerySession {
 public:
   QuerySession(llvm::ArrayRef<ASTUnit *> ASTs)
       : ASTs(ASTs), OutKind(OK_Diag), BindRoot(true) {}
 
   llvm::ArrayRef<ASTUnit *> ASTs;
   OutputKind OutKind;
   bool BindRoot;
+  llvm::StringMap<ast_matchers::dynamic::VariantValue> NamedValues;
 };
 
 } // namespace query
 } // namespace clang
 
 #endif

clang-query/tool/ClangQuery.cpp

 static cl::list<std::string> CommandFiles("f",
                                           cl::desc("Read commands from file"),
                                           cl::value_desc("<file>"));
 
 static cl::list<std::string> SourcePaths(cl::Positional,
                                          cl::desc("<source0> [... <sourceN>]"),
                                          cl::OneOrMore);
 
+const QuerySession *GlobalQS;
+static std::vector<llvm::LineEditor::Completion> complete(StringRef Line,
+                                                          size_t Pos) {
+  return QueryParser::complete(Line, Pos, *GlobalQS);
+}
+
 int main(int argc, const char **argv) {
   llvm::sys::PrintStackTraceOnErrorSignal();
   cl::ParseCommandLineOptions(argc, argv);
 
   if (!Commands.empty() && !CommandFiles.empty()) {
     llvm::errs() << argv[0] << ": cannot specify both -c and -f\n";
     return 1;
   }
int main(int argc, const char **argv) {
   }
 
   ClangTool Tool(*Compilations, SourcePaths);
   std::vector<ASTUnit *> ASTs;
   if (Tool.buildASTs(ASTs) != 0)
     return 1;
 
   QuerySession QS(ASTs);
+  GlobalQS = &QS;
 
   if (!Commands.empty()) {
     for (cl::list<std::string>::iterator I = Commands.begin(),
                                          E = Commands.end();
          I != E; ++I) {
-      QueryRef Q = QueryParser::parse(I->c_str());
+      QueryRef Q = QueryParser::parse(I->c_str(), QS);
       if (!Q->run(llvm::outs(), QS))
         return 1;
     }
   } else if (!CommandFiles.empty()) {
     for (cl::list<std::string>::iterator I = CommandFiles.begin(),
                                          E = CommandFiles.end();
          I != E; ++I) {
       std::ifstream Input(I->c_str());
       if (!Input.is_open()) {
         llvm::errs() << argv[0] << ": cannot open " << *I << "\n";
         return 1;
       }
       while (Input.good()) {
         std::string Line;
         std::getline(Input, Line);
 
-        QueryRef Q = QueryParser::parse(Line.c_str());
+        QueryRef Q = QueryParser::parse(Line.c_str(), QS);
         if (!Q->run(llvm::outs(), QS))
           return 1;
       }
     }
   } else {
     LineEditor LE("clang-query");
-    LE.setListCompleter(QueryParser::complete);
+    LE.setListCompleter(complete);
     while (llvm::Optional<std::string> Line = LE.readLine()) {
-      QueryRef Q = QueryParser::parse(*Line);
+      QueryRef Q = QueryParser::parse(*Line, QS);
       Q->run(llvm::outs(), QS);
     }
   }
 
   llvm::DeleteContainerPointers(ASTs);
 
   return 0;
 }

unittests/clang-query/QueryEngineTest.cpp

 //===---- QueryTest.cpp - clang-query test --------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "Query.h"
+#include "QueryParser.h"
 #include "QuerySession.h"
 #include "clang/ASTMatchers/ASTMatchers.h"
 #include "clang/ASTMatchers/Dynamic/VariantValue.h"
 #include "clang/Frontend/ASTUnit.h"
 #include "clang/Tooling/Tooling.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Support/raw_ostream.h"
 #include "gtest/gtest.h"
 #include <string>
 
 using namespace clang;
 using namespace clang::ast_matchers;
 using namespace clang::ast_matchers::dynamic;
 using namespace clang::query;
 using namespace clang::tooling;
 
-TEST(Query, Basic) {
-  std::unique_ptr<ASTUnit> FooAST(
-      buildASTFromCode("void foo1(void) {}\nvoid foo2(void) {}", "foo.cc"));
-  ASSERT_TRUE(FooAST.get());
-  std::unique_ptr<ASTUnit> BarAST(
-      buildASTFromCode("void bar1(void) {}\nvoid bar2(void) {}", "bar.cc"));
-  ASSERT_TRUE(BarAST.get());
-
-  ASTUnit *ASTs[] = { FooAST.get(), BarAST.get() };
+class QueryEngineTest : public ::testing::Test {
+protected:
+  QueryEngineTest() {}
+
+  std::unique_ptr<ASTUnit> FooAST{
+      buildASTFromCode("void foo1(void) {}\nvoid foo2(void) {}", "foo.cc")};
+  std::unique_ptr<ASTUnit> BarAST{
+      buildASTFromCode("void bar1(void) {}\nvoid bar2(void) {}", "bar.cc")};
+  ASTUnit *ASTs[2]{FooAST.get(), BarAST.get()};
+  QuerySession S{ASTs};
 
   std::string Str;
-  llvm::raw_string_ostream OS(Str);
-  QuerySession S(ASTs);
+  llvm::raw_string_ostream OS{Str};
+};
 
+TEST_F(QueryEngineTest, Basic) {
   DynTypedMatcher FnMatcher = functionDecl();
   DynTypedMatcher FooMatcher = functionDecl(hasName("foo1"));
 
   EXPECT_TRUE(NoOpQuery().run(OS, S));
 
   EXPECT_EQ("", OS.str());
 
   Str.clear();
TEST_F(QueryEngineTest, Basic) {
   EXPECT_TRUE(OS.str().find("No bindings.") != std::string::npos);
 
   Str.clear();
 
   EXPECT_FALSE(MatchQuery(isArrow()).run(OS, S));
 
   EXPECT_EQ("Not a valid top-level matcher.\n", OS.str());
 }
+
+TEST_F(QueryEngineTest, LetAndMatch) {
+  QueryRef LetString = QueryParser::parse("let x \"foo1\"", S);
+  EXPECT_TRUE(LetString->run(OS, S));
+  EXPECT_EQ("", OS.str());
+  Str.clear();
+
+  QueryRef LetMatcher = QueryParser::parse("let y hasName(x)", S);
+  EXPECT_TRUE(LetMatcher->run(OS, S));
+  EXPECT_EQ("", OS.str());
+  Str.clear();
+
+  QueryRef Match = QueryParser::parse("match functionDecl(y)", S);
+  EXPECT_TRUE(Match->run(OS, S));
+  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();
+}

unittests/clang-query/QueryParserTest.cpp

 #include "Query.h"
 #include "QuerySession.h"
 #include "llvm/LineEditor/LineEditor.h"
 #include "gtest/gtest.h"
 
 using namespace clang;
 using namespace clang::query;
 
-TEST(QueryParser, NoOp) {
-  QueryRef Q = QueryParser::parse("");
+class QueryParserTest : public ::testing::Test {
+protected:
+  QueryParserTest() {}
+  QueryRef parse(StringRef Code) { return QueryParser::parse(Code, QS); }
+
+  QuerySession QS{llvm::ArrayRef<ASTUnit*>()};
+};
+
+TEST_F(QueryParserTest, NoOp) {
+  QueryRef Q = parse("");
   EXPECT_TRUE(isa<NoOpQuery>(Q));
 
-  Q = QueryParser::parse("\n");
+  Q = parse("\n");
   EXPECT_TRUE(isa<NoOpQuery>(Q));
 }
 
-TEST(QueryParser, Invalid) {
-  QueryRef Q = QueryParser::parse("foo");
+TEST_F(QueryParserTest, Invalid) {
+  QueryRef Q = parse("foo");
   ASSERT_TRUE(isa<InvalidQuery>(Q));
   EXPECT_EQ("unknown command: foo", cast<InvalidQuery>(Q)->ErrStr);
 }
 
-TEST(QueryParser, Help) {
-  QueryRef Q = QueryParser::parse("help");
+TEST_F(QueryParserTest, Help) {
+  QueryRef Q = parse("help");
   ASSERT_TRUE(isa<HelpQuery>(Q));
 
-  Q = QueryParser::parse("help me");
+  Q = parse("help me");
   ASSERT_TRUE(isa<InvalidQuery>(Q));
   EXPECT_EQ("unexpected extra input: ' me'", cast<InvalidQuery>(Q)->ErrStr);
 }
 
-TEST(QueryParser, Set) {
-  QueryRef Q = QueryParser::parse("set");
+TEST_F(QueryParserTest, Set) {
+  QueryRef Q = parse("set");
   ASSERT_TRUE(isa<InvalidQuery>(Q));
   EXPECT_EQ("expected variable name", cast<InvalidQuery>(Q)->ErrStr);
 
-  Q = QueryParser::parse("set foo bar");
+  Q = parse("set foo bar");
   ASSERT_TRUE(isa<InvalidQuery>(Q));
   EXPECT_EQ("unknown variable: 'foo'", cast<InvalidQuery>(Q)->ErrStr);
 
-  Q = QueryParser::parse("set output");
+  Q = parse("set output");
   ASSERT_TRUE(isa<InvalidQuery>(Q));
   EXPECT_EQ("expected 'diag', 'print' or 'dump', got ''",
             cast<InvalidQuery>(Q)->ErrStr);
 
-  Q = QueryParser::parse("set bind-root true foo");
+  Q = parse("set bind-root true foo");
   ASSERT_TRUE(isa<InvalidQuery>(Q));
   EXPECT_EQ("unexpected extra input: ' foo'", cast<InvalidQuery>(Q)->ErrStr);
 
-  Q = QueryParser::parse("set output foo");
+  Q = parse("set output foo");
   ASSERT_TRUE(isa<InvalidQuery>(Q));
   EXPECT_EQ("expected 'diag', 'print' or 'dump', got 'foo'",
             cast<InvalidQuery>(Q)->ErrStr);
 
-  Q = QueryParser::parse("set output dump");
+  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);
 
-  Q = QueryParser::parse("set bind-root foo");
+  Q = parse("set bind-root foo");
   ASSERT_TRUE(isa<InvalidQuery>(Q));
   EXPECT_EQ("expected 'true' or 'false', got 'foo'",
             cast<InvalidQuery>(Q)->ErrStr);
 
-  Q = QueryParser::parse("set bind-root true");
+  Q = parse("set bind-root true");
   ASSERT_TRUE(isa<SetQuery<bool> >(Q));
   EXPECT_EQ(&QuerySession::BindRoot, cast<SetQuery<bool> >(Q)->Var);
   EXPECT_EQ(true, cast<SetQuery<bool> >(Q)->Value);
 }
 
-TEST(QueryParser, Match) {
-  QueryRef Q = QueryParser::parse("match decl()");
+TEST_F(QueryParserTest, Match) {
+  QueryRef Q = parse("match decl()");
   ASSERT_TRUE(isa<MatchQuery>(Q));
   EXPECT_TRUE(cast<MatchQuery>(Q)->Matcher.canConvertTo<Decl>());
 
-  Q = QueryParser::parse("m stmt()");
+  Q = parse("m stmt()");
   ASSERT_TRUE(isa<MatchQuery>(Q));
   EXPECT_TRUE(cast<MatchQuery>(Q)->Matcher.canConvertTo<Stmt>());
 }
 
-TEST(QueryParser, Complete) {
+TEST_F(QueryParserTest, Let) {
+  QueryRef Q = parse("let foo decl()");
+  ASSERT_TRUE(isa<LetQuery>(Q));
+  EXPECT_EQ("foo", cast<LetQuery>(Q)->Name);
+  EXPECT_TRUE(cast<LetQuery>(Q)->Value.isMatcher());
+  EXPECT_TRUE(cast<LetQuery>(Q)->Value.getMatcher().hasTypedMatcher<Decl>());
+
+  Q = parse("let bar \"str\"");
+  ASSERT_TRUE(isa<LetQuery>(Q));
+  EXPECT_EQ("bar", cast<LetQuery>(Q)->Name);
+  EXPECT_TRUE(cast<LetQuery>(Q)->Value.isString());
+  EXPECT_EQ("str", cast<LetQuery>(Q)->Value.getString());
+}
+
+TEST_F(QueryParserTest, Complete) {
   std::vector<llvm::LineEditor::Completion> Comps =
-      QueryParser::complete("", 0);
-  ASSERT_EQ(3u, Comps.size());
+      QueryParser::complete("", 0, QS);
+  ASSERT_EQ(4u, Comps.size());
   EXPECT_EQ("help ", Comps[0].TypedText);
   EXPECT_EQ("help", Comps[0].DisplayText);
   EXPECT_EQ("match ", Comps[1].TypedText);
   EXPECT_EQ("match", Comps[1].DisplayText);
   EXPECT_EQ("set ", Comps[2].TypedText);
   EXPECT_EQ("set", Comps[2].DisplayText);
+  EXPECT_EQ("let ", Comps[3].TypedText);
+  EXPECT_EQ("let", Comps[3].DisplayText);
 
-  Comps = QueryParser::complete("set o", 5);
+  Comps = QueryParser::complete("set o", 5, QS);
   ASSERT_EQ(1u, Comps.size());
   EXPECT_EQ("utput ", Comps[0].TypedText);
   EXPECT_EQ("output", Comps[0].DisplayText);
 
-  Comps = QueryParser::complete("match while", 11);
+  Comps = QueryParser::complete("match while", 11, QS);
   ASSERT_EQ(1u, Comps.size());
   EXPECT_EQ("Stmt(", Comps[0].TypedText);
   EXPECT_EQ("Matcher<Stmt> whileStmt(Matcher<WhileStmt>...)",
             Comps[0].DisplayText);
 }