Revert "Allow newlines in AST Matchers in clang-query files" + 1

Revert "Fix -Wunused-lambda-capture warnings."
This reverts commit 2369560f4a7720b19edfbf9de14ef061307ff773.
This reverts commit 522ee29a4fb3814db604b585c8637247477ec057.

clang/lib/ASTMatchers/Dynamic/Parser.cpp:610:13: warning: implicit conversion turns string literal into bool: 'const char [35]' to 'bool' [-Wstring-conversion]
    assert(!"Newline should never be found here");

1 files changed, 21 insertions, 55 deletions

diff --git a/clang/lib/ASTMatchers/Dynamic/Parser.cpp b/clang/lib/ASTMatchers/Dynamic/Parser.cpp
index 77c9629f6f8..e3b00b46832 100644
--- a/clang/lib/ASTMatchers/Dynamic/Parser.cpp
+++ b/clang/lib/ASTMatchers/Dynamic/Parser.cpp
@@ -38,7 +38,6 @@ struct Parser::TokenInfo {
   /// Different possible tokens.
   enum TokenKind {
     TK_Eof,
-    TK_NewLine,
     TK_OpenParen,
     TK_CloseParen,
     TK_Comma,
@@ -66,12 +65,12 @@ const char* const Parser::TokenInfo::ID_Bind = "bind";
 /// Simple tokenizer for the parser.
 class Parser::CodeTokenizer {
 public:
-  explicit CodeTokenizer(StringRef &MatcherCode, Diagnostics *Error)
+  explicit CodeTokenizer(StringRef MatcherCode, Diagnostics *Error)
       : Code(MatcherCode), StartOfLine(MatcherCode), Error(Error) {
     NextToken = getNextToken();
   }
 
-  CodeTokenizer(StringRef &MatcherCode, Diagnostics *Error,
+  CodeTokenizer(StringRef MatcherCode, Diagnostics *Error,
                 unsigned CodeCompletionOffset)
       : Code(MatcherCode), StartOfLine(MatcherCode), Error(Error),
         CodeCompletionLocation(MatcherCode.data() + CodeCompletionOffset) {
@@ -88,19 +87,6 @@ public:
     return ThisToken;
   }
 
-  TokenInfo SkipNewlines() {
-    while (NextToken.Kind == TokenInfo::TK_NewLine)
-      NextToken = getNextToken();
-    return NextToken;
-  }
-
-  TokenInfo consumeNextTokenIgnoreNewlines() {
-    SkipNewlines();
-    if (NextToken.Kind == TokenInfo::TK_Eof)
-      return NextToken;
-    return consumeNextToken();
-  }
-
   TokenInfo::TokenKind nextTokenKind() const { return NextToken.Kind; }
 
 private:
@@ -124,8 +110,9 @@ private:
 
     switch (Code[0]) {
     case '#':
-      Code = Code.drop_until([](char c) { return c == '\n'; });
-      return getNextToken();
+      Result.Kind = TokenInfo::TK_Eof;
+      Result.Text = "";
+      return Result;
     case ',':
       Result.Kind = TokenInfo::TK_Comma;
       Result.Text = Code.substr(0, 1);
@@ -136,13 +123,6 @@ private:
       Result.Text = Code.substr(0, 1);
       Code = Code.drop_front();
       break;
-    case '\n':
-      ++Line;
-      StartOfLine = Code.drop_front();
-      Result.Kind = TokenInfo::TK_NewLine;
-      Result.Text = Code.substr(0, 1);
-      Code = Code.drop_front();
-      break;
     case '(':
       Result.Kind = TokenInfo::TK_OpenParen;
       Result.Text = Code.substr(0, 1);
@@ -297,10 +277,13 @@ private:
 
   /// Consume all leading whitespace from \c Code.
   void consumeWhitespace() {
-    Code = Code.drop_while([](char c) {
-      // Don't trim newlines.
-      return StringRef(" \t\v\f\r").contains(c);
-    });
+    while (!Code.empty() && isWhitespace(Code[0])) {
+      if (Code[0] == '\n') {
+        ++Line;
+        StartOfLine = Code.drop_front();
+      }
+      Code = Code.drop_front();
+    }
   }
 
   SourceLocation currentLocation() {
@@ -310,7 +293,7 @@ private:
     return Location;
   }
 
-  StringRef &Code;
+  StringRef Code;
   StringRef StartOfLine;
   unsigned Line = 1;
   Diagnostics *Error;
@@ -354,13 +337,6 @@ struct Parser::ScopedContextEntry {
 bool Parser::parseIdentifierPrefixImpl(VariantValue *Value) {
   const TokenInfo NameToken = Tokenizer->consumeNextToken();
 
-  if (Tokenizer->nextTokenKind() == TokenInfo::TK_NewLine) {
-    Error->addError(Tokenizer->peekNextToken().Range,
-                    Error->ET_ParserNoOpenParen)
-        << "NewLine";
-    return false;
-  }
-
   if (Tokenizer->nextTokenKind() != TokenInfo::TK_OpenParen) {
     // Parse as a named value.
     if (const VariantValue NamedValue =
@@ -392,7 +368,6 @@ bool Parser::parseIdentifierPrefixImpl(VariantValue *Value) {
     // unknown named value.
     if ((Tokenizer->nextTokenKind() == TokenInfo::TK_Comma ||
          Tokenizer->nextTokenKind() == TokenInfo::TK_CloseParen ||
-         Tokenizer->nextTokenKind() == TokenInfo::TK_NewLine ||
          Tokenizer->nextTokenKind() == TokenInfo::TK_Eof) &&
         !S->lookupMatcherCtor(NameToken.Text)) {
       Error->addError(NameToken.Range, Error->ET_RegistryValueNotFound)
@@ -402,8 +377,6 @@ bool Parser::parseIdentifierPrefixImpl(VariantValue *Value) {
     // Otherwise, fallback to the matcher parser.
   }
 
-  Tokenizer->SkipNewlines();
-
   // Parse as a matcher expression.
   return parseMatcherExpressionImpl(NameToken, Value);
 }
@@ -419,8 +392,8 @@ bool Parser::parseBindID(std::string &BindID) {
   }
 
   const TokenInfo OpenToken = Tokenizer->consumeNextToken();
-  const TokenInfo IDToken = Tokenizer->consumeNextTokenIgnoreNewlines();
-  const TokenInfo CloseToken = Tokenizer->consumeNextTokenIgnoreNewlines();
+  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.
@@ -470,8 +443,6 @@ bool Parser::parseMatcherExpressionImpl(const TokenInfo &NameToken,
   std::vector<ParserValue> Args;
   TokenInfo EndToken;
 
-  Tokenizer->SkipNewlines();
-
   {
     ScopedContextEntry SCE(this, Ctor ? *Ctor : nullptr);
 
@@ -495,14 +466,12 @@ bool Parser::parseMatcherExpressionImpl(const TokenInfo &NameToken,
                                NameToken.Text, NameToken.Range,
                                Args.size() + 1);
       ParserValue ArgValue;
-      Tokenizer->SkipNewlines();
       ArgValue.Text = Tokenizer->peekNextToken().Text;
       ArgValue.Range = Tokenizer->peekNextToken().Range;
       if (!parseExpressionImpl(&ArgValue.Value)) {
         return false;
       }
 
-      Tokenizer->SkipNewlines();
       Args.push_back(ArgValue);
       SCE.nextArg();
     }
@@ -562,7 +531,7 @@ std::vector<MatcherCompletion> Parser::getNamedValueCompletions(
 }
 
 void Parser::addExpressionCompletions() {
-  const TokenInfo CompToken = Tokenizer->consumeNextTokenIgnoreNewlines();
+  const TokenInfo CompToken = Tokenizer->consumeNextToken();
   assert(CompToken.Kind == TokenInfo::TK_CodeCompletion);
 
   // We cannot complete code if there is an invalid element on the context
@@ -606,9 +575,7 @@ bool Parser::parseExpressionImpl(VariantValue *Value) {
   case TokenInfo::TK_Error:
     // This error was already reported by the tokenizer.
     return false;
-  case TokenInfo::TK_NewLine:
-    assert(!"Newline should never be found here");
-    return false;
+
   case TokenInfo::TK_OpenParen:
   case TokenInfo::TK_CloseParen:
   case TokenInfo::TK_Comma:
@@ -657,14 +624,13 @@ std::vector<MatcherCompletion> Parser::RegistrySema::getMatcherCompletions(
   return Registry::getMatcherCompletions(AcceptedTypes);
 }
 
-bool Parser::parseExpression(StringRef &Code, Sema *S,
+bool Parser::parseExpression(StringRef Code, Sema *S,
                              const NamedValueMap *NamedValues,
                              VariantValue *Value, Diagnostics *Error) {
   CodeTokenizer Tokenizer(Code, Error);
   if (!Parser(&Tokenizer, S, NamedValues, Error).parseExpressionImpl(Value))
     return false;
-  auto NT = Tokenizer.peekNextToken();
-  if (NT.Kind != TokenInfo::TK_Eof && NT.Kind != TokenInfo::TK_NewLine) {
+  if (Tokenizer.peekNextToken().Kind != TokenInfo::TK_Eof) {
     Error->addError(Tokenizer.peekNextToken().Range,
                     Error->ET_ParserTrailingCode);
     return false;
@@ -673,7 +639,7 @@ bool Parser::parseExpression(StringRef &Code, Sema *S,
 }
 
 std::vector<MatcherCompletion>
-Parser::completeExpression(StringRef &Code, unsigned CompletionOffset, Sema *S,
+Parser::completeExpression(StringRef Code, unsigned CompletionOffset, Sema *S,
                            const NamedValueMap *NamedValues) {
   Diagnostics Error;
   CodeTokenizer Tokenizer(Code, &Error, CompletionOffset);
@@ -693,7 +659,7 @@ Parser::completeExpression(StringRef &Code, unsigned CompletionOffset, Sema *S,
 }
 
 llvm::Optional<DynTypedMatcher>
-Parser::parseMatcherExpression(StringRef &Code, Sema *S,
+Parser::parseMatcherExpression(StringRef Code, Sema *S,
                                const NamedValueMap *NamedValues,
                                Diagnostics *Error) {
   VariantValue Value;