[clang-query] Use the new API for named values from the Parser.

[sbenza]

Summary

Use the API added in D3509.
This finishes the support for autocomplete for user defined values.

[pcc]

LGTM

[sbenza]

Closed by commit rL215474 (authored by @sbenza).

clang-tools-extra/trunk/clang-query/QueryParser.cpp

 
 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);
+      StringRef(Begin, End - Begin), CompletionPos - Begin, nullptr,
+      &QS.NamedValues);
   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("let", PQK_Let)
                               .Case("match", PQK_Match)
                               .Case("set", PQK_Set)
                               .Case("unlet", PQK_Unlet)
                               .Default(PQK_Invalid);
 
-  QuerySessionSema S(QS);
-
   switch (QKind) {
   case PQK_NoOp:
     return new NoOpQuery;
 
   case PQK_Help:
     return endQuery(new HelpQuery);
 
   case PQK_Let: {
     StringRef Name = lexWord();
 
     if (Name.empty())
       return new InvalidQuery("expected variable name");
 
     if (CompletionPos)
       return completeMatcherExpression();
 
     Diagnostics Diag;
     ast_matchers::dynamic::VariantValue Value;
-    if (!Parser::parseExpression(StringRef(Begin, End - Begin), &S, &Value,
-                                 &Diag)) {
+    if (!Parser::parseExpression(StringRef(Begin, End - Begin), nullptr,
+                                 &QS.NamedValues, &Value, &Diag)) {
       return makeInvalidQueryFromDiagnostics(Diag);
     }
 
     return new LetQuery(Name, Value);
   }
 
   case PQK_Match: {
     if (CompletionPos)
       return completeMatcherExpression();
 
     Diagnostics Diag;
     Optional<DynTypedMatcher> Matcher = Parser::parseMatcherExpression(
-        StringRef(Begin, End - Begin), &S, &Diag);
+        StringRef(Begin, End - Begin), nullptr, &QS.NamedValues, &Diag);
     if (!Matcher) {
       return makeInvalidQueryFromDiagnostics(Diag);
     }
     return new MatchQuery(*Matcher);
   }
 
   case PQK_Set: {
     StringRef VarStr;