Add clang-query support for mapAnyOf

[aaron.ballman]

LGTM aside from some minor nits.

clang/lib/ASTMatchers/Dynamic/Marshallers.h

1081 ↗

(On Diff #317229)

Is this a TODO comment?

1095–1098 ↗

(On Diff #317229)

1099–1100 ↗

(On Diff #317229)

[steveire]

Update

[steveire]

@aaron.ballman Please review this again as I've merged some more needed changes into it.

[aaron.ballman]

clang/include/clang/ASTMatchers/Dynamic/Registry.h

36–37 ↗

(On Diff #319431)

40 ↗

(On Diff #319431)

I think it'd be cleaner to make callers be explicit about forming the smart pointer.

clang/lib/ASTMatchers/Dynamic/Marshallers.h

586–587 ↗

(On Diff #319431)

Might as well make it obvious the function doesn't care about its arguments (same elsewhere in the patch).

1081–1083 ↗

(On Diff #319431)

clang/lib/ASTMatchers/Dynamic/Parser.cpp

394

395

434

447–448

The comment is a bit misleading in that this doesn't parse the .bind part, only the ("foo") bits.

Also, why does the function now accept BindToken but not use it?

490

509

520

552

unique_ptr? or is this our custom smart pointer? Either way, please spell the type out.

562

639–642

717

clang/lib/ASTMatchers/Dynamic/Registry.cpp

580 ↗

(On Diff #319431)

I think that having the explicit ctor call here would make it more obvious that the .release() is being picked up by another smart pointer type.

697 ↗

(On Diff #319431)

Any reason this declaration needed to move?

[steveire]

Update

clang/lib/ASTMatchers/Dynamic/Registry.cpp

697 ↗

(On Diff #319431)

It's used after the if-else.

[aaron.ballman]

I think there should be some documentation change for the new with functionality.

clang/lib/ASTMatchers/Dynamic/Marshallers.h

398–407 ↗

(On Diff #320593)

Rather than repeat these degenerate definitions six times, should this just be the default implementation within MatcherDescriptor (so derived classes are not required to override them)? Alternatively, should we make a NonBuilderMatcherDescriptor class that holds the degenerate definition, and these derived classes can inherit from NonBuilderMatcherDescriptor instead?

1094 ↗

(On Diff #320593)

clang/lib/ASTMatchers/Dynamic/Parser.cpp

372

448

605

[steveire]

Update

[steveire]

In D94880#2536399, @aaron.ballman wrote:

I think there should be some documentation change for the new with functionality.

It's already documented in https://clang.llvm.org/docs/LibASTMatchersReference.html , just like all the other functionality.

[steveire]

@aaron.ballman Any further comments?

[aaron.ballman]

In D94880#2544782, @steveire wrote:

@aaron.ballman Any further comments?

Thank you for pinging, this fell off my queue! The only further comments I have about about my confusion with with.

In D94880#2536485, @steveire wrote:

In D94880#2536399, @aaron.ballman wrote:

I think there should be some documentation change for the new with functionality.

It's already documented in https://clang.llvm.org/docs/LibASTMatchersReference.html , just like all the other functionality.

Perhaps I'm blind, but when I search for "with" on that page, I get 21 hits and none of them are about the with() function. I am not finding evidence of with being supported on ToT, can you point me to the existing implementation? (If the functionality isn't being introduced in this patch, you don't need to document as part of this work. However, I was under the impression you were adding this functionality, so I'd like to understand this situation better before approving.)

[steveire]

That page collapses the documentation for each matcher, as you know.

You need to expand the docs for mapAnyOf, as you know.

You seem to know all this. What's the remaining issue?

[aaron.ballman]

In D94880#2544873, @steveire wrote:

That page collapses the documentation for each matcher, as you know.

You need to expand the docs for mapAnyOf, as you know.

You seem to know all this. What's the remaining issue?

The issue was that this was not at all obvious to me as a code reviewer, so I was asking you for help. Your response comes across as patronizing, but thank you for giving me the information I was looking for. FWIW, I did not know this was under the mapAnyOf matcher and I was assuming this was going to be documented at the top level, just like bind().

LG.

[steveire]

In D94880#2544895, @aaron.ballman wrote:

In D94880#2544873, @steveire wrote:

That page collapses the documentation for each matcher, as you know.

You need to expand the docs for mapAnyOf, as you know.

You seem to know all this. What's the remaining issue?

The issue was that this was not at all obvious to me as a code reviewer, so I was asking you for help. Your response comes across as patronizing, but thank you for giving me the information I was looking for. FWIW, I did not know this was under the mapAnyOf matcher and I was assuming this was going to be documented at the top level, just like bind().

LG.

You reviewed the patches for mapAnyOf up to now and you reviewed this change which has unit tests using with. I didn't know what was unclear to you. Sorry for being terse.

Thanks for the review.

clang/include/clang/ASTMatchers/Dynamic/Diagnostics.h

enum ErrorType {
 
     ET_RegistryMatcherNotFound = 1,
     ET_RegistryWrongArgCount = 2,
     ET_RegistryWrongArgType = 3,
     ET_RegistryNotBindable = 4,
     ET_RegistryAmbiguousOverload = 5,
     ET_RegistryValueNotFound = 6,
     ET_RegistryUnknownEnumWithReplace = 7,
+    ET_RegistryNonNodeMatcher = 8,
+    ET_RegistryMatcherNoWithSupport = 9,
 
     ET_ParserStringError = 100,
     ET_ParserNoOpenParen = 101,
     ET_ParserNoCloseParen = 102,
     ET_ParserNoComma = 103,
     ET_ParserNoCode = 104,
     ET_ParserNotAMatcher = 105,
     ET_ParserInvalidToken = 106,
     ET_ParserMalformedBindExpr = 107,
     ET_ParserTrailingCode = 108,
     ET_ParserNumberError = 109,
-    ET_ParserOverloadedType = 110
+    ET_ParserOverloadedType = 110,
+    ET_ParserMalformedChainedExpr = 111,
+    ET_ParserFailedToBuildMatcher = 112
   };
 
   /// Helper stream class.
   class ArgStream {
   public:
     ArgStream(std::vector<std::string> *Out) : Out(Out) {}
     template <class T> ArgStream &operator<<(const T &Arg) {
       return operator<<(Twine(Arg));

clang/include/clang/ASTMatchers/Dynamic/Parser.h

public:
     ///
     /// \param MatcherName The matcher name found by the parser.
     ///
     /// \return The matcher constructor, or Optional<MatcherCtor>() if not
     /// found.
     virtual llvm::Optional<MatcherCtor>
     lookupMatcherCtor(StringRef MatcherName) = 0;
 
+    virtual bool isBuilderMatcher(MatcherCtor) const = 0;
+
+    virtual ASTNodeKind nodeMatcherType(MatcherCtor) const = 0;
+
+    virtual internal::MatcherDescriptorPtr
+    buildMatcherCtor(MatcherCtor, SourceRange NameRange,
+                     ArrayRef<ParserValue> Args, Diagnostics *Error) const = 0;
+
     /// Compute the list of completion types for \p Context.
     ///
     /// Each element of \p Context represents a matcher invocation, going from
     /// outermost to innermost. Elements are pairs consisting of a reference to
     /// the matcher constructor and the index of the next element in the
     /// argument list of that matcher (or for the last element, the index of
     /// the completion point in the argument list). An empty list requests
     /// completion for the root matcher.
VariantMatcher actOnMatcherExpression(MatcherCtor Ctor,
                                           SourceRange NameRange,
                                           StringRef BindID,
                                           ArrayRef<ParserValue> Args,
                                           Diagnostics *Error) override;
 
     std::vector<ArgKind> getAcceptedCompletionTypes(
         llvm::ArrayRef<std::pair<MatcherCtor, unsigned>> Context) override;
 
+    bool isBuilderMatcher(MatcherCtor Ctor) const override;
+
+    ASTNodeKind nodeMatcherType(MatcherCtor) const override;
+
+    internal::MatcherDescriptorPtr
+    buildMatcherCtor(MatcherCtor, SourceRange NameRange,
+                     ArrayRef<ParserValue> Args,
+                     Diagnostics *Error) const override;
+
     std::vector<MatcherCompletion>
     getMatcherCompletions(llvm::ArrayRef<ArgKind> AcceptedTypes) override;
   };
 
   using NamedValueMap = llvm::StringMap<VariantValue>;
 
   /// Parse a matcher expression.
   ///
private:
   struct TokenInfo;
 
   Parser(CodeTokenizer *Tokenizer, Sema *S,
          const NamedValueMap *NamedValues,
          Diagnostics *Error);
 
   bool parseBindID(std::string &BindID);
   bool parseExpressionImpl(VariantValue *Value);
+  bool parseMatcherBuilder(MatcherCtor Ctor, const TokenInfo &NameToken,
+                           const TokenInfo &OpenToken, VariantValue *Value);
   bool parseMatcherExpressionImpl(const TokenInfo &NameToken,
                                   const TokenInfo &OpenToken,
                                   llvm::Optional<MatcherCtor> Ctor,
                                   VariantValue *Value);
   bool parseIdentifierPrefixImpl(VariantValue *Value);
 
   void addCompletion(const TokenInfo &CompToken,
                      const MatcherCompletion &Completion);

clang/lib/ASTMatchers/Dynamic/Diagnostics.cpp

case Diagnostics::ET_RegistryNotBindable:
     return "Matcher does not support binding.";
   case Diagnostics::ET_RegistryAmbiguousOverload:
     // TODO: Add type info about the overload error.
     return "Ambiguous matcher overload.";
   case Diagnostics::ET_RegistryValueNotFound:
     return "Value not found: $0";
   case Diagnostics::ET_RegistryUnknownEnumWithReplace:
     return "Unknown value '$1' for arg $0; did you mean '$2'";
+  case Diagnostics::ET_RegistryNonNodeMatcher:
+    return "Matcher not a node matcher: $0";
+  case Diagnostics::ET_RegistryMatcherNoWithSupport:
+    return "Matcher does not support with call.";
 
   case Diagnostics::ET_ParserStringError:
     return "Error parsing string token: <$0>";
   case Diagnostics::ET_ParserNoOpenParen:
     return "Error parsing matcher. Found token <$0> while looking for '('.";
   case Diagnostics::ET_ParserNoCloseParen:
     return "Error parsing matcher. Found end-of-code while looking for ')'.";
   case Diagnostics::ET_ParserNoComma:
     return "Error parsing matcher. Found token <$0> while looking for ','.";
   case Diagnostics::ET_ParserNoCode:
     return "End of code found while looking for token.";
   case Diagnostics::ET_ParserNotAMatcher:
     return "Input value is not a matcher expression.";
   case Diagnostics::ET_ParserInvalidToken:
     return "Invalid token <$0> found when looking for a value.";
   case Diagnostics::ET_ParserMalformedBindExpr:
     return "Malformed bind() expression.";
   case Diagnostics::ET_ParserTrailingCode:
     return "Expected end of code.";
   case Diagnostics::ET_ParserNumberError:
     return "Error parsing numeric literal: <$0>";
   case Diagnostics::ET_ParserOverloadedType:
     return "Input value has unresolved overloaded type: $0";
+  case Diagnostics::ET_ParserMalformedChainedExpr:
+    return "Period not followed by valid chained call.";
+  case Diagnostics::ET_ParserFailedToBuildMatcher:
+    return "Failed to build matcher: $0.";
 
   case Diagnostics::ET_None:
     return "<N/A>";
   }
   llvm_unreachable("Unknown ErrorType value.");
 }
 
 static void formatErrorString(StringRef FormatString,

clang/lib/ASTMatchers/Dynamic/Parser.cpp

enum TokenKind {
     TK_Ident,
     TK_InvalidChar,
     TK_Error,
     TK_CodeCompletion
   };
 
   /// Some known identifiers.
   static const char* const ID_Bind;
+  static const char *const ID_With;
 
   TokenInfo() = default;
 
   StringRef Text;
   TokenKind Kind = TK_Eof;
   SourceRange Range;
   VariantValue Value;
 };
 
 const char* const Parser::TokenInfo::ID_Bind = "bind";
+const char *const Parser::TokenInfo::ID_With = "with";
 
 /// Simple tokenizer for the parser.
 class Parser::CodeTokenizer {
 public:
   explicit CodeTokenizer(StringRef &MatcherCode, Diagnostics *Error)
       : Code(MatcherCode), StartOfLine(MatcherCode), Error(Error) {
     NextToken = getNextToken();
   }
if (const VariantValue NamedValue =
 
       if (Tokenizer->nextTokenKind() != TokenInfo::TK_Period) {
         *Value = NamedValue;
         return true;
       }
 
       std::string BindID;
       Tokenizer->consumeNextToken();
-      TokenInfo BindToken = Tokenizer->consumeNextToken();
-      if (BindToken.Kind == TokenInfo::TK_CodeCompletion) {
-        addCompletion(BindToken, MatcherCompletion("bind(\"", "bind", 1));
+      TokenInfo ChainCallToken = Tokenizer->consumeNextToken();
+      if (ChainCallToken.Kind == TokenInfo::TK_CodeCompletion) {
+        addCompletion(ChainCallToken, MatcherCompletion("bind(\"", "bind", 1));
         return false;
       }
-      if (BindToken.Kind != TokenInfo::TK_Ident ||
-        BindToken.Text != TokenInfo::ID_Bind) {
-        Error->addError(BindToken.Range, Error->ET_ParserMalformedBindExpr);
+
+      if (ChainCallToken.Kind != TokenInfo::TK_Ident ||
+          (ChainCallToken.Text != TokenInfo::ID_Bind &&
+           ChainCallToken.Text != TokenInfo::ID_With)) {
+        Error->addError(ChainCallToken.Range,
+                        Error->ET_ParserMalformedChainedExpr);
+        return false;
+      }
+      if (ChainCallToken.Text == TokenInfo::ID_With) {
+
+        Diagnostics::Context Ctx(Diagnostics::Context::ConstructMatcher, Error,
+                                 NameToken.Text, NameToken.Range);
+
+        Error->addError(ChainCallToken.Range,
+                        Error->ET_RegistryMatcherNoWithSupport);
         return false;
       }
       if (!parseBindID(BindID))
         return false;
 
       assert(NamedValue.isMatcher());
       llvm::Optional<DynTypedMatcher> Result =
           NamedValue.getMatcher().getSingleMatcher();
       if (Result.hasValue()) {
         llvm::Optional<DynTypedMatcher> Bound = Result->tryBind(BindID);
         if (Bound.hasValue()) {
           *Value = VariantMatcher::SingleMatcher(*Bound);
if ((Tokenizer->nextTokenKind() == TokenInfo::TK_Comma ||
       return false;
     }
     // Otherwise, fallback to the matcher parser.
   }
 
   Tokenizer->SkipNewlines();
 
   assert(NameToken.Kind == TokenInfo::TK_Ident);
   TokenInfo OpenToken = Tokenizer->consumeNextToken();
   if (OpenToken.Kind != TokenInfo::TK_OpenParen) {
     Error->addError(OpenToken.Range, Error->ET_ParserNoOpenParen)
         << OpenToken.Text;
     return false;
   }
 
   llvm::Optional<MatcherCtor> Ctor = S->lookupMatcherCtor(NameToken.Text);
 
   // Parse as a matcher expression.
   return parseMatcherExpressionImpl(NameToken, OpenToken, Ctor, Value);
 }
 
 bool Parser::parseBindID(std::string &BindID) {
   // Parse the parenthesized argument to .bind("foo")
   const TokenInfo OpenToken = Tokenizer->consumeNextToken();
   const TokenInfo IDToken = Tokenizer->consumeNextTokenIgnoreNewlines();
   const TokenInfo CloseToken = Tokenizer->consumeNextTokenIgnoreNewlines();
 
   // TODO: We could use different error codes for each/some to be more
   //       explicit about the syntax error.
   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;
 }
 
+bool Parser::parseMatcherBuilder(MatcherCtor Ctor, const TokenInfo &NameToken,
+                                 const TokenInfo &OpenToken,
+                                 VariantValue *Value) {
+  std::vector<ParserValue> Args;
+  TokenInfo EndToken;
+
+  Tokenizer->SkipNewlines();
+
+  {
+    ScopedContextEntry SCE(this, Ctor);
+
+    while (Tokenizer->nextTokenKind() != TokenInfo::TK_Eof) {
+      if (Tokenizer->nextTokenKind() == TokenInfo::TK_CloseParen) {
+        // End of args.
+        EndToken = Tokenizer->consumeNextToken();
+        break;
+      }
+      if (!Args.empty()) {
+        // We must find a , token to continue.
+        TokenInfo CommaToken = Tokenizer->consumeNextToken();
+        if (CommaToken.Kind != TokenInfo::TK_Comma) {
+          Error->addError(CommaToken.Range, Error->ET_ParserNoComma)
+              << CommaToken.Text;
+          return false;
+        }
+      }
+
+      Diagnostics::Context Ctx(Diagnostics::Context::MatcherArg, Error,
+                               NameToken.Text, NameToken.Range,
+                               Args.size() + 1);
+      ParserValue ArgValue;
+      Tokenizer->SkipNewlines();
+
+      if (Tokenizer->peekNextToken().Kind == TokenInfo::TK_CodeCompletion) {
+        addExpressionCompletions();
+        return false;
+      }
+
+      TokenInfo NodeMatcherToken = Tokenizer->consumeNextToken();
+
+      if (NodeMatcherToken.Kind != TokenInfo::TK_Ident) {
+        Error->addError(NameToken.Range, Error->ET_ParserFailedToBuildMatcher)
+            << NameToken.Text;
+        return false;
+      }
+
+      ArgValue.Text = NodeMatcherToken.Text;
+      ArgValue.Range = NodeMatcherToken.Range;
+
+      llvm::Optional<MatcherCtor> MappedMatcher =
+          S->lookupMatcherCtor(ArgValue.Text);
+
+      if (!MappedMatcher) {
+        Error->addError(NodeMatcherToken.Range,
+                        Error->ET_RegistryMatcherNotFound)
+            << NodeMatcherToken.Text;
+        return false;
+      }
+
+      ASTNodeKind NK = S->nodeMatcherType(*MappedMatcher);
+
+      if (NK.isNone()) {
+        Error->addError(NodeMatcherToken.Range,
+                        Error->ET_RegistryNonNodeMatcher)
+            << NodeMatcherToken.Text;
+        return false;
+      }
+
+      ArgValue.Value = NK;
+
+      Tokenizer->SkipNewlines();
+      Args.push_back(ArgValue);
+
+      SCE.nextArg();
+    }
+  }
+
+  if (EndToken.Kind == TokenInfo::TK_Eof) {
+    Error->addError(OpenToken.Range, Error->ET_ParserNoCloseParen);
+    return false;
+  }
+
+  internal::MatcherDescriptorPtr BuiltCtor =
+      S->buildMatcherCtor(Ctor, NameToken.Range, Args, Error);
+
+  if (!BuiltCtor.get()) {
+    Error->addError(NameToken.Range, Error->ET_ParserFailedToBuildMatcher)
+        << NameToken.Text;
+    return false;
+  }
+
+  std::string BindID;
+  if (Tokenizer->peekNextToken().Kind == TokenInfo::TK_Period) {
+    Tokenizer->consumeNextToken();
+    TokenInfo ChainCallToken = Tokenizer->consumeNextToken();
+    if (ChainCallToken.Kind == TokenInfo::TK_CodeCompletion) {
+      addCompletion(ChainCallToken, MatcherCompletion("bind(\"", "bind", 1));
+      addCompletion(ChainCallToken, MatcherCompletion("with(", "with", 1));
+      return false;
+    }
+    if (ChainCallToken.Kind != TokenInfo::TK_Ident ||
+        (ChainCallToken.Text != TokenInfo::ID_Bind &&
+         ChainCallToken.Text != TokenInfo::ID_With)) {
+      Error->addError(ChainCallToken.Range,
+                      Error->ET_ParserMalformedChainedExpr);
+      return false;
+    }
+    if (ChainCallToken.Text == TokenInfo::ID_Bind) {
+      if (!parseBindID(BindID))
+        return false;
+      Diagnostics::Context Ctx(Diagnostics::Context::ConstructMatcher, Error,
+                               NameToken.Text, NameToken.Range);
+      SourceRange MatcherRange = NameToken.Range;
+      MatcherRange.End = ChainCallToken.Range.End;
+      VariantMatcher Result = S->actOnMatcherExpression(
+          BuiltCtor.get(), MatcherRange, BindID, {}, Error);
+      if (Result.isNull())
+        return false;
+
+      *Value = Result;
+      return true;
+    } else if (ChainCallToken.Text == TokenInfo::ID_With) {
+      Tokenizer->SkipNewlines();
+
+      if (Tokenizer->nextTokenKind() != TokenInfo::TK_OpenParen) {
+        StringRef ErrTxt = Tokenizer->nextTokenKind() == TokenInfo::TK_Eof
+                               ? StringRef("EOF")
+                               : Tokenizer->peekNextToken().Text;
+        Error->addError(Tokenizer->peekNextToken().Range,
+                        Error->ET_ParserNoOpenParen)
+            << ErrTxt;
+        return false;
+      }
+
+      TokenInfo WithOpenToken = Tokenizer->consumeNextToken();
+
+      return parseMatcherExpressionImpl(NameToken, WithOpenToken,
+                                        BuiltCtor.get(), Value);
+    }
+  }
+
+  Diagnostics::Context Ctx(Diagnostics::Context::ConstructMatcher, Error,
+                           NameToken.Text, NameToken.Range);
+  SourceRange MatcherRange = NameToken.Range;
+  MatcherRange.End = EndToken.Range.End;
+  VariantMatcher Result = S->actOnMatcherExpression(
+      BuiltCtor.get(), MatcherRange, BindID, {}, Error);
+  if (Result.isNull())
+    return false;
+
+  *Value = Result;
+  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,
                                         const TokenInfo &OpenToken,
                                         llvm::Optional<MatcherCtor> Ctor,
                                         VariantValue *Value) {
   if (!Ctor) {
     Error->addError(NameToken.Range, Error->ET_RegistryMatcherNotFound)
         << NameToken.Text;
     // Do not return here. We need to continue to give completion suggestions.
   }
 
+  if (Ctor && *Ctor && S->isBuilderMatcher(*Ctor))
+    return parseMatcherBuilder(*Ctor, NameToken, OpenToken, Value);
+
   std::vector<ParserValue> Args;
   TokenInfo EndToken;
 
   Tokenizer->SkipNewlines();
 
   {
     ScopedContextEntry SCE(this, Ctor ? *Ctor : nullptr);
 
     while (Tokenizer->nextTokenKind() != TokenInfo::TK_Eof) {
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) {
     Tokenizer->consumeNextToken();
-    TokenInfo BindToken = Tokenizer->consumeNextToken();
-    if (BindToken.Kind == TokenInfo::TK_CodeCompletion) {
-      addCompletion(BindToken, MatcherCompletion("bind(\"", "bind", 1));
+    TokenInfo ChainCallToken = Tokenizer->consumeNextToken();
+    if (ChainCallToken.Kind == TokenInfo::TK_CodeCompletion) {
+      addCompletion(ChainCallToken, MatcherCompletion("bind(\"", "bind", 1));
+      return false;
+    }
+
+    if (ChainCallToken.Kind != TokenInfo::TK_Ident) {
+      Error->addError(ChainCallToken.Range,
+                      Error->ET_ParserMalformedChainedExpr);
+      return false;
+    }
+    if (ChainCallToken.Text == TokenInfo::ID_With) {
+
+      Diagnostics::Context Ctx(Diagnostics::Context::ConstructMatcher, Error,
+                               NameToken.Text, NameToken.Range);
+
+      Error->addError(ChainCallToken.Range,
+                      Error->ET_RegistryMatcherNoWithSupport);
       return false;
     }
-    if (BindToken.Kind != TokenInfo::TK_Ident ||
-      BindToken.Text != TokenInfo::ID_Bind) {
-      Error->addError(BindToken.Range, Error->ET_ParserMalformedBindExpr);
+    if (ChainCallToken.Text != TokenInfo::ID_Bind) {
+      Error->addError(ChainCallToken.Range,
+                      Error->ET_ParserMalformedChainedExpr);
       return false;
     }
     if (!parseBindID(BindID))
       return false;
   }
 
   if (!Ctor)
     return false;
 
   // Merge the start and end infos.
   Diagnostics::Context Ctx(Diagnostics::Context::ConstructMatcher, Error,
                            NameToken.Text, NameToken.Range);
std::vector<ArgKind> Parser::RegistrySema::getAcceptedCompletionTypes(
   return Registry::getAcceptedCompletionTypes(Context);
 }
 
 std::vector<MatcherCompletion> Parser::RegistrySema::getMatcherCompletions(
     ArrayRef<ArgKind> AcceptedTypes) {
   return Registry::getMatcherCompletions(AcceptedTypes);
 }
 
+bool Parser::RegistrySema::isBuilderMatcher(MatcherCtor Ctor) const {
+  return Registry::isBuilderMatcher(Ctor);
+}
+
+ASTNodeKind Parser::RegistrySema::nodeMatcherType(MatcherCtor Ctor) const {
+  return Registry::nodeMatcherType(Ctor);
+}
+
+internal::MatcherDescriptorPtr
+Parser::RegistrySema::buildMatcherCtor(MatcherCtor Ctor, SourceRange NameRange,
+                                       ArrayRef<ParserValue> Args,
+                                       Diagnostics *Error) const {
+  return Registry::buildMatcherCtor(Ctor, NameRange, Args, Error);
+}
+
 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) {

clang/unittests/ASTMatchers/Dynamic/ParserTest.cpp

uint64_t expectMatcher(StringRef MatcherName) {
     // Optimizations on the matcher framework make simple matchers like
     // 'stmt()' to be all the same matcher.
     // Use a more complex expression to prevent that.
     ast_matchers::internal::Matcher<Stmt> M = stmt(stmt(), stmt());
     ExpectedMatchers.insert(std::make_pair(std::string(MatcherName), M));
     return M.getID().second;
   }
 
+  bool isBuilderMatcher(MatcherCtor) const override { return false; }
+
+  ASTNodeKind nodeMatcherType(MatcherCtor) const override { return {}; }
+
+  internal::MatcherDescriptorPtr
+  buildMatcherCtor(MatcherCtor, SourceRange NameRange,
+                   ArrayRef<ParserValue> Args,
+                   Diagnostics *Error) const override {
+    return internal::MatcherDescriptorPtr{nullptr};
+  }
+
   void parse(StringRef Code) {
     Diagnostics Error;
     VariantValue Value;
     Parser::parseExpression(Code, this, &Value, &Error);
     Values.push_back(Value);
     Errors.push_back(Error.toStringFull());
   }
 
EXPECT_EQ("1:1: End of code found while looking for token.",
             ParseWithError(""));
   EXPECT_EQ("Input value is not a matcher expression.",
             ParseMatcherWithError("\"A\""));
   EXPECT_EQ("1:1: Matcher not found: Foo\n"
             "1:1: Error parsing argument 1 for matcher Foo.\n"
             "1:5: Invalid token <(> found when looking for a value.",
             ParseWithError("Foo(("));
   EXPECT_EQ("1:7: Expected end of code.", ParseWithError("expr()a"));
-  EXPECT_EQ("1:11: Malformed bind() expression.",
+  EXPECT_EQ("1:11: Period not followed by valid chained call.",
             ParseWithError("isArrow().biind"));
   EXPECT_EQ("1:15: Malformed bind() expression.",
             ParseWithError("isArrow().bind"));
   EXPECT_EQ("1:16: Malformed bind() expression.",
             ParseWithError("isArrow().bind(foo"));
   EXPECT_EQ("1:21: Malformed bind() expression.",
             ParseWithError("isArrow().bind(\"foo\""));
   EXPECT_EQ("1:1: Error building matcher isArrow.\n"
             "1:1: Matcher does not support binding.",
             ParseWithError("isArrow().bind(\"foo\")"));
+  EXPECT_EQ("1:1: Error building matcher isArrow.\n"
+            "1:11: Matcher does not support with call.",
+            ParseWithError("isArrow().with"));
+  EXPECT_EQ(
+      "1:22: Error parsing matcher. Found token <EOF> while looking for '('.",
+      ParseWithError("mapAnyOf(ifStmt).with"));
+  EXPECT_EQ(
+      "1:22: Error parsing matcher. Found end-of-code while looking for ')'.",
+      ParseWithError("mapAnyOf(ifStmt).with("));
+  EXPECT_EQ("1:1: Failed to build matcher: mapAnyOf.",
+            ParseWithError("mapAnyOf()"));
+  EXPECT_EQ("1:1: Error parsing argument 1 for matcher mapAnyOf.\n1:1: Failed "
+            "to build matcher: mapAnyOf.",
+            ParseWithError("mapAnyOf(\"foo\")"));
   EXPECT_EQ("Input value has unresolved overloaded type: "
             "Matcher<DoStmt|ForStmt|WhileStmt|CXXForRangeStmt|FunctionDecl>",
             ParseMatcherWithError("hasBody(stmt())"));
   EXPECT_EQ(
       "1:1: Error parsing argument 1 for matcher decl.\n"
       "1:6: Error building matcher hasAttr.\n"
       "1:14: Unknown value 'attr::Fnal' for arg 1; did you mean 'attr::Final'",
       ParseMatcherWithError(R"query(decl(hasAttr("attr::Fnal")))query"));
)matcher";
 
     auto NamedValues = getTestNamedValues();
 
     Code = R"matcher(hasParamA.
   bind("paramName")
 )matcher";
     M = Parser::parseMatcherExpression(Code, nullptr, &NamedValues, &Error);
     EXPECT_FALSE(M.hasValue());
-    EXPECT_EQ("1:11: Malformed bind() expression.", Error.toStringFull());
+    EXPECT_EQ("1:11: Period not followed by valid chained call.",
+              Error.toStringFull());
   }
 
   {
     Diagnostics Error;
 
     Code = R"matcher(varDecl
 ()
 )matcher";