Extract parseBindID method

[klimek]

lib/ASTMatchers/Dynamic/Parser.cpp

362

CloseToken seems to not be used afterwards either here or in the follow-up patch?

[steveire]

lib/ASTMatchers/Dynamic/Parser.cpp

362

Good catch, thanks. Fixed before committing.

include/clang/ASTMatchers/Dynamic/Parser.h

private:
   class CodeTokenizer;
   struct ScopedContextEntry;
   struct TokenInfo;
 
   Parser(CodeTokenizer *Tokenizer, Sema *S,
          const NamedValueMap *NamedValues,
          Diagnostics *Error);
 
+  bool parseBindID(std::string &BindID, TokenInfo &endToken);
   bool parseExpressionImpl(VariantValue *Value);
   bool parseMatcherExpressionImpl(const TokenInfo &NameToken,
                                   VariantValue *Value);
   bool parseIdentifierPrefixImpl(VariantValue *Value);
 
   void addCompletion(const TokenInfo &CompToken,
                      const MatcherCompletion &Completion);
   void addExpressionCompletions();

lib/ASTMatchers/Dynamic/Parser.cpp

if (Tokenizer->nextTokenKind() != TokenInfo::TK_OpenParen) {
     }
     // Otherwise, fallback to the matcher parser.
   }
 
   // Parse as a matcher expression.
   return parseMatcherExpressionImpl(NameToken, Value);
 }
 
+bool Parser::parseBindID(std::string &BindID, TokenInfo &CloseToken) {
+  // Parse .bind("foo")
+  assert(Tokenizer->peekNextToken().Kind == TokenInfo::TK_Period);
+  Tokenizer->consumeNextToken(); // consume the period.
+  const TokenInfo BindToken = Tokenizer->consumeNextToken();
+  if (BindToken.Kind == TokenInfo::TK_CodeCompletion) {
+    addCompletion(BindToken, MatcherCompletion("bind(\"", "bind", 1));
+    return false;
+  }
+
+  const TokenInfo OpenToken = Tokenizer->consumeNextToken();
+  const TokenInfo IDToken = Tokenizer->consumeNextToken();
+  CloseToken = Tokenizer->consumeNextToken();
+
+  // TODO: We could use different error codes for each/some to be more
+  //       explicit about the syntax error.
+  if (BindToken.Kind != TokenInfo::TK_Ident ||
+      BindToken.Text != TokenInfo::ID_Bind) {
+    Error->addError(BindToken.Range, Error->ET_ParserMalformedBindExpr);
+    return false;
+  }
+  if (OpenToken.Kind != TokenInfo::TK_OpenParen) {
+    Error->addError(OpenToken.Range, Error->ET_ParserMalformedBindExpr);
+    return false;
+  }
+  if (IDToken.Kind != TokenInfo::TK_Literal || !IDToken.Value.isString()) {
+    Error->addError(IDToken.Range, Error->ET_ParserMalformedBindExpr);
+    return false;
+  }
+  if (CloseToken.Kind != TokenInfo::TK_CloseParen) {
+    Error->addError(CloseToken.Range, Error->ET_ParserMalformedBindExpr);
+    return false;
+  }
+  BindID = IDToken.Value.getString();
+  return true;
+}
+
 /// Parse and validate a matcher expression.
 /// \return \c true on success, in which case \c Value has the matcher parsed.
 ///   If the input is malformed, or some argument has an error, it
 ///   returns \c false.
 bool Parser::parseMatcherExpressionImpl(const TokenInfo &NameToken,
                                         VariantValue *Value) {
   assert(NameToken.Kind == TokenInfo::TK_Ident);
   const TokenInfo OpenToken = Tokenizer->consumeNextToken();
bool Parser::parseMatcherExpressionImpl(const TokenInfo &NameToken,
 
   if (EndToken.Kind == TokenInfo::TK_Eof) {
     Error->addError(OpenToken.Range, Error->ET_ParserNoCloseParen);
     return false;
   }
 
   std::string BindID;
   if (Tokenizer->peekNextToken().Kind == TokenInfo::TK_Period) {
-    // Parse .bind("foo")
-    Tokenizer->consumeNextToken();  // consume the period.
-    const TokenInfo BindToken = Tokenizer->consumeNextToken();
-    if (BindToken.Kind == TokenInfo::TK_CodeCompletion) {
-      addCompletion(BindToken, MatcherCompletion("bind(\"", "bind", 1));
-      return false;
-    }
-
-    const TokenInfo OpenToken = Tokenizer->consumeNextToken();
-    const TokenInfo IDToken = Tokenizer->consumeNextToken();
-    const TokenInfo CloseToken = Tokenizer->consumeNextToken();
-
-    // TODO: We could use different error codes for each/some to be more
-    //       explicit about the syntax error.
-    if (BindToken.Kind != TokenInfo::TK_Ident ||
-        BindToken.Text != TokenInfo::ID_Bind) {
-      Error->addError(BindToken.Range, Error->ET_ParserMalformedBindExpr);
-      return false;
-    }
-    if (OpenToken.Kind != TokenInfo::TK_OpenParen) {
-      Error->addError(OpenToken.Range, Error->ET_ParserMalformedBindExpr);
-      return false;
-    }
-    if (IDToken.Kind != TokenInfo::TK_Literal || !IDToken.Value.isString()) {
-      Error->addError(IDToken.Range, Error->ET_ParserMalformedBindExpr);
-      return false;
-    }
-    if (CloseToken.Kind != TokenInfo::TK_CloseParen) {
-      Error->addError(CloseToken.Range, Error->ET_ParserMalformedBindExpr);
+    TokenInfo CloseToken;
+    if (!parseBindID(BindID, CloseToken))
       return false;
-    }
-    BindID = IDToken.Value.getString();
-  }
 
   if (!Ctor)
     return false;
 
   // Merge the start and end infos.
   Diagnostics::Context Ctx(Diagnostics::Context::ConstructMatcher, Error,
                            NameToken.Text, NameToken.Range);
   SourceRange MatcherRange = NameToken.Range;