[clang] adds builtin `std::invoke` and `std::invoke_r`

[cjdb]

Summary

std::invoke and std::invoke_r are fairly expensive in debug builds,
and are used extensively by standard ranges. By lifting these functions
into the compiler, we save a fair amount of space and improve run-time.

The changes in this commit were used to build a slightly modified
version of range-v3. range-v3 normally rolls its own invoke as a
function object, so the experiment deleted that code in favour of
using std::invoke.

	Build time	Build directory size	CTest time
libstdc++ w/o D130867	User: 465.04s	478504 bytes	13.19s
	Sys: 58.98s	(468 MB)
libstdc++ w/ D130867	User: 468.49s	456936 bytes	7.79s
	Sys: 57.31s	(457 MB)
libc++ w/o D130867	User: 627.67s	795652 bytes	11.88s
	Sys: 67.16s	(778 MB)
libc++ w/ D130867	User: 626.03s	781392 bytes	8.32s
	Sys: 65.77s	(764MB)

[cjdb]

updates commit message

• changes message so that it's accurate
• no longer adding type traits in this commit
• adds bechmark

updates diagnoses so that they're more accurate

[cjdb]

adds logic to diagnose misqualified pointer-to-member functions

[cjdb]

rebases to ToT

[cjdb]

clang/lib/Sema/SemaExprCXX.cpp

5744–5749

[cjdb]

applies a fix

[cjdb]

rebase messed up diff

[cjdb]

rebases onto main

[aaron.ballman]

Thanks for working on this; these sort of improvements to compile time overhead are very much appreciated!

Has this been tested against libc++ (our preccommit CI doesn't test that), and if so, do all the results come back clean from their test suite? Did you try out any other large scale C++ projects to make sure they don't break?

clang/include/clang/Basic/DiagnosticSemaKinds.td

8411

Something's off here, what's a "wrapee"? ("to be a wrapee to a class compatible" doesn't seem grammatically correct.)

8413–8414

Can we reuse err_pointer_to_member_call_drops_quals instead of making a new diagnostic?

8415

Same question here, but about err_pointer_to_member_oper_value_classify instead.

8418–8430

Can we modify existing diagnostics for these as well?

It seems like in most cases, it's a matter of adding a select to use invoke terminology in all of these cases, which is why I'm asking.

clang/include/clang/Sema/Sema.h

4099

Since we're already touching the line anyway...

4101

Hmmm, I wonder if there's a way we can make this change without having to force every caller to think about std::invoke when they look at the signature for these calls? For example (and maybe this is a terrible idea, I'm thinking out loud), could we use an RAII object that specifies we're in a "building a call to invoke" context that is then checked within these functions (and we leave that RAII object before evaluating arguments to the invoke)?

I'm not strongly opposed to the current approach, but I'm worried that it adds complexity for an infrequent construct. I think we should try to keep the situations where we need information about a specific API as self-contained as possible because WG21 has shown more and more interest in the library being implemented in the compiler (so there's a scaling concern as well).

clang/lib/Sema/SemaExpr.cpp

267

Why do we want to suppress the diagnostic here?

14543

This also surprises me.

clang/lib/Sema/SemaExprCXX.cpp

5713–5715

Down with braces! Up with danger!

5736–5739

Yeah, it repeats a bunch of arguments to the calls, but at least it's not using function pointers and hoping the optimizer will undo them back into direct calls.

5759

Adding some standards citations about why you're handling things the way you are would be appreciated.

5776–5777

Do we need to look at the canonical type of FirstArgType? e.g., what if the user did something odd like wrapped reference_wrapper in a type alias and then used that?

clang/test/SemaCXX/builtin-std-invoke.cpp

295

It would be good to have a test which decays a use of std::invoke into a function pointer to make sure that's still possible.

[var-const]

Out of curiosity, would it be possible to do a benchmark to see how adding _LIBCPP_NODEBUG to std::invoke would compare to using builtins?

[cjdb]

In D130867#3759181, @aaron.ballman wrote:

Thanks for working on this; these sort of improvements to compile time overhead are very much appreciated!

Has this been tested against libc++ (our preccommit CI doesn't test that), and if so, do all the results come back clean from their test suite? Did you try out any other large scale C++ projects to make sure they don't break?

I've tested it with the libc++ tests (it caught an interesting thing or two), range-v3, and whatever else I've built since adding this patch to my local install of Clang. I can give a few more large projects a spin if you want higher confidence?

In D130867#3768142, @var-const wrote:

Out of curiosity, would it be possible to do a benchmark to see how adding _LIBCPP_NODEBUG to std::invoke would compare to using builtins?

They're within a few hundred bytes of each other when I also apply [[clang::always_inline]], but it's still worth applying the built-in. This patch helps multiple standard library implementations, so while I encourage libc++ to consider decorating std::invoke, I do think it's worth the implementation existing in Clang too. Another good reason is that by having it as a built-in lets me more easily add __is[_nothrow]_invocable and __invoke_result.

clang/include/clang/Basic/DiagnosticSemaKinds.td

8411

"wrapee" refers to the type that's wrapped by std::reference_wrapper. I can't think of a better name for them, any suggestions?

8413–8414

Short answer: yes.

Long answer: I've found that "can't invoke X" to be really helpful when they've popped up, because it's very obvious that this is to do with std::invoke, so I'm partial to making err_pointer_to_member_call_drops_quals toggleable based on that. (I think you suggest this two comments down?)

clang/lib/Sema/SemaExpr.cpp

267

I think this is the one where I was getting the same diagnostic twice.

14543

Or maybe it was this one. One (or both) of the suppressions is because there was a duplicate error.

clang/test/SemaCXX/builtin-std-invoke.cpp

295

Is that allowed? I thought taking the address of std::invoke was ill-formed.

[ldionne]

I think this is quite interesting, but it also raises the obvious question of: where do we stop? I think the following elements need to be taken into account:

1. Implementing more stuff in the compiler adds complexity to the compiler, and does not decrease the complexity of the library because libc++ still needs to implement invoke on other compilers.
2. It duplicates the tests. The test coverage added by this patch already exists in libc++ (or it should if we're missing it). This patch also seems to be only testing in C++17 mode, and only at compile-time. So technically, this has less coverage than libc++'s own tests for the same thing.
3. Duplicating functionality in libc++ and in the compiler is confusing. For instance, it sets up the stage for people not knowing where a bug in std::invoke should be fixed. Is it in the compiler? In the library? In both? And the set of folks who can fix a bug in the library is not the same as the set of folks who can do it in the compiler.

Regarding the benefits of this patch, do I understand correctly that it had a roughly 1 second improvement in total User Time for libc++, and roughly a 3 seconds regression with libstdc++? If my math's right, that's a roughly 0.1% improvement on libc++ and a 0.6% pessimization on libstdc++, both of which I would argue are kind of in the noise. Also, ranges-v3 is not a typical code base -- it uses metaprogramming and invoke more than a traditional C++ code base, so the overall effect of this is likely to be less than that on a regular code base. Does this make sense, or am I mis interpreting the data?

So I think this is quite interesting, however I do question the benefits this provides in relation with its downsides. In particular, I am not sure that overriding non-trivial libc++ code like this is desirable. We're extremely happy with things like type traits (whose specification is super simple) being implemented in the compiler, but I'm not so sure about things like std::invoke, or even std::tuple. Instead, I'd personally be more interested in having builtins that we can use *from our implementation* to simplify various parts of the implementation (and make it faster). Thoughts?

[cjdb]

I had not realised that libc++ was listed as a reviewer. I am going to abandon this revision, since I only wish to interact with that community when it is both business-critical and unavoidable.

[ldionne]

In D130867#3781429, @cjdb wrote:

I had not realised that libc++ was listed as a reviewer.

The change does have an impact on libc++, so I think it makes sense to look at it not only from the compiler perspective, but from the whole clang/libc++ ecosystem's perspective.

I am going to abandon this revision, since I only wish to interact with that community when it is both business-critical and unavoidable.

While you're not saying so explicitly, you seem to be implying some sort of fault on libc++ here, which I don't understand. I am trying to engage in a genuine and productive discussion. I'm asking questions to clarify my understanding of your benchmarks, raising IMO reasonable technical concerns with the patch, and doing so politely unless I missed something. I'm not saying we should not move forward with the patch -- there must be a reason why you put in all this effort into it. I'm merely raising concerns because no, this isn't a black-and-white situation -- there is a tradeoff with this patch.

I don't know whether your comment targets me personally or the libc++ community as a whole, but either way, honestly this sort of "I won't talk to you" behavior is kind of hurtful. If you feel there's something wrong with the libc++ community or with me, the LLVM Foundation has channels to remediate to that, and I encourage you (or anyone feeling bad about any part of LLVM) to use them.

[cjdb]

In D130867#3781492, @ldionne wrote:

In D130867#3781429, @cjdb wrote:

I had not realised that libc++ was listed as a reviewer.

The change does have an impact on libc++, so I think it makes sense to look at it not only from the compiler perspective, but from the whole clang/libc++ ecosystem's perspective.

I am going to abandon this revision, since I only wish to interact with that community when it is both business-critical and unavoidable.

While you're not saying so explicitly, you seem to be implying some sort of fault on libc++ here, which I don't understand. I am trying to engage in a genuine and productive discussion. I'm asking questions to clarify my understanding of your benchmarks, raising IMO reasonable technical concerns with the patch, and doing so politely unless I missed something. I'm not saying we should not move forward with the patch -- there must be a reason why you put in all this effort into it. I'm merely raising concerns because no, this isn't a black-and-white situation -- there is a tradeoff with this patch.

I don't know whether your comment targets me personally or the libc++ community as a whole, but either way, honestly this sort of "I won't talk to you" behavior is kind of hurtful. If you feel there's something wrong with the libc++ community or with me, the LLVM Foundation has channels to remediate to that, and I encourage you (or anyone feeling bad about any part of LLVM) to use them.

Please revise the emails I sent to you, titled 'libc++ involvement' on 2022-01-18 and 'RE: RE: libc++ involvement' on 2022-01-20, for the reasons why I do not wish to engage with the libc++ community. Friday's commentary simply documents why work on this patch has abruptly stopped.

I do not intend to discuss the matter any further in D130867.

clang/docs/ReleaseNotes.rst

 C2x Feature Support
 -------------------
 
 C++ Language Changes in Clang
 -----------------------------
 
 - Implemented DR692, DR1395 and DR1432. Use the ``-fclang-abi-compat=14`` option
   to get the old partial ordering behavior regarding packs.
+- Improved ``-O0`` code generation for calls to ``std::invoke``, and
+  ``std::invoke_r``. These are now treated as compiler builtins and implemented
+  directly, rather than instantiating a definition from the standard library.
 
 C++20 Feature Support
 ^^^^^^^^^^^^^^^^^^^^^
 
 - Support capturing structured bindings in lambdas
   (`P1091R3 <https://wg21.link/p1091r3>`_ and `P1381R1 <https://wg21.link/P1381R1>`).
   This fixes issues `GH52720 <https://github.com/llvm/llvm-project/issues/52720>`_,
   `GH54300 <https://github.com/llvm/llvm-project/issues/54300>`_,

clang/include/clang/Basic/Builtins.def

 // FIXME: Also declare NSConcreteGlobalBlock and NSConcreteStackBlock.
 
 // C++ standard library builtins in namespace 'std'.
 LIBBUILTIN(addressof, "v*v&", "zfncTh", "memory", CXX_LANG)
 // Synonym for addressof used internally by libstdc++.
 LANGBUILTIN(__addressof, "v*v&", "zfncT", CXX_LANG)
 LIBBUILTIN(as_const, "v&v&", "zfncTh", "utility", CXX_LANG)
 LIBBUILTIN(forward, "v&v&", "zfncTh", "utility", CXX_LANG)
+LIBBUILTIN(invoke, "v.", "zfTh", "functional", CXX_LANG)
+LIBBUILTIN(invoke_r, "v.", "zfTh", "functional", CXX_LANG)
 LIBBUILTIN(move, "v&v&", "zfncTh", "utility", CXX_LANG)
 LIBBUILTIN(move_if_noexcept, "v&v&", "zfncTh", "utility", CXX_LANG)
 
 // Annotation function
 BUILTIN(__builtin_annotation, "v.", "tn")
 
 // Invariants
 BUILTIN(__builtin_assume, "vb", "n")

clang/include/clang/Basic/DiagnosticSemaKinds.td

def err_typecheck_call_too_many_args_suggest : Error<
   "too many %select{|||execution configuration }0arguments to "
   "%select{function|block|method|kernel function}0 call, "
   "expected %1, have %2; did you mean %3?">;
 def err_typecheck_call_too_many_args_at_most_suggest : Error<
   "too many %select{|||execution configuration }0arguments to "
   "%select{function|block|method|kernel function}0 call, "
   "expected at most %1, have %2; did you mean %3?">;
 
+def err_invoke_pointer_to_member_too_few_args : Error<
+  "can't invoke pointer-to-%select{data member|member function}0: "
+  "'std::invoke%select{|_r}1' must have %select{exactly|at least}0 2 arguments "
+  "for a pointer-to-%select{data member|member function}0, got %2">;
+def err_invoke_pointer_to_member_incompatible_second_arg : Error<
+  "can't invoke pointer-to-%select{data member|member function}0: expected "
+  "second argument to be a %select{reference|wrapee|pointer}1 to a class "
+  "compatible with %2, got %3">;
+def err_invoke_pointer_to_member_drops_qualifiers : Error<
+  "can't invoke pointer-to-member function: '%0' drops '%1' qualifier%s2">;
+def err_invoke_pointer_to_member_ref_qualifiers : Error<
+  "can't invoke pointer-to-member function: '%0' can only be called on an "
+  "%select{lvalue|rvalue}1">;
+def err_invoke_wrong_number_of_args : Error<
+  "can't invoke %select{function|block|pointer-to-member function}0: expected "
+  "%1 %select{argument|arguments}2, got %3">;
+def err_invoke_function_object : Error<
+  "can't invoke %0 function object: %select{no|%2}1 suitable "
+  "overload%s2 found%select{|, which makes choosing ambiguous}1">;
+def err_invoke_function_object_deleted : Error<
+  "can't invoke %select{function|pointer-to-member function|"
+  "%1 function object}0: chosen overload candidate is deleted">;
+def err_invoke_bad_conversion : Error<
+  "can't invoke %select{function|block|pointer-to-data member|"
+  "pointer-to-member function|%3 function object}0: return type "
+  "%1 isn't convertible to %2">;
+
 def err_arc_typecheck_convert_incompatible_pointer : Error<
   "incompatible pointer types passing retainable parameter of type %0"
   "to a CF function expecting %1 type">;
 
 def err_builtin_fn_use : Error<"builtin functions must be directly called">;
 
 def warn_call_wrong_number_of_arguments : Warning<
   "too %select{few|many}0 arguments in call to %1">;

clang/include/clang/Sema/Sema.h

public:
   ExprResult CreateUnresolvedLookupExpr(CXXRecordDecl *NamingClass,
                                         NestedNameSpecifierLoc NNSLoc,
                                         DeclarationNameInfo DNI,
                                         const UnresolvedSetImpl &Fns,
                                         bool PerformADL = true);
 
   ExprResult CreateOverloadedUnaryOp(SourceLocation OpLoc,
                                      UnaryOperatorKind Opc,
-                                     const UnresolvedSetImpl &Fns,
-                                     Expr *input, bool RequiresADL = true);
+                                     const UnresolvedSetImpl &Fns, Expr *input,
+                                     bool RequiresADL = true,
+                                     bool IsStdInvoke = false);
 
   void LookupOverloadedBinOp(OverloadCandidateSet &CandidateSet,
                              OverloadedOperatorKind Op,
                              const UnresolvedSetImpl &Fns,
                              ArrayRef<Expr *> Args, bool RequiresADL = true);
-  ExprResult CreateOverloadedBinOp(SourceLocation OpLoc,
-                                   BinaryOperatorKind Opc,
-                                   const UnresolvedSetImpl &Fns,
-                                   Expr *LHS, Expr *RHS,
-                                   bool RequiresADL = true,
+  ExprResult CreateOverloadedBinOp(SourceLocation OpLoc, BinaryOperatorKind Opc,
+                                   const UnresolvedSetImpl &Fns, Expr *LHS,
+                                   Expr *RHS, bool RequiresADL = true,
                                    bool AllowRewrittenCandidates = true,
-                                   FunctionDecl *DefaultedFn = nullptr);
+                                   FunctionDecl *DefaultedFn = nullptr,
+                                   bool IsStdInvoke = false);
   ExprResult BuildSynthesizedThreeWayComparison(SourceLocation OpLoc,
                                                 const UnresolvedSetImpl &Fns,
                                                 Expr *LHS, Expr *RHS,
                                                 FunctionDecl *DefaultedFn);
 
   ExprResult CreateOverloadedArraySubscriptExpr(SourceLocation LLoc,
                                                 SourceLocation RLoc, Expr *Base,
                                                 MultiExprArg Args);
 
-  ExprResult BuildCallToMemberFunction(Scope *S, Expr *MemExpr,
+  ExprResult BuildCallToMemberFunction(
+      Scope *S, Expr *MemExpr, SourceLocation LParenLoc, MultiExprArg Args,
+      SourceLocation RParenLoc, Expr *ExecConfig = nullptr,
+      bool IsExecConfig = false, bool AllowRecovery = false,
+      bool IsStdInvoke = false);
+  ExprResult BuildCallToObjectOfClassType(Scope *S, Expr *Object,
                                           SourceLocation LParenLoc,
                                           MultiExprArg Args,
                                           SourceLocation RParenLoc,
-                                       Expr *ExecConfig = nullptr,
-                                       bool IsExecConfig = false,
-                                       bool AllowRecovery = false);
-  ExprResult
-  BuildCallToObjectOfClassType(Scope *S, Expr *Object, SourceLocation LParenLoc,
-                               MultiExprArg Args,
-                               SourceLocation RParenLoc);
+                                          bool IsStdInvoke = false);
 
   ExprResult BuildOverloadedArrowExpr(Scope *S, Expr *Base,
                                       SourceLocation OpLoc,
                                       bool *NoArrowOperatorFound = nullptr);
 
   /// CheckCallReturnType - Checks that a call expression's return type is
   /// complete. Returns true on failure. The location passed in is the location
   /// that best represents the call.
public:
   //===--------------------------------------------------------------------===//
   // Expression Parsing Callbacks: SemaExpr.cpp.
 
   bool CanUseDecl(NamedDecl *D, bool TreatUnavailableAsInvalid);
   bool DiagnoseUseOfDecl(NamedDecl *D, ArrayRef<SourceLocation> Locs,
                          const ObjCInterfaceDecl *UnknownObjCClass = nullptr,
                          bool ObjCPropertyAccess = false,
                          bool AvoidPartialAvailabilityChecks = false,
-                         ObjCInterfaceDecl *ClassReciever = nullptr);
+                         ObjCInterfaceDecl *ClassReciever = nullptr,
+                         bool IsStdInvoke = false);
   void NoteDeletedFunction(FunctionDecl *FD);
   void NoteDeletedInheritingConstructor(CXXConstructorDecl *CD);
   bool DiagnosePropertyAccessorMismatch(ObjCPropertyDecl *PD,
                                         ObjCMethodDecl *Getter,
                                         SourceLocation Loc);
   void DiagnoseSentinelCalls(NamedDecl *D, SourceLocation Loc,
                              ArrayRef<Expr *> Args);
 
ExprResult CreateGenericSelectionExpr(SourceLocation KeyLoc,
                                         SourceLocation DefaultLoc,
                                         SourceLocation RParenLoc,
                                         Expr *ControllingExpr,
                                         ArrayRef<TypeSourceInfo *> Types,
                                         ArrayRef<Expr *> Exprs);
 
   // Binary/Unary Operators.  'Tok' is the token for the operator.
   ExprResult CreateBuiltinUnaryOp(SourceLocation OpLoc, UnaryOperatorKind Opc,
-                                  Expr *InputExpr);
-  ExprResult BuildUnaryOp(Scope *S, SourceLocation OpLoc,
-                          UnaryOperatorKind Opc, Expr *Input);
+                                  Expr *InputExpr, bool IsStdInvoke = false);
+  ExprResult BuildUnaryOp(Scope *S, SourceLocation OpLoc, UnaryOperatorKind Opc,
+                          Expr *Input, bool IsStdInvoke = false);
   ExprResult ActOnUnaryOp(Scope *S, SourceLocation OpLoc,
                           tok::TokenKind Op, Expr *Input);
 
   bool isQualifiedMemberAccess(Expr *E);
   QualType CheckAddressOfOperand(ExprResult &Operand, SourceLocation OpLoc);
 
   bool CheckTypeTraitArity(unsigned Arity, SourceLocation Loc, size_t N);
 
BuildMemberExpr(Expr *Base, bool IsArrow, SourceLocation OpLoc,
                   NestedNameSpecifierLoc NNS, SourceLocation TemplateKWLoc,
                   ValueDecl *Member, DeclAccessPair FoundDecl,
                   bool HadMultipleCandidates,
                   const DeclarationNameInfo &MemberNameInfo, QualType Ty,
                   ExprValueKind VK, ExprObjectKind OK,
                   const TemplateArgumentListInfo *TemplateArgs = nullptr);
 
   void ActOnDefaultCtorInitializers(Decl *CDtorDecl);
-  bool ConvertArgumentsForCall(CallExpr *Call, Expr *Fn,
-                               FunctionDecl *FDecl,
+  bool ConvertArgumentsForCall(CallExpr *Call, Expr *Fn, FunctionDecl *FDecl,
                                const FunctionProtoType *Proto,
-                               ArrayRef<Expr *> Args,
-                               SourceLocation RParenLoc,
-                               bool ExecConfig = false);
+                               ArrayRef<Expr *> Args, SourceLocation RParenLoc,
+                               bool ExecConfig = false,
+                               bool IsStdInvoke = false);
   void CheckStaticArrayArgument(SourceLocation CallLoc,
                                 ParmVarDecl *Param,
                                 const Expr *ArgExpr);
 
+  ExprResult BuildStdInvokeCall(CallExpr *TheCall, FunctionDecl *FDecl,
+                                unsigned int BuiltinID);
+
   /// ActOnCallExpr - Handle a call to Fn with the specified array of arguments.
   /// This provides the location of the left/right parens and a list of comma
   /// locations.
   ExprResult ActOnCallExpr(Scope *S, Expr *Fn, SourceLocation LParenLoc,
                            MultiExprArg ArgExprs, SourceLocation RParenLoc,
                            Expr *ExecConfig = nullptr);
   ExprResult BuildCallExpr(Scope *S, Expr *Fn, SourceLocation LParenLoc,
                            MultiExprArg ArgExprs, SourceLocation RParenLoc,
                            Expr *ExecConfig = nullptr,
                            bool IsExecConfig = false,
-                           bool AllowRecovery = false);
+                           bool AllowRecovery = false,
+                           bool IsStdInvoke = false);
   Expr *BuildBuiltinCallExpr(SourceLocation Loc, Builtin::ID Id,
                              MultiExprArg CallArgs);
   enum class AtomicArgumentOrder { API, AST };
   ExprResult
   BuildAtomicExpr(SourceRange CallRange, SourceRange ExprRange,
                   SourceLocation RParenLoc, MultiExprArg Args,
                   AtomicExpr::AtomicOp Op,
                   AtomicArgumentOrder ArgOrder = AtomicArgumentOrder::API);
   ExprResult
   BuildResolvedCallExpr(Expr *Fn, NamedDecl *NDecl, SourceLocation LParenLoc,
                         ArrayRef<Expr *> Arg, SourceLocation RParenLoc,
                         Expr *Config = nullptr, bool IsExecConfig = false,
-                        ADLCallKind UsesADL = ADLCallKind::NotADL);
+                        ADLCallKind UsesADL = ADLCallKind::NotADL,
+                        bool IsStdInvoke = false);
 
   ExprResult ActOnCUDAExecConfigExpr(Scope *S, SourceLocation LLLLoc,
                                      MultiExprArg ExecConfig,
                                      SourceLocation GGGLoc);
 
   ExprResult ActOnCastExpr(Scope *S, SourceLocation LParenLoc,
                            Declarator &D, ParsedType &Ty,
                            SourceLocation RParenLoc, Expr *CastExpr);
ExprResult ActOnDesignatedInitializer(Designation &Desig,
                                         ExprResult Init);
 
 private:
   static BinaryOperatorKind ConvertTokenKindToBinaryOpcode(tok::TokenKind Kind);
 
 public:
   ExprResult ActOnBinOp(Scope *S, SourceLocation TokLoc,
                         tok::TokenKind Kind, Expr *LHSExpr, Expr *RHSExpr);
-  ExprResult BuildBinOp(Scope *S, SourceLocation OpLoc,
-                        BinaryOperatorKind Opc, Expr *LHSExpr, Expr *RHSExpr);
+  ExprResult BuildBinOp(Scope *S, SourceLocation OpLoc, BinaryOperatorKind Opc,
+                        Expr *LHSExpr, Expr *RHSExpr, bool IsStdInvoke = false);
   ExprResult CreateBuiltinBinOp(SourceLocation OpLoc, BinaryOperatorKind Opc,
-                                Expr *LHSExpr, Expr *RHSExpr);
+                                Expr *LHSExpr, Expr *RHSExpr,
+                                bool IsStdInvoke = false);
   void LookupBinOp(Scope *S, SourceLocation OpLoc, BinaryOperatorKind Opc,
                    UnresolvedSetImpl &Functions);
 
   void DiagnoseCommaOperator(const Expr *LHS, SourceLocation Loc);
 
   /// ActOnConditionalOp - Parse a ?: operation.  Note that 'LHS' may be null
   /// in the case of a the GNU conditional expr extension.
   ExprResult ActOnConditionalOp(SourceLocation QuestionLoc,
public:
   /// or a null QualType (indicating an error diagnostic was issued).
 
   /// type checking binary operators (subroutines of CreateBuiltinBinOp).
   QualType InvalidOperands(SourceLocation Loc, ExprResult &LHS,
                            ExprResult &RHS);
   QualType InvalidLogicalVectorOperands(SourceLocation Loc, ExprResult &LHS,
                                  ExprResult &RHS);
   QualType CheckPointerToMemberOperands( // C++ 5.5
-    ExprResult &LHS, ExprResult &RHS, ExprValueKind &VK,
-    SourceLocation OpLoc, bool isIndirect);
+      ExprResult &LHS, ExprResult &RHS, ExprValueKind &VK, SourceLocation OpLoc,
+      bool isIndirect, bool IsStdInvoke = false);
   QualType CheckMultiplyDivideOperands( // C99 6.5.5
     ExprResult &LHS, ExprResult &RHS, SourceLocation Loc, bool IsCompAssign,
     bool IsDivide);
   QualType CheckRemainderOperands( // C99 6.5.5
     ExprResult &LHS, ExprResult &RHS, SourceLocation Loc,
     bool IsCompAssign = false);
   QualType CheckAdditionOperands( // C99 6.5.6
     ExprResult &LHS, ExprResult &RHS, SourceLocation Loc,

clang/lib/AST/ExprConstant.cpp

bool LValueExprEvaluator::VisitVarDecl(const Expr *E, const VarDecl *VD) {
   }
   return Success(*V, E);
 }
 
 bool LValueExprEvaluator::VisitCallExpr(const CallExpr *E) {
   switch (E->getBuiltinCallee()) {
   case Builtin::BIas_const:
   case Builtin::BIforward:
+  case Builtin::BIinvoke:
+  case Builtin::BIinvoke_r:
   case Builtin::BImove:
   case Builtin::BImove_if_noexcept:
     if (cast<FunctionDecl>(E->getCalleeDecl())->isConstexpr())
       return Visit(E->getArg(0));
     break;
   }
 
   return ExprEvaluatorBaseTy::VisitCallExpr(E);

clang/lib/CodeGen/CGBuiltin.cpp

case Builtin::BI_setjmp:
     }
     break;
 
   // C++ std:: builtins.
   case Builtin::BImove:
   case Builtin::BImove_if_noexcept:
   case Builtin::BIforward:
   case Builtin::BIas_const:
+  case Builtin::BIinvoke:
+  case Builtin::BIinvoke_r:
     return RValue::get(EmitLValue(E->getArg(0)).getPointer(*this));
   case Builtin::BI__GetExceptionInfo: {
     if (llvm::GlobalVariable *GV =
             CGM.getCXXABI().getThrowInfo(FD->getParamDecl(0)->getType()))
       return RValue::get(llvm::ConstantExpr::getBitCast(GV, CGM.Int8PtrTy));
     break;
   }
 

clang/lib/Sema/SemaChecking.cpp

 #include "clang/AST/DeclarationName.h"
 #include "clang/AST/EvaluatedExprVisitor.h"
 #include "clang/AST/Expr.h"
 #include "clang/AST/ExprCXX.h"
 #include "clang/AST/ExprObjC.h"
 #include "clang/AST/ExprOpenMP.h"
 #include "clang/AST/FormatString.h"
 #include "clang/AST/NSAPI.h"
+#include "clang/AST/NestedNameSpecifier.h"
 #include "clang/AST/NonTrivialTypeVisitor.h"
 #include "clang/AST/OperationKinds.h"
 #include "clang/AST/RecordLayout.h"
 #include "clang/AST/Stmt.h"
 #include "clang/AST/TemplateBase.h"
 #include "clang/AST/Type.h"
 #include "clang/AST/TypeLoc.h"
 #include "clang/AST/UnresolvedSet.h"
if (!(Param->isReferenceType() &&
           Context.hasSameUnqualifiedType(Param->getPointeeType(),
                                          Result->getPointeeType()))) {
       Diag(TheCall->getBeginLoc(), diag::err_builtin_move_forward_unsupported)
           << FDecl;
       return ExprError();
     }
     break;
   }
+  case Builtin::BIinvoke:
+  case Builtin::BIinvoke_r: {
+    TheCallResult = BuildStdInvokeCall(TheCall, FDecl, BuiltinID);
+    break;
+  }
   // OpenCL v2.0, s6.13.16 - Pipe functions
   case Builtin::BIread_pipe:
   case Builtin::BIwrite_pipe:
     // Since those two functions are declared with var args, we need a semantic
     // check for the argument.
     if (SemaBuiltinRWPipe(*this, TheCall))
       return ExprError();
     break;

clang/lib/Sema/SemaDecl.cpp

static bool isStdBuiltin(ASTContext &Ctx, FunctionDecl *FD,
   case Builtin::BImove_if_noexcept:
   case Builtin::BIas_const: {
     // Ensure that we don't treat the algorithm
     //   OutputIt std::move(InputIt, InputIt, OutputIt)
     // as the builtin std::move.
     const auto *FPT = FD->getType()->castAs<FunctionProtoType>();
     return FPT->getNumParams() == 1 && !FPT->isVariadic();
   }
+  case Builtin::BIinvoke:
+  case Builtin::BIinvoke_r:
+    return true;
 
   default:
     return false;
   }
 }
 
 NamedDecl*
 Sema::ActOnFunctionDeclarator(Scope *S, Declarator &D, DeclContext *DC,

clang/lib/Sema/SemaExpr.cpp

 ///
 /// \returns true if there was an error (this declaration cannot be
 /// referenced), false otherwise.
 ///
 bool Sema::DiagnoseUseOfDecl(NamedDecl *D, ArrayRef<SourceLocation> Locs,
                              const ObjCInterfaceDecl *UnknownObjCClass,
                              bool ObjCPropertyAccess,
                              bool AvoidPartialAvailabilityChecks,
-                             ObjCInterfaceDecl *ClassReceiver) {
+                             ObjCInterfaceDecl *ClassReceiver,
+                             bool IsStdInvoke) {
   SourceLocation Loc = Locs.front();
   if (getLangOpts().CPlusPlus && isa<FunctionDecl>(D)) {
     // If there were any diagnostics suppressed by template argument deduction,
     // emit them now.
     auto Pos = SuppressedDiagnostics.find(D->getCanonicalDecl());
     if (Pos != SuppressedDiagnostics.end()) {
       for (const PartialDiagnosticAt &Suppressed : Pos->second)
         Diag(Suppressed.first, Suppressed.second);
if (ParsingInitForAutoVars.count(D)) {
     }
     return true;
   }
 
   if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
     // See if this is a deleted function.
     if (FD->isDeleted()) {
       auto *Ctor = dyn_cast<CXXConstructorDecl>(FD);
+      if (!IsStdInvoke) {
         if (Ctor && Ctor->isInheritingConstructor())
           Diag(Loc, diag::err_deleted_inherited_ctor_use)
               << Ctor->getParent()
               << Ctor->getInheritedConstructor().getConstructor()->getParent();
         else
           Diag(Loc, diag::err_deleted_function_use);
         NoteDeletedFunction(FD);
+      }
       return true;
     }
 
     // [expr.prim.id]p4
     //   A program that refers explicitly or implicitly to a function with a
     //   trailing requires-clause whose constraint-expression is not satisfied,
     //   other than to declare it, is ill-formed. [...]
     //

 }
 
 /// ConvertArgumentsForCall - Converts the arguments specified in
 /// Args/NumArgs to the parameter types of the function FDecl with
 /// function prototype Proto. Call is the call expression itself, and
 /// Fn is the function expression. For a C++ member function, this
 /// routine does not attempt to convert the object argument. Returns
 /// true if the call is ill-formed.
-bool
-Sema::ConvertArgumentsForCall(CallExpr *Call, Expr *Fn,
+bool Sema::ConvertArgumentsForCall(CallExpr *Call, Expr *Fn,
                                    FunctionDecl *FDecl,
                                    const FunctionProtoType *Proto,
                                    ArrayRef<Expr *> Args,
-                              SourceLocation RParenLoc,
-                              bool IsExecConfig) {
+                                   SourceLocation RParenLoc, bool IsExecConfig,
+                                   bool IsStdInvoke) {
   // Bail out early if calling a builtin with custom typechecking.
   if (FDecl)
     if (unsigned ID = FDecl->getBuiltinID())
       if (Context.BuiltinInfo.hasCustomTypechecking(ID))
         return false;
 
   // C99 6.5.2.2p7 - the arguments are implicitly converted, as if by
   // assignment, to the types of the corresponding parameter, ...
   unsigned NumParams = Proto->getNumParams();
   bool Invalid = false;
   unsigned MinArgs = FDecl ? FDecl->getMinRequiredArguments() : NumParams;
   unsigned FnKind = Fn->getType()->isBlockPointerType()
                        ? 1 /* block */
                        : (IsExecConfig ? 3 /* kernel function (exec config) */
                                        : 0 /* function */);
 
   // If too few arguments are available (and we don't have default
   // arguments for the remaining parameters), don't make the call.
   if (Args.size() < NumParams) {
     if (Args.size() < MinArgs) {
       TypoCorrection TC;
-      if (FDecl && (TC = TryTypoCorrectionForCall(*this, Fn, FDecl, Args))) {
+      if (IsStdInvoke) {
+        QualType FnType = Fn->getType();
+        unsigned Kind = FnType->isRecordType() ? 3 // function object
+                        : isa<BinaryOperator>(Fn)
+                            ? 2 // pointer-to-member-function
+                        : FnType->isBlockPointerType() ? 1  // block
+                                                       : 0; // function
+        Diag(Call->getBeginLoc(), diag::err_invoke_wrong_number_of_args)
+            << Kind << NumParams << (NumParams != 1) << Args.size();
+      } else if (FDecl &&
+                 (TC = TryTypoCorrectionForCall(*this, Fn, FDecl, Args))) {
         unsigned diag_id =
             MinArgs == NumParams && !Proto->isVariadic()
                 ? diag::err_typecheck_call_too_few_args_suggest
                 : diag::err_typecheck_call_too_few_args_at_least_suggest;
         diagnoseTypo(TC, PDiag(diag_id) << FnKind << MinArgs
                                         << static_cast<unsigned>(Args.size())
                                         << TC.getCorrectionRange());
       } else if (MinArgs == 1 && FDecl && FDecl->getParamDecl(0)->getDeclName())
assert((Call->getNumArgs() == NumParams) &&
            "We should have reserved space for the default arguments before!");
   }
 
   // If too many are passed and not variadic, error on the extras and drop
   // them.
   if (Args.size() > NumParams) {
     if (!Proto->isVariadic()) {
       TypoCorrection TC;
-      if (FDecl && (TC = TryTypoCorrectionForCall(*this, Fn, FDecl, Args))) {
+      if (IsStdInvoke) {
+        QualType FnType = Fn->getType();
+        unsigned Kind = FnType->isRecordType() ? 3 // function object
+                        : isa<BinaryOperator>(Fn)
+                            ? 2 // pointer-to-member-function
+                        : FnType->isBlockPointerType() ? 1  // block
+                                                       : 0; // function
+        Diag(Call->getBeginLoc(), diag::err_invoke_wrong_number_of_args)
+            << Kind << NumParams << (NumParams != 1) << Args.size();
+      } else if (FDecl &&
+                 (TC = TryTypoCorrectionForCall(*this, Fn, FDecl, Args))) {
         unsigned diag_id =
             MinArgs == NumParams && !Proto->isVariadic()
                 ? diag::err_typecheck_call_too_many_args_suggest
                 : diag::err_typecheck_call_too_many_args_at_most_suggest;
         diagnoseTypo(TC, PDiag(diag_id) << FnKind << NumParams
                                         << static_cast<unsigned>(Args.size())
                                         << TC.getCorrectionRange());
       } else if (NumParams == 1 && FDecl &&

 }
 
 /// BuildCallExpr - Handle a call to Fn with the specified array of arguments.
 /// This provides the location of the left/right parens and a list of comma
 /// locations.
 ExprResult Sema::BuildCallExpr(Scope *Scope, Expr *Fn, SourceLocation LParenLoc,
                                MultiExprArg ArgExprs, SourceLocation RParenLoc,
                                Expr *ExecConfig, bool IsExecConfig,
-                               bool AllowRecovery) {
+                               bool AllowRecovery, bool IsStdInvoke) {
   // Since this might be a postfix expression, get rid of ParenListExprs.
   ExprResult Result = MaybeConvertParenListExprToParenExpr(Scope, Fn);
   if (Result.isInvalid()) return ExprError();
   Fn = Result.get();
 
   if (checkArgsForPlaceholders(*this, ArgExprs))
     return ExprError();
 
if (Fn->isTypeDependent() || Expr::hasAnyTypeDependentArguments(ArgExprs)) {
         return CallExpr::Create(Context, Fn, ArgExprs, Context.DependentTy,
                                 VK_PRValue, RParenLoc, CurFPFeatureOverrides());
       }
     }
 
     // Determine whether this is a call to an object (C++ [over.call.object]).
     if (Fn->getType()->isRecordType())
       return BuildCallToObjectOfClassType(Scope, Fn, LParenLoc, ArgExprs,
-                                          RParenLoc);
+                                          RParenLoc, IsStdInvoke);
 
     if (Fn->getType() == Context.UnknownAnyTy) {
       ExprResult result = rebuildUnknownAnyFunction(*this, Fn);
       if (result.isInvalid()) return ExprError();
       Fn = result.get();
     }
 
     if (Fn->getType() == Context.BoundMemberTy) {
QualType ReturnType =
         llvm::isa_and_nonnull<FunctionDecl>(NDecl)
             ? cast<FunctionDecl>(NDecl)->getCallResultType()
             : Context.DependentTy;
     return CallExpr::Create(Context, Fn, ArgExprs, ReturnType,
                             Expr::getValueKindForType(ReturnType), RParenLoc,
                             CurFPFeatureOverrides());
   }
   return BuildResolvedCallExpr(Fn, NDecl, LParenLoc, ArgExprs, RParenLoc,
-                               ExecConfig, IsExecConfig);
+                               ExecConfig, IsExecConfig, ADLCallKind::NotADL,
+                               IsStdInvoke);
 }
 
 /// BuildBuiltinCallExpr - Create a call to a builtin function specified by Id
 //  with the specified CallArgs
 Expr *Sema::BuildBuiltinCallExpr(SourceLocation Loc, Builtin::ID Id,
                                  MultiExprArg CallArgs) {
   StringRef Name = Context.BuiltinInfo.getName(Id);
   LookupResult R(*this, &Context.Idents.get(Name), Loc,

 /// unary-convert to an expression of function-pointer or
 /// block-pointer type.
 ///
 /// \param NDecl the declaration being called, if available
 ExprResult Sema::BuildResolvedCallExpr(Expr *Fn, NamedDecl *NDecl,
                                        SourceLocation LParenLoc,
                                        ArrayRef<Expr *> Args,
                                        SourceLocation RParenLoc, Expr *Config,
-                                       bool IsExecConfig, ADLCallKind UsesADL) {
+                                       bool IsExecConfig, ADLCallKind UsesADL,
+                                       bool IsStdInvoke) {
   FunctionDecl *FDecl = dyn_cast_or_null<FunctionDecl>(NDecl);
   unsigned BuiltinID = (FDecl ? FDecl->getBuiltinID() : 0);
 
   // Functions with 'interrupt' attribute cannot be called directly.
   if (FDecl && FDecl->hasAttr<AnyX86InterruptAttr>()) {
     Diag(Fn->getExprLoc(), diag::err_anyx86_interrupt_called);
     return ExprError();
   }
if (CheckCallReturnType(FuncT->getReturnType(), Fn->getBeginLoc(), TheCall,
     return ExprError();
 
   // We know the result type of the call, set it.
   TheCall->setType(FuncT->getCallResultType(Context));
   TheCall->setValueKind(Expr::getValueKindForType(FuncT->getReturnType()));
 
   if (Proto) {
     if (ConvertArgumentsForCall(TheCall, Fn, FDecl, Proto, Args, RParenLoc,
-                                IsExecConfig))
+                                IsExecConfig, IsStdInvoke))
       return ExprError();
   } else {
     assert(isa<FunctionNoProtoType>(FuncT) && "Unknown FunctionType!");
 
     if (FDecl) {
       // Check if we have too few/too many template arguments, based
       // on our knowledge of the function definition.
       const FunctionDecl *Def = nullptr;
if (const FunctionDecl* FD = dyn_cast<FunctionDecl>(Param->getDeclContext()))
     if (!FD->hasAttr<NonNullAttr>() && !Param->hasAttr<NonNullAttr>())
       return;
   if (FunctionScopeInfo *FD = S.getCurFunction())
     FD->ModifiedNonNullParams.insert(Param);
 }
 
 /// CheckIndirectionOperand - Type check unary indirection (prefix '*').
 static QualType CheckIndirectionOperand(Sema &S, Expr *Op, ExprValueKind &VK,
-                                        SourceLocation OpLoc) {
+                                        SourceLocation OpLoc,
+                                        bool IsStdInvoke = false) {
   if (Op->isTypeDependent())
     return S.Context.DependentTy;
 
   ExprResult ConvResult = S.UsualUnaryConversions(Op);
   if (ConvResult.isInvalid())
     return QualType();
   Op = ConvResult.get();
   QualType OpTy = Op->getType();
static QualType CheckIndirectionOperand(Sema &S, Expr *Op, ExprValueKind &VK,
   else {
     ExprResult PR = S.CheckPlaceholderExpr(Op);
     if (PR.isInvalid()) return QualType();
     if (PR.get() != Op)
       return CheckIndirectionOperand(S, PR.get(), VK, OpLoc);
   }
 
   if (Result.isNull()) {
+    if (!IsStdInvoke)
       S.Diag(OpLoc, diag::err_typecheck_indirection_requires_pointer)
           << OpTy << Op->getSourceRange();
     return QualType();
   }
 
   // Note that per both C89 and C99, indirection is always legal, even if Result
   // is an incomplete type or void.  It would be possible to warn about
   // dereferencing a void pointer, but it's completely well-defined, and such a
   // warning is unlikely to catch any mistakes. In C++, indirection is not valid
   // for pointers to 'void' but is fine for any other pointer type:
static bool needsConversionOfHalfVec(bool OpRequiresConversion, ASTContext &Ctx,
 
   return HasVectorOfHalfType(E0) && (!E1 || HasVectorOfHalfType(E1));
 }
 
 /// CreateBuiltinBinOp - Creates a new built-in binary operation with
 /// operator @p Opc at location @c TokLoc. This routine only supports
 /// built-in operations; ActOnBinOp handles overloaded operators.
 ExprResult Sema::CreateBuiltinBinOp(SourceLocation OpLoc,
-                                    BinaryOperatorKind Opc,
-                                    Expr *LHSExpr, Expr *RHSExpr) {
+                                    BinaryOperatorKind Opc, Expr *LHSExpr,
+                                    Expr *RHSExpr, bool IsStdInvoke) {
   if (getLangOpts().CPlusPlus11 && isa<InitListExpr>(RHSExpr)) {
     // The syntax only allows initializer lists on the RHS of assignment,
     // so we don't need to worry about accepting invalid code for
     // non-assignment operators.
     // C++11 5.17p9:
     //   The meaning of x = {v} [...] is that of x = T(v) [...]. The meaning
     //   of x = {} is x = T().
     InitializationKind Kind = InitializationKind::CreateDirectList(
if (!ResultTy.isNull()) {
         checkNonTrivialCUnion(LHS.get()->getType(), LHS.get()->getExprLoc(),
                               NTCUC_Assignment, NTCUK_Copy);
     }
     RecordModifiableNonNullParam(*this, LHS.get());
     break;
   case BO_PtrMemD:
   case BO_PtrMemI:
     ResultTy = CheckPointerToMemberOperands(LHS, RHS, VK, OpLoc,
-                                            Opc == BO_PtrMemI);
+                                            Opc == BO_PtrMemI, IsStdInvoke);
     break;
   case BO_Mul:
   case BO_Div:
     ConvertHalfVec = true;
     ResultTy = CheckMultiplyDivideOperands(LHS, RHS, OpLoc, false,
                                            Opc == BO_Div);
     break;
   case BO_Rem:
void Sema::LookupBinOp(Scope *S, SourceLocation OpLoc, BinaryOperatorKind Opc,
   if (getLangOpts().CPlusPlus20) {
     if (OverloadedOperatorKind ExtraOp = getRewrittenOverloadedOperator(OverOp))
       LookupOverloadedOperatorName(ExtraOp, S, Functions);
   }
 }
 
 /// Build an overloaded binary operator expression in the given scope.
 static ExprResult BuildOverloadedBinOp(Sema &S, Scope *Sc, SourceLocation OpLoc,
-                                       BinaryOperatorKind Opc,
-                                       Expr *LHS, Expr *RHS) {
+                                       BinaryOperatorKind Opc, Expr *LHS,
+                                       Expr *RHS, bool IsStdInvoke = false) {
   switch (Opc) {
   case BO_Assign:
   case BO_DivAssign:
   case BO_RemAssign:
   case BO_SubAssign:
   case BO_AndAssign:
   case BO_OrAssign:
   case BO_XorAssign:
     DiagnoseSelfAssignment(S, LHS, RHS, OpLoc, false);
     CheckIdentityFieldAssignment(LHS, RHS, OpLoc, S);
     break;
   default:
     break;
   }
 
   // Find all of the overloaded operators visible from this point.
   UnresolvedSet<16> Functions;
   S.LookupBinOp(Sc, OpLoc, Opc, Functions);
 
   // Build the (potentially-overloaded, potentially-dependent)
   // binary operation.
-  return S.CreateOverloadedBinOp(OpLoc, Opc, Functions, LHS, RHS);
+  return S.CreateOverloadedBinOp(OpLoc, Opc, Functions, LHS, RHS, true, true,
+                                 nullptr, IsStdInvoke);
 }
 
 ExprResult Sema::BuildBinOp(Scope *S, SourceLocation OpLoc,
-                            BinaryOperatorKind Opc,
-                            Expr *LHSExpr, Expr *RHSExpr) {
+                            BinaryOperatorKind Opc, Expr *LHSExpr,
+                            Expr *RHSExpr, bool IsStdInvoke) {
   ExprResult LHS, RHS;
   std::tie(LHS, RHS) = CorrectDelayedTyposInBinOp(*this, Opc, LHSExpr, RHSExpr);
   if (!LHS.isUsable() || !RHS.isUsable())
     return ExprError();
   LHSExpr = LHS.get();
   RHSExpr = RHS.get();
 
   // We want to end up calling one of checkPseudoObjectAssignment
if (getLangOpts().CPlusPlus) {
     // overloaded op.
     if (LHSExpr->isTypeDependent() || RHSExpr->isTypeDependent())
       return BuildOverloadedBinOp(*this, S, OpLoc, Opc, LHSExpr, RHSExpr);
 
     // Otherwise, build an overloaded op if either expression has an
     // overloadable type.
     if (LHSExpr->getType()->isOverloadableType() ||
         RHSExpr->getType()->isOverloadableType())
-      return BuildOverloadedBinOp(*this, S, OpLoc, Opc, LHSExpr, RHSExpr);
+      return BuildOverloadedBinOp(*this, S, OpLoc, Opc, LHSExpr, RHSExpr,
+                                  IsStdInvoke);
   }
 
   if (getLangOpts().RecoveryAST &&
       (LHSExpr->isTypeDependent() || RHSExpr->isTypeDependent())) {
     assert(!getLangOpts().CPlusPlus);
     assert((LHSExpr->containsErrors() || RHSExpr->containsErrors()) &&
            "Should only occur in error-recovery path.");
     if (BinaryOperator::isCompoundAssignmentOp(Opc))
static bool isOverflowingIntegerType(ASTContext &Ctx, QualType T) {
 
   if (!T->isPromotableIntegerType())
     return true;
 
   return Ctx.getIntWidth(T) >= Ctx.getIntWidth(Ctx.IntTy);
 }
 
 ExprResult Sema::CreateBuiltinUnaryOp(SourceLocation OpLoc,
-                                      UnaryOperatorKind Opc,
-                                      Expr *InputExpr) {
+                                      UnaryOperatorKind Opc, Expr *InputExpr,
+                                      bool IsStdInvoke) {
   ExprResult Input = InputExpr;
   ExprValueKind VK = VK_PRValue;
   ExprObjectKind OK = OK_Ordinary;
   QualType resultType;
   bool CanOverflow = false;
 
   bool ConvertHalfVec = false;
   if (getLangOpts().OpenCL) {
ExprResult Sema::CreateBuiltinUnaryOp(SourceLocation OpLoc,
   case UO_AddrOf:
     resultType = CheckAddressOfOperand(Input, OpLoc);
     CheckAddressOfNoDeref(InputExpr);
     RecordModifiableNonNullParam(*this, InputExpr);
     break;
   case UO_Deref: {
     Input = DefaultFunctionArrayLvalueConversion(Input.get());
     if (Input.isInvalid()) return ExprError();
-    resultType = CheckIndirectionOperand(*this, Input.get(), VK, OpLoc);
+    resultType =
+        CheckIndirectionOperand(*this, Input.get(), VK, OpLoc, IsStdInvoke);
     break;
   }
   case UO_Plus:
   case UO_Minus:
     CanOverflow = Opc == UO_Minus &&
                   isOverflowingIntegerType(Context, Input.get()->getType());
     Input = UsualUnaryConversions(Input.get());
     if (Input.isInvalid()) return ExprError();
if (UnresolvedLookupExpr *ULE = dyn_cast<UnresolvedLookupExpr>(E)) {
 
     return false;
   }
 
   return false;
 }
 
 ExprResult Sema::BuildUnaryOp(Scope *S, SourceLocation OpLoc,
-                              UnaryOperatorKind Opc, Expr *Input) {
+                              UnaryOperatorKind Opc, Expr *Input,
+                              bool IsStdInvoke) {
   // First things first: handle placeholders so that the
   // overloaded-operator check considers the right type.
   if (const BuiltinType *pty = Input->getType()->getAsPlaceholderType()) {
     // Increment and decrement of pseudo-object references.
     if (pty->getKind() == BuiltinType::PseudoObject &&
         UnaryOperator::isIncrementDecrementOp(Opc))
       return checkPseudoObjectIncDec(S, OpLoc, Opc, Input);
 
if (getLangOpts().CPlusPlus && Input->getType()->isOverloadableType() &&
       UnaryOperator::getOverloadedOperator(Opc) != OO_None &&
       !(Opc == UO_AddrOf && isQualifiedMemberAccess(Input))) {
     // Find all of the overloaded operators visible from this point.
     UnresolvedSet<16> Functions;
     OverloadedOperatorKind OverOp = UnaryOperator::getOverloadedOperator(Opc);
     if (S && OverOp != OO_None)
       LookupOverloadedOperatorName(OverOp, S, Functions);
 
-    return CreateOverloadedUnaryOp(OpLoc, Opc, Functions, Input);
+    return CreateOverloadedUnaryOp(OpLoc, Opc, Functions, Input,
+                                   /*RequiresADL*/ true, IsStdInvoke);
   }
 
   return CreateBuiltinUnaryOp(OpLoc, Opc, Input);
 }
 
 // Unary Operators.  'Tok' is the token for the operator.
 ExprResult Sema::ActOnUnaryOp(Scope *S, SourceLocation OpLoc,
                               tok::TokenKind Op, Expr *Input) {

clang/lib/Sema/SemaExprCXX.cpp

 //===----------------------------------------------------------------------===//
 
 #include "TreeTransform.h"
 #include "TypeLocBuilder.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/ASTLambda.h"
 #include "clang/AST/CXXInheritance.h"
 #include "clang/AST/CharUnits.h"
+#include "clang/AST/DeclBase.h"
 #include "clang/AST/DeclObjC.h"
+#include "clang/AST/Expr.h"
 #include "clang/AST/ExprCXX.h"
 #include "clang/AST/ExprObjC.h"
 #include "clang/AST/RecursiveASTVisitor.h"
 #include "clang/AST/TypeLoc.h"
 #include "clang/Basic/AlignedAllocation.h"
 #include "clang/Basic/DiagnosticSema.h"
 #include "clang/Basic/PartialDiagnostic.h"
+#include "clang/Basic/SourceLocation.h"
 #include "clang/Basic/TargetInfo.h"
+#include "clang/Basic/TokenKinds.h"
 #include "clang/Basic/TypeTraits.h"
 #include "clang/Lex/Preprocessor.h"
 #include "clang/Sema/DeclSpec.h"
 #include "clang/Sema/Initialization.h"
 #include "clang/Sema/Lookup.h"
 #include "clang/Sema/ParsedTemplate.h"
 #include "clang/Sema/Scope.h"
 #include "clang/Sema/ScopeInfo.h"
case BTT_IsTriviallyAssignable: {
     llvm_unreachable("unhandled type trait");
     return false;
   }
     default: llvm_unreachable("not a BTT");
   }
   llvm_unreachable("Unknown type trait or not implemented");
 }
 
+static ExprResult HandleInvokePointerToMemberFunction(
+    Sema &S, const MemberPointerType *CalleeType, bool,
+    SourceLocation LParenLoc, Expr *F, MultiExprArg Args,
+    SourceLocation RParenLoc) {
+  assert(CalleeType->isMemberFunctionPointer());
+  ExprResult B = S.BuildBinOp(S.getCurScope(), LParenLoc,
+                              BinaryOperatorKind::BO_PtrMemD, Args[0], F, true);
+  if (B.isInvalid()) {
+    return ExprError();
+  }
+
+  return S.BuildCallToMemberFunction(
+      S.getCurScope(), B.get(), LParenLoc, Args.drop_front(), RParenLoc,
+      /*ExecConfig*/ nullptr, /*IsExecConfig*/ false, /*AllowRecovery*/ false,
+      /*IsStdInvoke*/ true);
+}
+
+static ExprResult
+HandleInvokePointerToDataMember(Sema &S, const MemberPointerType *CalleeType,
+                                bool IsInvokeR, SourceLocation LParenLoc,
+                                Expr *F, MultiExprArg Args,
+                                SourceLocation RParenLoc) {
+  return S.BuildBinOp(S.getCurScope(), LParenLoc,
+                      BinaryOperatorKind::BO_PtrMemD, Args[0], F);
+}
+
+static ExprResult
+HandleInvokePointerToMember(Sema &S, const MemberPointerType *CalleeType,
+                            bool IsInvokeR, SourceLocation LParenLoc, Expr *F,
+                            MultiExprArg Args, SourceLocation RParenLoc) {
+  auto *Fn = CalleeType->isMemberFunctionPointer()
+                 ? HandleInvokePointerToMemberFunction
+                 : HandleInvokePointerToDataMember;
+  return Fn(S, CalleeType, IsInvokeR, LParenLoc, F, Args, RParenLoc);
+}
+
+static ExprResult UnwrapReferenceWrapper(Sema &S, QualType &FirstArgType,
+                                         Expr *Arg) {
+  auto *D = dyn_cast<ClassTemplateSpecializationDecl>(
+      FirstArgType.getDesugaredType(S.Context)->getAsRecordDecl());
+  FirstArgType = S.BuiltinAddReference(D->getTemplateArgs().get(0).getAsType(),
+                                       Sema::UTTKind::AddLvalueReference,
+                                       Arg->getExprLoc());
+  return S.BuildCXXNamedCast(Arg->getBeginLoc(), tok::kw_static_cast,
+                             S.Context.getTrivialTypeSourceInfo(FirstArgType),
+                             Arg, {}, Arg->getEndLoc());
+}
+
+static ExprResult HandleInvokePointerToMember(Sema &S, bool IsInvokeR,
+                                              QualType CalleeType,
+                                              SourceLocation LParenLoc, Expr *F,
+                                              MultiExprArg Args,
+                                              SourceLocation RParenLoc) {
+  auto *PtrToMember = CalleeType->getAs<MemberPointerType>();
+  if (Args.size() == 0 ||
+      (Args.size() > 1 && CalleeType->isMemberDataPointerType())) {
+    S.Diag(LParenLoc, diag::err_invoke_pointer_to_member_too_few_args)
+        << PtrToMember->isMemberFunctionPointer() << IsInvokeR << 1;
+    return ExprError();
+  }
+
+  QualType FirstArgType = Args[0]->getType();
+  QualType ClassType = QualType(PtrToMember->getClass(), 0);
+  bool IsBase = EvaluateBinaryTypeTrait(S, TypeTrait::BTT_IsBaseOf, ClassType,
+                                        FirstArgType.getNonReferenceType(), {});
+  if (IsBase)
+    return HandleInvokePointerToMember(S, PtrToMember, IsInvokeR, LParenLoc, F,
+                                       Args, RParenLoc);
+
+  if (RecordDecl *D = FirstArgType->getAsCXXRecordDecl()) {
+    bool IsReferenceWrapper =
+        D->isInStdNamespace() && D->getName() == "reference_wrapper";
+    if (IsReferenceWrapper) {
+      Args[0] = UnwrapReferenceWrapper(S, FirstArgType, Args[0]).get();
+      FirstArgType = Args[0]->getType();
+    }
+
+    IsBase = EvaluateBinaryTypeTrait(S, TypeTrait::BTT_IsBaseOf, ClassType,
+                                     FirstArgType, {});
+    if (IsBase)
+      return HandleInvokePointerToMember(S, PtrToMember, IsInvokeR, LParenLoc,
+                                         F, Args, RParenLoc);
+
+    if (IsReferenceWrapper) {
+      S.Diag(F->getBeginLoc(),
+             diag::err_invoke_pointer_to_member_incompatible_second_arg)
+          << CalleeType->isMemberFunctionPointerType() << 1
+          << PtrToMember->getClass()->getAsRecordDecl() << FirstArgType;
+      return ExprError();
+    }
+  }
+
+  ExprResult Deref = S.BuildUnaryOp(S.getCurScope(), LParenLoc,
+                                    UnaryOperatorKind::UO_Deref, Args[0], true);
+  if (Deref.isInvalid()) {
+    S.Diag(F->getBeginLoc(),
+           diag::err_invoke_pointer_to_member_incompatible_second_arg)
+        << CalleeType->isMemberFunctionPointerType() << 0
+        << PtrToMember->getClass()->getAsCXXRecordDecl() << FirstArgType;
+    return ExprError();
+  }
+
+  Args[0] = Deref.get();
+  IsBase = EvaluateBinaryTypeTrait(S, TypeTrait::BTT_IsBaseOf, ClassType,
+                                   Args[0]->getType(), {});
+  if (!IsBase) {
+    S.Diag(LParenLoc,
+           diag::err_invoke_pointer_to_member_incompatible_second_arg)
+        << PtrToMember->isMemberFunctionPointer() << 2
+        << PtrToMember->getClass()->getAsCXXRecordDecl() << FirstArgType;
+    return ExprError();
+  }
+
+  return HandleInvokePointerToMember(S, PtrToMember, IsInvokeR, LParenLoc, F,
+                                     Args, RParenLoc);
+}
+
+static ExprResult HandleInvoke(Sema &S, CallExpr *TheCall, bool IsInvokeR) {
+  Expr *F = TheCall->getArgs()[0];
+  QualType CalleeType = F->getType();
+  MultiExprArg Args(TheCall->getArgs() + 1, TheCall->getNumArgs() - 1);
+
+  // FIXME: remove this comment block once notes are addressed.
+  // Reviewer note 1: It really feels like there should be some way to use
+  // Context.getSubstTemplateTypeParmType, but it's not clear what the second
+  // argument should be.
+  // Reviewer note 2: Do we need to consider SubstTemplateTypeParmPackType too?
+  if (auto *T = dyn_cast<SubstTemplateTypeParmType>(CalleeType))
+    CalleeType = T->getReplacementType();
+
+  if (!CalleeType->isMemberPointerType()) {
+    return S.BuildCallExpr(S.getCurScope(), F, TheCall->getBeginLoc(), Args,
+                           TheCall->getEndLoc(), /*ExecConfig*/ nullptr,
+                           /*IsExecConfig*/ false, /*AllowRecovery*/ false,
+                           /*IsStdInvoke*/ true);
+  }
+
+  return HandleInvokePointerToMember(S, IsInvokeR, CalleeType,
+                                     TheCall->getBeginLoc(), F, Args,
+                                     TheCall->getEndLoc());
+}
+
+ExprResult Sema::BuildStdInvokeCall(CallExpr *TheCall, FunctionDecl *FDecl,
+                                    unsigned int BuiltinID) {
+  assert(TheCall->getNumArgs() > 0);
+
+  ExprResult Result =
+      HandleInvoke(*this, TheCall, BuiltinID == Builtin::BIinvoke_r);
+  if (BuiltinID == Builtin::BIinvoke || Result.isInvalid())
+    return Result;
+
+  QualType ResultType = Result.get()->getType();
+  QualType InvokeRType = FDecl->getReturnType();
+  if (!EvaluateBinaryTypeTrait(*this, TypeTrait::BTT_IsConvertibleTo,
+                               ResultType, InvokeRType, {})) {
+    QualType T = TheCall->getArgs()[0]->getType();
+    unsigned Kind = T->isRecordType() ? 4 // function object
+                    : T->isMemberFunctionPointerType()
+                        ? 3 // pointer-to-member function
+                    : T->isMemberDataPointerType() ? 2 // pointer-to-data member
+                    : T->isBlockPointerType()      ? 1 // block
+                                                   : 0;     // function
+    SemaDiagnosticBuilder B =
+        Diag(TheCall->getBeginLoc(), diag::err_invoke_bad_conversion)
+        << Kind << ResultType << InvokeRType;
+    if (T->isRecordType())
+      B << T;
+    return ExprError();
+  }
+
+  return BuildCXXNamedCast(TheCall->getBeginLoc(), tok::kw_static_cast,
+                           Context.getTrivialTypeSourceInfo(InvokeRType),
+                           Result.get(), TheCall->getBeginLoc(),
+                           TheCall->getBeginLoc());
+}
+
 ExprResult Sema::ActOnArrayTypeTrait(ArrayTypeTrait ATT,
                                      SourceLocation KWLoc,
                                      ParsedType Ty,
                                      Expr* DimExpr,
                                      SourceLocation RParen) {
   TypeSourceInfo *TSInfo;
   QualType T = GetTypeFromParser(Ty, &TSInfo);
   if (!TSInfo)
ExprResult Sema::BuildExpressionTrait(ExpressionTrait ET,
   bool Value = EvaluateExpressionTrait(ET, Queried);
 
   return new (Context)
       ExpressionTraitExpr(KWLoc, ET, Queried, Value, RParen, Context.BoolTy);
 }
 
 QualType Sema::CheckPointerToMemberOperands(ExprResult &LHS, ExprResult &RHS,
                                             ExprValueKind &VK,
-                                            SourceLocation Loc,
-                                            bool isIndirect) {
+                                            SourceLocation Loc, bool isIndirect,
+                                            bool IsStdInvoke) {
   assert(!LHS.get()->hasPlaceholderType() && !RHS.get()->hasPlaceholderType() &&
          "placeholders should have been weeded out by now");
 
   // The LHS undergoes lvalue conversions if this is ->*, and undergoes the
   // temporary materialization conversion otherwise.
   if (isIndirect)
     LHS = DefaultLvalueConversion(LHS.get());
   else if (LHS.get()->isPRValue())
if (const FunctionProtoType *Proto = Result->getAs<FunctionProtoType>()) {
     case RQ_LValue:
       if (!isIndirect && !LHS.get()->Classify(Context).isLValue()) {
         // C++2a allows functions with ref-qualifier & if their cv-qualifier-seq
         // is (exactly) 'const'.
         if (Proto->isConst() && !Proto->isVolatile())
           Diag(Loc, getLangOpts().CPlusPlus20
                         ? diag::warn_cxx17_compat_pointer_to_const_ref_member_on_rvalue
                         : diag::ext_pointer_to_const_ref_member_on_rvalue);
-        else
+        else if (!IsStdInvoke)
           Diag(Loc, diag::err_pointer_to_member_oper_value_classify)
               << RHSType << 1 << LHS.get()->getSourceRange();
+        else {
+          Diag(Loc, diag::err_invoke_pointer_to_member_ref_qualifiers)
+              << RHS.get() << 0;
+          return QualType();
+        }
       }
       break;
 
     case RQ_RValue:
-      if (isIndirect || !LHS.get()->Classify(Context).isRValue())
+      if (isIndirect || !LHS.get()->Classify(Context).isRValue()) {
+        if (!IsStdInvoke)
           Diag(Loc, diag::err_pointer_to_member_oper_value_classify)
               << RHSType << 0 << LHS.get()->getSourceRange();
+        else {
+          Diag(Loc, diag::err_invoke_pointer_to_member_ref_qualifiers)
+              << RHS.get() << 1;
+          return QualType();
+        }
+      }
       break;
     }
   }
 
   // C++ [expr.mptr.oper]p6:
   //   The result of a .* expression whose second operand is a pointer
   //   to a data member is of the same value category as its
   //   first operand. The result of a .* expression whose second

clang/lib/Sema/SemaOverload.cpp

 
 static bool functionHasPassObjectSizeParams(const FunctionDecl *FD) {
   return llvm::any_of(FD->parameters(), [](const ParmVarDecl *P) {
     return P->hasAttr<PassObjectSizeAttr>();
   });
 }
 
 /// A convenience routine for creating a decayed reference to a function.
-static ExprResult CreateFunctionRefExpr(
-    Sema &S, FunctionDecl *Fn, NamedDecl *FoundDecl, const Expr *Base,
-    bool HadMultipleCandidates, SourceLocation Loc = SourceLocation(),
-    const DeclarationNameLoc &LocInfo = DeclarationNameLoc()) {
-  if (S.DiagnoseUseOfDecl(FoundDecl, Loc))
+static ExprResult
+CreateFunctionRefExpr(Sema &S, FunctionDecl *Fn, NamedDecl *FoundDecl,
+                      const Expr *Base, bool HadMultipleCandidates,
+                      SourceLocation Loc = SourceLocation(),
+                      const DeclarationNameLoc &LocInfo = DeclarationNameLoc(),
+                      bool IsStdInvoke = false) {
+  if (S.DiagnoseUseOfDecl(FoundDecl, Loc, {}, {}, {}, {}, IsStdInvoke))
     return ExprError();
   // If FoundDecl is different from Fn (such as if one is a template
   // and the other a specialization), make sure DiagnoseUseOfDecl is
   // called on both.
   // FIXME: This would be more comprehensively addressed by modifying
   // DiagnoseUseOfDecl to accept both the FoundDecl and the decl
   // being used.
   if (FoundDecl != Fn && S.DiagnoseUseOfDecl(Fn, Loc))
if (getLangOpts().CPlusPlusModules && !MF->isModuleMapModule() &&
       /// FIXME: Currently, the semantics of linkage in clang is slightly
       /// different from the semantics in C++ spec. In C++ spec, only names
       /// have linkage. So that all entities of the same should share one
       /// linkage. But in clang, different entities of the same could have
       /// different linkage.
       NamedDecl *ND = Function;
       if (auto *SpecInfo = Function->getTemplateSpecializationInfo())
         ND = SpecInfo->getTemplate();
-      
       if (ND->getFormalLinkage() == Linkage::InternalLinkage) {
         Candidate.Viable = false;
         Candidate.FailureKind = ovl_fail_module_mismatched;
         return;
       }
     }
   }
 

 /// neither template is more specialized than the other.
 /// [over.match.best]p2.6
 /// F1 and F2 are non-template functions with the same parameter-type-lists,
 /// and F1 is more constrained than F2 [...]
 static bool canCompareFunctionConstraints(Sema &S,
                                           const OverloadCandidate &Cand1,
                                           const OverloadCandidate &Cand2) {
   // FIXME: Per P2113R0 we also need to compare the template parameter lists
-  // when comparing template functions. 
+  // when comparing template functions.
   if (Cand1.Function && Cand2.Function && Cand1.Function->hasPrototype() &&
       Cand2.Function->hasPrototype()) {
     auto *PT1 = cast<FunctionProtoType>(Cand1.Function->getFunctionType());
     auto *PT2 = cast<FunctionProtoType>(Cand2.Function->getFunctionType());
     if (PT1->getNumParams() == PT2->getNumParams() &&
         PT1->isVariadic() == PT2->isVariadic() &&
         S.FunctionParamTypesAreEqual(PT1, PT2, nullptr,
                                      Cand1.isReversed() ^ Cand2.isReversed()))

 /// \param Fns The set of non-member functions that will be
 /// considered by overload resolution. The caller needs to build this
 /// set based on the context using, e.g.,
 /// LookupOverloadedOperatorName() and ArgumentDependentLookup(). This
 /// set should not contain any member functions; those will be added
 /// by CreateOverloadedUnaryOp().
 ///
 /// \param Input The input argument.
-ExprResult
-Sema::CreateOverloadedUnaryOp(SourceLocation OpLoc, UnaryOperatorKind Opc,
+ExprResult Sema::CreateOverloadedUnaryOp(SourceLocation OpLoc,
+                                         UnaryOperatorKind Opc,
                                          const UnresolvedSetImpl &Fns,
-                              Expr *Input, bool PerformADL) {
+                                         Expr *Input, bool PerformADL,
+                                         bool IsStdInvoke) {
   OverloadedOperatorKind Op = UnaryOperator::getOverloadedOperator(Opc);
   assert(Op != OO_None && "Invalid opcode for overloaded unary operator");
   DeclarationName OpName = Context.DeclarationNames.getCXXOperatorName(Op);
   // TODO: provide better source location info.
   DeclarationNameInfo OpNameInfo(OpName, OpLoc);
 
   if (checkPlaceholderForOverload(*this, Input))
     return ExprError();
CandidateSet.NoteCandidates(
         *this, OCD_AllCandidates, ArgsArray, UnaryOperator::getOpcodeStr(Opc),
         OpLoc);
     return ExprError();
   }
 
   // Either we found no viable overloaded operator or we matched a
   // built-in operator. In either case, fall through to trying to
   // build a built-in operation.
-  return CreateBuiltinUnaryOp(OpLoc, Opc, Input);
+  return CreateBuiltinUnaryOp(OpLoc, Opc, Input, IsStdInvoke);
 }
 
 /// Perform lookup for an overloaded binary operator.
 void Sema::LookupOverloadedBinOp(OverloadCandidateSet &CandidateSet,
                                  OverloadedOperatorKind Op,
                                  const UnresolvedSetImpl &Fns,
                                  ArrayRef<Expr *> Args, bool PerformADL) {
   SourceLocation OpLoc = CandidateSet.getLocation();

 /// \param RHS Right-hand argument.
 /// \param PerformADL Whether to consider operator candidates found by ADL.
 /// \param AllowRewrittenCandidates Whether to consider candidates found by
 ///        C++20 operator rewrites.
 /// \param DefaultedFn If we are synthesizing a defaulted operator function,
 ///        the function in question. Such a function is never a candidate in
 ///        our overload resolution. This also enables synthesizing a three-way
 ///        comparison from < and == as described in C++20 [class.spaceship]p1.
-ExprResult Sema::CreateOverloadedBinOp(SourceLocation OpLoc,
-                                       BinaryOperatorKind Opc,
-                                       const UnresolvedSetImpl &Fns, Expr *LHS,
-                                       Expr *RHS, bool PerformADL,
-                                       bool AllowRewrittenCandidates,
-                                       FunctionDecl *DefaultedFn) {
+ExprResult
+Sema::CreateOverloadedBinOp(SourceLocation OpLoc, BinaryOperatorKind Opc,
+                            const UnresolvedSetImpl &Fns, Expr *LHS, Expr *RHS,
+                            bool PerformADL, bool AllowRewrittenCandidates,
+                            FunctionDecl *DefaultedFn, bool IsStdInvoke) {
   Expr *Args[2] = { LHS, RHS };
   LHS=RHS=nullptr; // Please use only Args instead of LHS/RHS couple
 
   if (!getLangOpts().CPlusPlus20)
     AllowRewrittenCandidates = false;
 
   OverloadedOperatorKind Op = BinaryOperator::getOverloadedOperator(Opc);
 
Sema::CreateOverloadedBinOp(SourceLocation OpLoc, BinaryOperatorKind Opc,
   // problems. So we do it this way, which pretty much follows what GCC does.
   // Note that we go the traditional code path for compound assignment forms.
   if (Opc == BO_Assign && !Args[0]->getType()->isOverloadableType())
     return CreateBuiltinBinOp(OpLoc, Opc, Args[0], Args[1]);
 
   // If this is the .* operator, which is not overloadable, just
   // create a built-in binary operator.
   if (Opc == BO_PtrMemD)
-    return CreateBuiltinBinOp(OpLoc, Opc, Args[0], Args[1]);
+    return CreateBuiltinBinOp(OpLoc, Opc, Args[0], Args[1], IsStdInvoke);
 
   // Build the overload set.
   OverloadCandidateSet CandidateSet(
       OpLoc, OverloadCandidateSet::CSK_Operator,
       OverloadCandidateSet::OperatorRewriteInfo(Op, AllowRewrittenCandidates));
   if (DefaultedFn)
     CandidateSet.exclude(DefaultedFn);
   LookupOverloadedBinOp(CandidateSet, Op, Fns, Args, PerformADL);

 
 /// BuildCallToMemberFunction - Build a call to a member
 /// function. MemExpr is the expression that refers to the member
 /// function (and includes the object parameter), Args/NumArgs are the
 /// arguments to the function call (not including the object
 /// parameter). The caller needs to validate that the member
 /// expression refers to a non-static member function or an overloaded
 /// member function.
-ExprResult Sema::BuildCallToMemberFunction(Scope *S, Expr *MemExprE,
-                                           SourceLocation LParenLoc,
-                                           MultiExprArg Args,
-                                           SourceLocation RParenLoc,
-                                           Expr *ExecConfig, bool IsExecConfig,
-                                           bool AllowRecovery) {
+ExprResult Sema::BuildCallToMemberFunction(
+    Scope *S, Expr *MemExprE, SourceLocation LParenLoc, MultiExprArg Args,
+    SourceLocation RParenLoc, Expr *ExecConfig, bool IsExecConfig,
+    bool AllowRecovery, bool IsStdInvoke) {
   assert(MemExprE->getType() == Context.BoundMemberTy ||
          MemExprE->getType() == Context.OverloadTy);
 
   // Dig out the member expression. This holds both the object
   // argument and the member function we're referring to.
   Expr *NakedMemExpr = MemExprE->IgnoreParens();
 
   // Determine whether this is a call to a pointer-to-member function.
if (op->getOpcode() == BO_PtrMemI)
       objectType = objectType->castAs<PointerType>()->getPointeeType();
     Qualifiers objectQuals = objectType.getQualifiers();
 
     Qualifiers difference = objectQuals - funcQuals;
     difference.removeObjCGCAttr();
     difference.removeAddressSpace();
     if (difference) {
       std::string qualsString = difference.getAsString();
+      if (!IsStdInvoke)
           Diag(LParenLoc, diag::err_pointer_to_member_call_drops_quals)
-        << fnType.getUnqualifiedType()
-        << qualsString
+              << fnType.getUnqualifiedType() << qualsString
+              << (qualsString.find(' ') == std::string::npos ? 1 : 2);
+      else {
+          Diag(LParenLoc, diag::err_invoke_pointer_to_member_drops_qualifiers)
+              << op->getRHS() << qualsString
               << (qualsString.find(' ') == std::string::npos ? 1 : 2);
+          return ExprError();
+      }
     }
 
     CXXMemberCallExpr *call = CXXMemberCallExpr::Create(
         Context, MemExprE, Args, resultType, valueKind, RParenLoc,
         CurFPFeatureOverrides(), proto->getNumParams());
 
     if (CheckCallReturnType(proto->getReturnType(), op->getRHS()->getBeginLoc(),
                             call, nullptr))
       return ExprError();
 
-    if (ConvertArgumentsForCall(call, op, nullptr, proto, Args, RParenLoc))
+    if (ConvertArgumentsForCall(call, op, nullptr, proto, Args, RParenLoc,
+                                false, IsStdInvoke))
       return ExprError();
 
     if (CheckOtherCall(call, proto))
       return ExprError();
 
     return MaybeBindToTemporary(call);
   }
 
ExprResult Sema::BuildCallToMemberFunction(
   return CheckForImmediateInvocation(MaybeBindToTemporary(TheCall),
                                      TheCall->getMethodDecl());
 }
 
 /// BuildCallToObjectOfClassType - Build a call to an object of class
 /// type (C++ [over.call.object]), which can end up invoking an
 /// overloaded function call operator (@c operator()) or performing a
 /// user-defined conversion on the object argument.
-ExprResult
-Sema::BuildCallToObjectOfClassType(Scope *S, Expr *Obj,
+ExprResult Sema::BuildCallToObjectOfClassType(Scope *S, Expr *Obj,
                                               SourceLocation LParenLoc,
                                               MultiExprArg Args,
-                                   SourceLocation RParenLoc) {
+                                              SourceLocation RParenLoc,
+                                              bool IsStdInvoke) {
   if (checkPlaceholderForOverload(*this, Obj))
     return ExprError();
   ExprResult Object = Obj;
 
   UnbridgedCastsSet UnbridgedCasts;
   if (checkArgPlaceholdersForOverload(*this, Args, UnbridgedCasts))
     return ExprError();
 
if (!Conv->isExplicit()) {
       }
     }
   }
 
   bool HadMultipleCandidates = (CandidateSet.size() > 1);
 
   // Perform overload resolution.
   OverloadCandidateSet::iterator Best;
+  QualType T = Object.get()->getType();
+  SourceRange SR = Object.get()->getSourceRange();
   switch (CandidateSet.BestViableFunction(*this, Object.get()->getBeginLoc(),
                                           Best)) {
   case OR_Success:
     // Overload resolution succeeded; we'll build the appropriate call
     // below.
     break;
 
   case OR_No_Viable_Function: {
     PartialDiagnostic PD =
         CandidateSet.empty()
-            ? (PDiag(diag::err_ovl_no_oper)
-               << Object.get()->getType() << /*call*/ 1
-               << Object.get()->getSourceRange())
-            : (PDiag(diag::err_ovl_no_viable_object_call)
-               << Object.get()->getType() << Object.get()->getSourceRange());
+            ? (PDiag(diag::err_ovl_no_oper) << T << /*call*/ 1 << SR)
+        : !IsStdInvoke ? (PDiag(diag::err_ovl_no_viable_object_call) << T << SR)
+                       : (PDiag(diag::err_invoke_function_object)
+                          << T << /*no*/ 0 << 1 << SR);
     CandidateSet.NoteCandidates(
         PartialDiagnosticAt(Object.get()->getBeginLoc(), PD), *this,
         OCD_AllCandidates, Args);
     break;
   }
-  case OR_Ambiguous:
+  case OR_Ambiguous: {
+    PartialDiagnostic PD =
+        !IsStdInvoke ? (PDiag(diag::err_ovl_ambiguous_object_call) << T << SR)
+                     : (PDiag(diag::err_invoke_function_object)
+                        << T << /*plural*/ 1 << CandidateSet.size() << 2 << SR);
     CandidateSet.NoteCandidates(
-        PartialDiagnosticAt(Object.get()->getBeginLoc(),
-                            PDiag(diag::err_ovl_ambiguous_object_call)
-                                << Object.get()->getType()
-                                << Object.get()->getSourceRange()),
-        *this, OCD_AmbiguousCandidates, Args);
+        PartialDiagnosticAt(Object.get()->getBeginLoc(), PD), *this,
+        OCD_AmbiguousCandidates, Args);
     break;
-
+  }
   case OR_Deleted:
+    PartialDiagnostic PD =
+        !IsStdInvoke
+            ? PDiag(diag::err_ovl_deleted_object_call) << T << SR
+            : PDiag(diag::err_invoke_function_object_deleted) << 2 << T << SR;
     CandidateSet.NoteCandidates(
-        PartialDiagnosticAt(Object.get()->getBeginLoc(),
-                            PDiag(diag::err_ovl_deleted_object_call)
-                                << Object.get()->getType()
-                                << Object.get()->getSourceRange()),
-        *this, OCD_AllCandidates, Args);
+        PartialDiagnosticAt(Object.get()->getBeginLoc(), PD), *this,
+        OCD_AllCandidates, Args);
     break;
   }
 
   if (Best == CandidateSet.end())
     return true;
 
   UnbridgedCasts.restore();
 
if (Method->isInvalidDecl())
     return ExprError();
 
   const auto *Proto = Method->getType()->castAs<FunctionProtoType>();
   unsigned NumParams = Proto->getNumParams();
 
   DeclarationNameInfo OpLocInfo(
                Context.DeclarationNames.getCXXOperatorName(OO_Call), LParenLoc);
   OpLocInfo.setCXXOperatorNameRange(SourceRange(LParenLoc, RParenLoc));
-  ExprResult NewFn = CreateFunctionRefExpr(*this, Method, Best->FoundDecl,
-                                           Obj, HadMultipleCandidates,
-                                           OpLocInfo.getLoc(),
-                                           OpLocInfo.getInfo());
+  ExprResult NewFn = CreateFunctionRefExpr(
+      *this, Method, Best->FoundDecl, Obj, HadMultipleCandidates,
+      OpLocInfo.getLoc(), OpLocInfo.getInfo(), IsStdInvoke);
   if (NewFn.isInvalid())
     return true;
 
   SmallVector<Expr *, 8> MethodArgs;
   MethodArgs.reserve(NumParams + 1);
 
   bool IsError = false;
 

clang/test/SemaCXX/builtin-std-invoke.cpp

+// RUN: %clang_cc1 -fsyntax-only -std=c++17 -verify %s
+
+namespace std {
+template <class F, class... Args>
+void invoke(F &&, Args &&...); // expected-note{{requires at least 1 argument, but 0 were provided}}
+
+template <class R, class F, class... Args>
+R invoke_r(F &&, Args &&...); // expected-note{{requires at least 1 argument, but 0 were provided}}
+
+// Slightly different to the real deal to simplify test.
+template <class T>
+class reference_wrapper {
+public:
+  constexpr reference_wrapper(T &t) : data(&t) {}
+
+  constexpr operator T &() const noexcept { return *data; }
+
+private:
+  T *data;
+};
+} // namespace std
+
+#define assert(...)   \
+  if (!(__VA_ARGS__)) \
+    __builtin_unreachable();
+
+struct ThrowingInt {
+  constexpr ThrowingInt(int x) : value(x) {}
+
+  int value;
+};
+
+template <class Returns, bool IsNoexcept, int ExpectedResult, class F, class T, class... Args>
+constexpr void bullet_1(F f, T &&t, Args... args) {
+  assert(std::invoke(f, static_cast<T &&>(t), args...) == ExpectedResult);
+  static_assert(__is_same(decltype(std::invoke(f, static_cast<T &&>(t), args...)), Returns));
+  static_assert(noexcept(std::invoke(f, static_cast<T &&>(t), args...)) == IsNoexcept);
+
+  assert(std::invoke_r<double>(f, static_cast<T &&>(t), args...) == ExpectedResult);
+  static_assert(__is_same(decltype(std::invoke_r<double>(f, static_cast<T &&>(t), args...)), double));
+  static_assert(noexcept(std::invoke_r<double>(f, static_cast<T &&>(t), args...)) == IsNoexcept);
+
+  assert(std::invoke_r<ThrowingInt>(f, static_cast<T &&>(t), args...).value == ExpectedResult);
+  static_assert(__is_same(decltype(std::invoke_r<ThrowingInt>(f, static_cast<T &&>(t), args...)), ThrowingInt));
+  static_assert(!noexcept(std::invoke_r<ThrowingInt>(f, static_cast<T &&>(t), args...)));
+}
+
+template <class Returns, bool IsNoexcept, int ExpectedResult, class F, class T, class... Args>
+constexpr void bullet_2(F f, T &t, Args... args) {
+  std::reference_wrapper<T> rw(t);
+  assert(std::invoke(f, rw, args...) == ExpectedResult);
+  static_assert(__is_same(decltype(std::invoke(f, rw, args...)), Returns));
+  static_assert(noexcept(std::invoke(f, rw, args...)) == IsNoexcept);
+
+  assert(std::invoke_r<double>(f, rw, args...) == ExpectedResult);
+  static_assert(__is_same(decltype(std::invoke_r<double>(f, rw, args...)), double));
+  static_assert(noexcept(std::invoke_r<double>(f, rw, args...)) == IsNoexcept);
+
+  assert(std::invoke_r<ThrowingInt>(f, rw, args...).value == ExpectedResult);
+  static_assert(__is_same(decltype(std::invoke_r<ThrowingInt>(f, rw, args...)), ThrowingInt));
+  static_assert(!noexcept(std::invoke_r<ThrowingInt>(f, rw, args...)));
+}
+
+template <class T>
+class PointerWrapper {
+public:
+  constexpr explicit PointerWrapper(T &t) noexcept : p(&t) {}
+
+  constexpr T &operator*() const noexcept { return *p; }
+
+private:
+  T *p;
+};
+
+template <class Returns, bool IsNoexcept, int ExpectedResult, class F, class T, class... Args>
+constexpr void bullet_3(F f, T &t, Args... args) {
+  assert(std::invoke(f, &t, args...) == ExpectedResult);
+  static_assert(__is_same(decltype(std::invoke(f, &t, args...)), Returns));
+  static_assert(noexcept(std::invoke(f, &t, args...)) == IsNoexcept);
+
+  assert(std::invoke(f, PointerWrapper(t), args...) == ExpectedResult);
+  static_assert(__is_same(decltype(std::invoke(f, PointerWrapper(t), args...)), Returns));
+  static_assert(noexcept(std::invoke(f, PointerWrapper(t), args...)) == IsNoexcept);
+
+  assert(std::invoke_r<double>(f, &t, args...) == ExpectedResult);
+  static_assert(__is_same(decltype(std::invoke_r<double>(f, &t, args...)), double));
+  static_assert(noexcept(std::invoke_r<double>(f, &t, args...)) == IsNoexcept);
+
+  assert(std::invoke_r<double>(f, PointerWrapper(t), args...) == ExpectedResult);
+  static_assert(__is_same(decltype(std::invoke_r<double>(f, PointerWrapper(t), args...)), double));
+  static_assert(noexcept(std::invoke_r<double>(f, PointerWrapper(t), args...)) == IsNoexcept);
+
+  assert(std::invoke_r<ThrowingInt>(f, &t, args...).value == ExpectedResult);
+  static_assert(__is_same(decltype(std::invoke_r<ThrowingInt>(f, &t, args...)), ThrowingInt));
+  static_assert(!noexcept(std::invoke_r<ThrowingInt>(f, &t, args...)));
+
+  assert(std::invoke_r<ThrowingInt>(f, PointerWrapper(t), args...).value == ExpectedResult);
+  static_assert(__is_same(decltype(std::invoke_r<ThrowingInt>(f, PointerWrapper(t), args...)), ThrowingInt));
+  static_assert(!noexcept(std::invoke_r<ThrowingInt>(f, PointerWrapper(t), args...)));
+}
+
+template <class T>
+constexpr bool bullets_1_through_3(T t) {
+  bullet_1</*Returns=*/int &, /*IsNoexcept=*/true, /*ExpectedResult=*/0>(&T::plus, t, 3, -3);
+  bullet_1</*Returns=*/const int &, /*IsNoexcept=*/true, /*ExpectedResult=*/-4>(&T::minus, static_cast<const T &>(t), 1, 2, 3);
+  bullet_1</*Returns=*/int &&, /*IsNoexcept=*/false, /*ExpectedResult=*/49>(&T::square, static_cast<__remove_reference_t(T) &&>(t), 7);
+  bullet_1</*Returns=*/const int &&, /*IsNoexcept=*/false, /*ExpectedResult=*/-63>(&T::sum, static_cast<const T &&>(t), -1, -2, -4, -8, -16, -32);
+
+  bullet_2</*Returns=*/int &, /*IsNoexcept=*/true, /*ExpectedResult=*/0>(&T::plus, t, 3, -3);
+  bullet_2</*Returns=*/const int &, /*IsNoexcept=*/true, /*ExpectedResult=*/-4>(&T::minus, static_cast<const T &>(t), 1, 2, 3);
+
+  bullet_3</*Returns=*/int &, /*IsNoexcept=*/true, /*ExpectedResult=*/0>(&T::plus, t, 3, -3);
+  bullet_3</*Returns=*/const int &, /*IsNoexcept=*/true, /*ExpectedResult=*/-4>(&T::minus, static_cast<const T &>(t), 1, 2, 3);
+
+  return true;
+}
+
+template <class Returns, class F, class T, class U>
+constexpr void bullet_4(F f, T &&t, U ExpectedResult) {
+  assert(std::invoke(f, static_cast<T &&>(t)) == ExpectedResult);
+  static_assert(__is_same(decltype(std::invoke(f, static_cast<T &&>(t))), Returns));
+  static_assert(noexcept(std::invoke(f, static_cast<T &&>(t))));
+
+  assert(std::invoke_r<double>(f, static_cast<T &&>(t)) == ExpectedResult);
+  static_assert(__is_same(decltype(std::invoke_r<double>(f, static_cast<T &&>(t))), double));
+  static_assert(noexcept(std::invoke_r<double>(f, static_cast<T &&>(t))));
+
+  assert(std::invoke_r<ThrowingInt>(f, static_cast<T &&>(t)).value == ExpectedResult);
+  static_assert(__is_same(decltype(std::invoke_r<ThrowingInt>(f, static_cast<T &&>(t))), ThrowingInt));
+  static_assert(!noexcept(std::invoke_r<ThrowingInt>(f, static_cast<T &&>(t))));
+}
+
+template <class Returns, class F, class T, class U>
+constexpr void bullet_5(F f, T &t, U ExpectedResult) {
+  std::reference_wrapper<T> rw(t);
+  assert(std::invoke(f, rw) == ExpectedResult);
+  static_assert(__is_same(decltype(std::invoke(f, rw)), Returns));
+  static_assert(noexcept(std::invoke(f, rw)));
+
+  assert(std::invoke_r<double>(f, rw) == ExpectedResult);
+  static_assert(__is_same(decltype(std::invoke_r<double>(f, rw)), double));
+  static_assert(noexcept(std::invoke_r<double>(f, rw)));
+
+  assert(std::invoke_r<ThrowingInt>(f, rw).value == ExpectedResult);
+  static_assert(__is_same(decltype(std::invoke_r<ThrowingInt>(f, rw)), ThrowingInt));
+  static_assert(!noexcept(std::invoke_r<ThrowingInt>(f, rw)));
+}
+
+template <class Returns, class F, class T, class U>
+constexpr void bullet_6(F f, T &t, U ExpectedResult) {
+  assert(std::invoke(f, &t) == ExpectedResult);
+  static_assert(__is_same(decltype(std::invoke(f, &t)), Returns));
+  static_assert(noexcept(std::invoke(f, &t)));
+
+  assert(std::invoke(f, PointerWrapper(t)) == ExpectedResult);
+  static_assert(__is_same(decltype(std::invoke(f, PointerWrapper(t))), Returns));
+  static_assert(noexcept(std::invoke(f, PointerWrapper(t))));
+
+  assert(std::invoke_r<double>(f, &t) == ExpectedResult);
+  static_assert(__is_same(decltype(std::invoke_r<double>(f, &t)), double));
+  static_assert(noexcept(std::invoke_r<double>(f, &t)));
+
+  assert(std::invoke_r<double>(f, PointerWrapper(t)) == ExpectedResult);
+  static_assert(__is_same(decltype(std::invoke_r<double>(f, PointerWrapper(t))), double));
+  static_assert(noexcept(std::invoke_r<double>(f, PointerWrapper(t))));
+
+  assert(std::invoke_r<ThrowingInt>(f, &t).value == ExpectedResult);
+  static_assert(__is_same(decltype(std::invoke_r<ThrowingInt>(f, &t)), ThrowingInt));
+  static_assert(!noexcept(std::invoke_r<ThrowingInt>(f, &t)));
+
+  assert(std::invoke_r<ThrowingInt>(f, PointerWrapper(t)).value == ExpectedResult);
+  static_assert(__is_same(decltype(std::invoke_r<ThrowingInt>(f, PointerWrapper(t))), ThrowingInt));
+  static_assert(!noexcept(std::invoke_r<ThrowingInt>(f, PointerWrapper(t))));
+}
+
+template <class F, class T, class U>
+constexpr bool bullets_4_through_6(F f, T t, U ExpectedResult) {
+  bullet_4</*Returns=*/U &>(f, t, ExpectedResult);
+  bullet_4</*Returns=*/const U &>(f, static_cast<const T &>(t), ExpectedResult);
+  bullet_4</*Returns=*/U &&>(f, static_cast<T &&>(t), ExpectedResult);
+  bullet_4</*Returns=*/const U &&>(f, static_cast<const T &&>(t), ExpectedResult);
+
+  bullet_5</*Returns=*/U &>(f, t, ExpectedResult);
+  bullet_5</*Returns=*/const U &>(f, static_cast<const T &>(t), ExpectedResult);
+
+  bullet_6</*Returns=*/U &>(f, t, ExpectedResult);
+  bullet_6</*Returns=*/const U &>(f, static_cast<const T &>(t), ExpectedResult);
+
+  return true;
+}
+
+constexpr int zero() { return 0; }
+constexpr int square(int x) { return x * x; } // expected-note 4 {{'square' declared here}}
+constexpr double product(double x, double y) { return x * y; }
+
+struct summation {
+  template <class... Ts>
+  constexpr auto operator()(Ts... ts) {
+    return (ts + ...);
+  }
+};
+
+struct callable {
+  int x;
+
+  constexpr int &operator()() &noexcept { return x; }                                          // expected-note 2 {{candidate function not viable: requires 0 arguments, but 2 were provided}}
+  constexpr const int &operator()() const &noexcept { return x; }                              // expected-note 2 {{candidate function not viable: requires 0 arguments, but 2 were provided}}
+  constexpr int &&operator()() &&noexcept { return static_cast<int &&>(x); }                   // expected-note 2 {{candidate function not viable: requires 0 arguments, but 2 were provided}}
+  constexpr const int &&operator()() const &&noexcept { return static_cast<const int &&>(x); } // expected-note 2 {{candidate function not viable: requires 0 arguments, but 2 were provided}}
+};
+
+template <class T, auto expected, bool IsNoexcept, class F, class... Args>
+constexpr bool bullet_7(F &&f, Args &&...args) {
+  assert(std::invoke(static_cast<F>(f), static_cast<Args>(args)...) == expected);
+  static_assert(__is_same(decltype(std::invoke(static_cast<F>(f), static_cast<Args>(args)...)), T));
+  static_assert(noexcept(std::invoke(static_cast<F>(f), static_cast<Args>(args)...)) == IsNoexcept);
+
+  assert(std::invoke_r<double>(f, args...) == expected);
+  static_assert(__is_same(decltype(std::invoke_r<double>(f, args...)), double));
+  static_assert(noexcept(std::invoke_r<double>(f, args...)) == IsNoexcept);
+
+  assert(std::invoke_r<ThrowingInt>(f, args...).value == expected);
+  static_assert(__is_same(decltype(std::invoke_r<ThrowingInt>(f, args...)), ThrowingInt));
+  static_assert(!noexcept(std::invoke_r<ThrowingInt>(f, args...)));
+
+  return true;
+}
+
+template <class T, class Expected>
+constexpr bool bullet_7_1() {
+  callable c{21};
+  return std::invoke(static_cast<T>(c)) == 21 &&
+         __is_same(decltype(std::invoke(static_cast<T>(c))), Expected) &&noexcept(std::invoke(static_cast<T>(c)));
+}
+
+struct Base {
+  mutable int data;
+
+  constexpr int &plus(int x, int y) &noexcept {
+    data = x + y;
+    return data;
+  }
+
+  constexpr const int &minus(int x, int y, int z) const &noexcept {
+    data = x - y - z;
+    return data;
+  }
+
+  constexpr int &&square(int x) && {
+    data = x * x;
+    return static_cast<int &&>(data);
+  }
+
+  constexpr const int &&sum(int a, int b, int c, int d, int e, int f) const && {
+    data = a + b + c + d + e + f;
+    return static_cast<const int &&>(data);
+  }
+};
+
+struct Derived : Base {
+  double data2;
+};
+
+void test_invoke() {
+  static_assert(bullets_1_through_3(Base{}));
+  static_assert(bullets_1_through_3(Derived{}));
+
+  static_assert(bullets_4_through_6(&Base::data, Base{21}, 21));
+  static_assert(bullets_4_through_6(&Base::data, Derived{-96, 18}, -96));
+  static_assert(bullets_4_through_6(&Derived::data2, Derived{21, 34}, 34.0));
+
+  static_assert(bullet_7<int, 0, false>(zero));
+  static_assert(bullet_7<int, 25, false>(square, 5.0));
+  static_assert(bullet_7<double, 9, false>(product, 9, 1));
+  static_assert(bullet_7<int, 0, false>(&zero));
+  static_assert(bullet_7<long, 55L, false>(summation{}, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10L));
+  static_assert(bullet_7<int, 18, false>([] { return 18; }));
+
+  static_assert(bullet_7_1<callable &, int &>());
+  static_assert(bullet_7_1<const callable &, const int &>());
+  static_assert(bullet_7_1<callable &&, int &&>());
+  static_assert(bullet_7_1<const callable &&, const int &&>());
+}
+
+struct Ambiguous {
+  int operator()(int) const;           // expected-note 2 {{candidate function}}
+  long operator()(unsigned int) const; // expected-note 2 {{candidate function}}
+};
+
+struct Deleted {
+  int operator()() const = delete; // expected-note 2 {{candidate function has been explicitly deleted}}
+};
+
+int deleted_function() = delete; // expected-note 2 {{'deleted_function' has been explicitly marked deleted here}}
+
+struct Incompatible {};
+
+void test_errors() {
+  // TODO: add cases for bullets 1--6 where 2nd param is an int
+  std::invoke();        // expected-error{{no matching function for call to 'invoke'}}
+  std::invoke_r<int>(); // expected-error{{no matching function for call to 'invoke_r'}}
+
+  { // Concerning bullet 1
+    std::invoke(&Base::plus);
+    // expected-error@-1{{can't invoke pointer-to-member function: 'std::invoke' must have at least 2 arguments for a pointer-to-member function, got 1}}
+    std::invoke_r<double>(&Base::plus);
+    // expected-error@-1{{can't invoke pointer-to-member function: 'std::invoke_r' must have at least 2 arguments for a pointer-to-member function, got 1}}
+    std::invoke(&Base::plus, Incompatible{}, 1, 2);
+    // expected-error@-1{{can't invoke pointer-to-member function: expected second argument to be a reference to a class compatible with 'Base', got 'Incompatible'}}
+    std::invoke_r<double>(&Base::plus, Incompatible{}, 1, 2);
+    // expected-error@-1{{can't invoke pointer-to-member function: expected second argument to be a reference to a class compatible with 'Base', got 'Incompatible'}}
+
+    std::invoke(&Base::sum, Base{}, 0);
+    // expected-error@-1{{can't invoke pointer-to-member function: expected 6 arguments, got 1}}
+    std::invoke_r<double>(&Base::sum, Base{}, 0);
+    // expected-error@-1{{can't invoke pointer-to-member function: expected 6 arguments, got 1}}
+
+    std::invoke(&Base::sum, Base{}, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9);
+    // expected-error@-1{{can't invoke pointer-to-member function: expected 6 arguments, got 10}}
+    std::invoke_r<double>(&Base::sum, Base{}, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9);
+    // expected-error@-1{{can't invoke pointer-to-member function: expected 6 arguments, got 10}}
+
+    std::invoke_r<void *>(&Base::sum, Base{}, 0, 1, 2, 3, 4, 5);
+    // expected-error@-1{{can't invoke pointer-to-member function: return type 'const int' isn't convertible to 'void *'}}
+
+    const Base cb;
+    std::invoke(&Base::plus, cb, 1, 2);
+    // expected-error@-1{{can't invoke pointer-to-member function: '&Base::plus' drops 'const' qualifier}}
+    std::invoke_r<double>(&Base::plus, cb, 1, 2);
+    // expected-error@-1{{can't invoke pointer-to-member function: '&Base::plus' drops 'const' qualifier}}
+
+    volatile Base vb;
+    std::invoke(&Base::plus, vb, 1, 2);
+    // expected-error@-1{{can't invoke pointer-to-member function: '&Base::plus' drops 'volatile' qualifier}}
+    std::invoke_r<double>(&Base::plus, vb, 1, 2);
+    // expected-error@-1{{can't invoke pointer-to-member function: '&Base::plus' drops 'volatile' qualifier}}
+
+    const volatile Base cvb;
+    std::invoke(&Base::plus, cvb, 1, 2);
+    // expected-error@-1{{can't invoke pointer-to-member function: '&Base::plus' drops 'const volatile' qualifiers}}
+    std::invoke_r<double>(&Base::plus, cvb, 1, 2);
+    // expected-error@-1{{can't invoke pointer-to-member function: '&Base::plus' drops 'const volatile' qualifiers}}
+
+    std::invoke(&Base::plus, Base{}, 1, 2);
+    // expected-error@-1{{can't invoke pointer-to-member function: '&Base::plus' can only be called on an lvalue}}
+    std::invoke_r<double>(&Base::plus, Base{}, 1, 2);
+    // expected-error@-1{{can't invoke pointer-to-member function: '&Base::plus' can only be called on an lvalue}}
+
+    std::invoke(&Base::sum, cb, 1, 2, 3, 4, 5, 6);
+    // expected-error@-1{{can't invoke pointer-to-member function: '&Base::sum' can only be called on an rvalue}}
+    std::invoke_r<double>(&Base::sum, cb, 1, 2, 3, 4, 5, 6);
+    // expected-error@-1{{can't invoke pointer-to-member function: '&Base::sum' can only be called on an rvalue}}
+  }
+  { // Concerning bullet 2
+    Base b;
+    std::reference_wrapper<Base> rw(b);
+
+    Incompatible p;
+    std::reference_wrapper<Incompatible> pw(p);
+
+    std::invoke(&Base::plus, pw, 1, 2);
+    // expected-error@-1{{can't invoke pointer-to-member function: expected second argument to be a wrapee to a class compatible with 'Base', got 'Incompatible'}}
+    std::invoke_r<double>(&Base::plus, pw, 1, 2);
+    // expected-error@-1{{can't invoke pointer-to-member function: expected second argument to be a wrapee to a class compatible with 'Base', got 'Incompatible'}}
+
+    std::invoke(&Base::plus, rw, 0);
+    // expected-error@-1{{can't invoke pointer-to-member function: expected 2 arguments, got 1}}
+    std::invoke_r<double>(&Base::plus, rw, 0);
+    // expected-error@-1{{can't invoke pointer-to-member function: expected 2 arguments, got 1}}
+
+    std::invoke(&Base::plus, rw, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9);
+    // expected-error@-1{{can't invoke pointer-to-member function: expected 2 arguments, got 10}}
+    std::invoke_r<double>(&Base::plus, rw, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9);
+    // expected-error@-1{{can't invoke pointer-to-member function: expected 2 arguments, got 10}}
+
+    std::invoke_r<void *>(&Base::plus, rw, 4, 1);
+    // expected-error@-1{{can't invoke pointer-to-member function: return type 'int' isn't convertible to 'void *'}}
+  }
+  { // Concerning bullet 3
+    Base b;
+    Incompatible p;
+
+    std::invoke(&Base::plus, &p, 1, 2);
+    // expected-error@-1{{can't invoke pointer-to-member function: expected second argument to be a pointer to a class compatible with 'Base', got 'Incompatible *'}}
+    std::invoke_r<double>(&Base::plus, &p, 1, 2);
+    // expected-error@-1{{can't invoke pointer-to-member function: expected second argument to be a pointer to a class compatible with 'Base', got 'Incompatible *'}}
+
+    std::invoke(&Base::plus, &b, 0);
+    // expected-error@-1{{can't invoke pointer-to-member function: expected 2 arguments, got 1}}
+    std::invoke_r<double>(&Base::plus, &b, 0);
+    // expected-error@-1{{can't invoke pointer-to-member function: expected 2 arguments, got 1}}
+
+    std::invoke(&Base::plus, &b, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9);
+    // expected-error@-1{{can't invoke pointer-to-member function: expected 2 arguments, got 10}}
+    std::invoke_r<double>(&Base::plus, &b, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9);
+    // expected-error@-1{{can't invoke pointer-to-member function: expected 2 arguments, got 10}}
+
+    std::invoke_r<void *>(&Base::plus, &b, 4, 1);
+    // expected-error@-1{{can't invoke pointer-to-member function: return type 'int' isn't convertible to 'void *'}}
+  }
+  { // Concerning bullet 4
+    std::invoke(&Base::data);
+    // expected-error@-1{{can't invoke pointer-to-data member: 'std::invoke' must have exactly 2 arguments for a pointer-to-data member, got 1}}
+    std::invoke_r<double>(&Base::data);
+    // expected-error@-1{{can't invoke pointer-to-data member: 'std::invoke_r' must have exactly 2 arguments for a pointer-to-data member, got 1}}
+
+    std::invoke(&Base::data, Incompatible{});
+    // expected-error@-1{{can't invoke pointer-to-data member: expected second argument to be a reference to a class compatible with 'Base', got 'Incompatible'}}
+    std::invoke_r<double>(&Base::data, Incompatible{});
+    // expected-error@-1{{can't invoke pointer-to-data member: expected second argument to be a reference to a class compatible with 'Base', got 'Incompatible'}}
+
+    std::invoke(&Base::data, Base{}, Base{});
+    // expected-error@-1{{can't invoke pointer-to-data member: 'std::invoke' must have exactly 2 arguments for a pointer-to-data member, got 1}}
+    std::invoke_r<double>(&Base::data, Base{}, Base{});
+    // expected-error@-1{{can't invoke pointer-to-data member: 'std::invoke_r' must have exactly 2 arguments for a pointer-to-data member, got 1}}
+
+    std::invoke_r<void *>(&Base::data, Base{});
+    // expected-error@-1{{can't invoke pointer-to-data member: return type 'int' isn't convertible to 'void *'}}
+  }
+  { // Concerning bullet 5
+    Base b;
+    std::reference_wrapper<Base> rw(b);
+
+    Incompatible p;
+    std::reference_wrapper<Incompatible> pw(p);
+
+    std::invoke(&Base::data, pw);
+    // expected-error@-1{{can't invoke pointer-to-data member: expected second argument to be a wrapee to a class compatible with 'Base', got 'Incompatible'}}
+    std::invoke_r<double>(&Base::data, pw);
+    // expected-error@-1{{can't invoke pointer-to-data member: expected second argument to be a wrapee to a class compatible with 'Base', got 'Incompatible'}}
+
+    std::invoke(&Base::data, rw, Base{});
+    // expected-error@-1{{can't invoke pointer-to-data member: 'std::invoke' must have exactly 2 arguments for a pointer-to-data member, got 1}}
+    std::invoke_r<double>(&Base::data, rw, Base{});
+    // expected-error@-1{{can't invoke pointer-to-data member: 'std::invoke_r' must have exactly 2 arguments for a pointer-to-data member, got 1}}
+
+    std::invoke_r<void *>(&Base::data, rw);
+    // expected-error@-1{{can't invoke pointer-to-data member: return type 'int' isn't convertible to 'void *'}}
+  }
+  { // Concerning bullet 6
+    Base b;
+    Incompatible p;
+
+    std::invoke(&Base::data, &p);
+    // expected-error@-1{{can't invoke pointer-to-data member: expected second argument to be a pointer to a class compatible with 'Base', got 'Incompatible *'}}
+    std::invoke_r<double>(&Base::data, &p);
+    // expected-error@-1{{can't invoke pointer-to-data member: expected second argument to be a pointer to a class compatible with 'Base', got 'Incompatible *'}}
+
+    std::invoke(&Base::data, &b, Base{});
+    // expected-error@-1{{can't invoke pointer-to-data member: 'std::invoke' must have exactly 2 arguments for a pointer-to-data member, got 1}}
+    std::invoke_r<double>(&Base::data, &b, Base{});
+    // expected-error@-1{{can't invoke pointer-to-data member: 'std::invoke_r' must have exactly 2 arguments for a pointer-to-data member, got 1}}
+
+    std::invoke_r<void *>(&Base::data, &b);
+    // expected-error@-1{{can't invoke pointer-to-data member: return type 'int' isn't convertible to 'void *'}}
+  }
+  { // Concerning bullet 7
+    std::invoke(square);
+    // expected-error@-1{{can't invoke function: expected 1 argument, got 0}}
+    std::invoke_r<double>(square);
+    // expected-error@-1{{can't invoke function: expected 1 argument, got 0}}
+
+    std::invoke(square, 1, 2);
+    // expected-error@-1{{can't invoke function: expected 1 argument, got 2}}
+    std::invoke_r<double>(square, 1, 2);
+    // expected-error@-1{{can't invoke function: expected 1 argument, got 2}}
+
+    std::invoke(&product, 1);
+    // expected-error@-1{{can't invoke function: expected 2 arguments, got 1}}
+    std::invoke_r<double>(&product, 1);
+    // expected-error@-1{{can't invoke function: expected 2 arguments, got 1}}
+
+    std::invoke(deleted_function);
+    // expected-error@-1{{attempt to use a deleted function}}
+    std::invoke_r<double>(deleted_function);
+    // expected-error@-1{{attempt to use a deleted function}}
+
+    std::invoke(callable{1}, 1, 2);
+    // expected-error@-1{{can't invoke 'callable' function object: no suitable overload found}}
+    std::invoke_r<double>(callable{1}, 1, 2);
+    // expected-error@-1{{can't invoke 'callable' function object: no suitable overload found}}
+
+    std::invoke_r<callable>(callable{1});
+    // expected-error@-1{{can't invoke 'callable' function object: return type 'int' isn't convertible to 'callable'}}
+
+    std::invoke(Ambiguous{}, 0.0);
+    // expected-error@-1{{can't invoke 'Ambiguous' function object: 2 suitable overloads found, which makes choosing ambiguous}}
+    std::invoke_r<double>(Ambiguous{}, 0.0);
+    // expected-error@-1{{can't invoke 'Ambiguous' function object: 2 suitable overloads found, which makes choosing ambiguous}}
+
+    std::invoke(Deleted{});
+    // expected-error@-1{{can't invoke 'Deleted' function object: chosen overload candidate is deleted}}
+    std::invoke_r<double>(Deleted{});
+    // expected-error@-1{{can't invoke 'Deleted' function object: chosen overload candidate is deleted}}
+  }
+}