[Clang] P1169R4: static operator()

[royjacobson]

Summary

Implements 'P1169R4: static operator()' from C++2b.

[royjacobson]

missing newline

[royjacobson]

Fix the tests, add a CodeGen test.

[royjacobson]

Fix diagnosing static operators that are not call.

[royjacobson]

Fix codegen test on windows, rebase on main.

[cor3ntin]

Thanks a lot for working on that!

I think this is the right direction but i would like to see more tests.
Notably:

• converting a lambda with a static operator to a pointer
• tests in dependant contexts
• classes having both static and non-static operator() . especially the example in https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2022/p1169r4.html#overload-resolution deserves a test.
• unevaluated lambda tests / constexpr tests

There is the question of whether we'd want the call operator to be implicitly static but I'm don't think it's currently allowed, it may have abi impact and it doesn't to be dealt with in this PR so that should not hold us.
The other question is whether we want to make static operator() an extension in older language modes. I don;t see a reason to prohibit that (with a warning)

clang/include/clang/Basic/DiagnosticParseKinds.td

1041

clang/include/clang/Basic/DiagnosticSemaKinds.td

9075

For consistency and clarity, I'd say 'static overloaded %0'

9077

clang/lib/Parse/ParseExprCXX.cpp

1265

We might want to add a note showing where the capture list is.

clang/lib/Sema/SemaChecking.cpp

5839

clang/lib/Sema/SemaLambda.cpp

963–964

Do we actually need that check ? It should be diagnosed already.

995–997

Do we want an assert to make sure it's not something else than static or none?

clang/test/CXX/over/over.oper/over.literal/p7.cpp

23–25 ↗

(On Diff #459361)

This doesn't really seem to be the right file for this test - I'd expect that to be in a test file where we do sema check on operators, not literal operators.
Do you need help looking for a better place?

[royjacobson]

Wow, thanks for the quick review!

In D133659#3783008, @cor3ntin wrote:

Thanks a lot for working on that!

I think this is the right direction but i would like to see more tests.
Notably:

• converting a lambda with a static operator to a pointer

Turns out I had a bug in the conversion function generation, thanks for the suggestion! Fixed it and added tests.

• tests in dependant contexts

Added some tests for that, but I'm not sure how to judge if I have good coverage of all the possible edge cases, so more suggestions are welcome :)

• classes having both static and non-static operator() . especially the example in https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2022/p1169r4.html#overload-resolution deserves a test.

I _think_ you can't do that - https://stackoverflow.com/questions/5365689/c-overload-static-function-with-non-static-function.

The example from the paper is about disambiguating the conversion-to-function-pointer call from the operator(), which is kind-of already tested because otherwise you wouldn't be able to call a static lambda at all. I added it as an explicit test, though.

• unevaluated lambda tests / constexpr tests

I'm not sure I understand what you mean by unevaluated lambdas, could you elaborate? I added some constexpr/eval tests.

There is the question of whether we'd want the call operator to be implicitly static but I'm don't think it's currently allowed, it may have abi impact and it doesn't to be dealt with in this PR so that should not hold us.
The other question is whether we want to make static operator() an extension in older language modes. I don;t see a reason to prohibit that (with a warning)

I thought I made it an extension, but apparently it was only for the static lambdas, just because that's how most of the other lambda extensions were implemented :)
I don't have a strong opinion about this. But I realized that without backporting the overload resolution changes, this will not be useful for lambdas.
So just to be consistent right now I made it an error for both - we can always change that to a warning pretty easily.

clang/lib/Sema/SemaLambda.cpp

963–964

It's not about diagnosing, it's preventing declaring the operator 'const' if it's static.

clang/test/CXX/over/over.oper/over.literal/p7.cpp

23–25 ↗

(On Diff #459361)

Oops, this is the wrong p7 indeed :)

thanks!

[royjacobson]

Fix conversion to function pointer, add more tests and apply Corentin's wording.

[royjacobson]

Fix test after warning text change

[royjacobson]

format

[royjacobson]

clang/lib/Parse/ParseExprCXX.cpp

1265

I added a note, but the captures list is always just before the static specifier, so I'm not sure how useful it is. WDYT?

[royjacobson]

Add note in diagnostic.

[lichray]

clang/test/CodeGenCXX/cxx2b-static-call-operator.cpp

6

I want to see some tests that diagnose extern operator().

clang/test/Parser/cxx2b-lambdas.cpp

43

And some tests that diagnose extern, mutable extern, etc.

[shafik]

clang/lib/Sema/SemaDeclCXX.cpp

15934

clang/test/Parser/cxx2b-lambdas.cpp

42

also combined w/ constexpr and consteval

52

Why not throw in capture by copy/move as well.

[royjacobson]

Add tests required by reviewerd.

[lichray]

LGTM

[cor3ntin]

Beside a missing test, this LGTM
I'd like someone else (@erichkeane maybe) to review the codegen tests.

clang/test/Parser/cxx2b-lambdas.cpp

60

For completeness, can you add a test for *this/this?

[royjacobson]

Added tests for 'this' lambda captures and for the pre-cxx2b compatability warnings.

[royjacobson]

Does anyone feel comfortable with looking at the CodeGen tests? They're checking that we aren't passing a this argument.

@erichkeane @shafik @lichray

[erichkeane]

In D133659#3806315, @royjacobson wrote:

Does anyone feel comfortable with looking at the CodeGen tests? They're checking that we aren't passing a this argument.

@erichkeane @shafik @lichray

The codegen tests look reasonably complete and correct to me.

[royjacobson]

Thanks everyone! So if no one else has comments I'm planning to merge this tomorrow.

[aaron.ballman]

In D133659#3808095, @royjacobson wrote:

Thanks everyone! So if no one else has comments I'm planning to merge this tomorrow.

FWIW, you shouldn't merge something that has nobody signed on as the reviewer (and has only mild acceptance from people subscribing) -- a better approach is to add some reviewers, get them to accept, then land. Otherwise, coming back to this review in the future when doing code archeology leads to confusion about whether the changes should have even gone in at all, etc. I've added some more reviewers so we can make sure this gets the pretty green checkmark before landing. :-)

clang/include/clang/Basic/DiagnosticParseKinds.td

1033

This is a bit confusing -- we're saying it's an extension but then making it an error? I've reworded based on how I think you're intending it to be issued.

1037–1041

These are semantic errors, not parsing ones. This means these will be diagnosed when parsing the lambda rather than when instantiating it. I don't think that matters for the cast of combining mutable and static, but I'm less certain about "have any captures" because of cases like:

template <typename... Types>
auto func(Types... Ts) {
  return [Ts...] { return 1; };
}

int main() {
  auto lambda = func();
}

I'm pretty sure that lambda has no captures for that call, but it could have captures depending on the instantiation.

Actually, from some off-list discussion with @erichkeane, even mutable and static are a problem in code like:

template <typename Ty>
void func(T t) {
  if constexpr (Something<T>) {
    [](){};
  } else {
    [t](){};
  }

where the lambda is in a discarded statement.

So I think these might need to change to be Sema diagnostics (and we should add some additional test coverage).

clang/include/clang/Basic/DiagnosticSemaKinds.td

9075

clang/lib/Sema/SemaDeclCXX.cpp

15938–15944

The diagnostic formatter knows how to format anything that inherits from NamedDecl.

[royjacobson]

clang/include/clang/Basic/DiagnosticParseKinds.td

1037–1041

From https://eel.is/c++draft/expr.prim.lambda.general#4

If the lambda-specifier-seq contains static, there shall be no lambda-capture

So this should be a parsing error. Or maybe I don't understand what you're saying. There are no static lambdas in your examples so I'm not sure how they're related.

[aaron.ballman]

clang/include/clang/Basic/DiagnosticParseKinds.td

1037–1041

So this should be a parsing error. Or maybe I don't understand what you're saying.

Parsing errors are where the grammar disallows something, generally. The rest are semantic diagnostics (e.g., we can parse the construct just fine, but we diagnose when turning it into an AST node because that's the point at which we have complete information about what we've parsed).

That said, my concern was mostly around SFINAE situations. My recollection is that SFINAE traps do not cover parsing errors only type substitution errors. So for my first example, I would expect there to be no parsing error despite specifying a capture list because that capture list can be empty when the pack is empty, but we would get a SFINAE diagnostic when rebuilding declaration during template instantiation if the pack was not empty.

There are no static lambdas in your examples so I'm not sure how they're related.

Sorry, I was being lazy with my examples and showing more about the capture list. Consider:

template <typename... Types>
auto func(Types... Ts) {
  return [Ts...] static { return 1; };
}

int main() {
  auto lambda = func();
}

[royjacobson]

clang/include/clang/Basic/DiagnosticParseKinds.td

1037–1041

Like I said,

If the lambda-specifier-seq contains static, there shall be no lambda-capture

Ts... is still a syntactic lambda-capture, even if it's instantiated as an empty pack. I don't see how that's not a parsing error.

[aaron.ballman]

clang/include/clang/Basic/DiagnosticParseKinds.td

1037–1041

Ah, I think I maybe see where the confusion is coming in, now: you think my example should be diagnosed and I think my example should be accepted.

Based on the standards wording, I think you're right. The standard specifically uses "lambda-capture" as a grammar term, so it *is* a parsing error at that point.

Based on my understanding of the intent behind the feature, I think I'm right and there's a core issue here. I don't think we intended to prohibit empty packs from being captured as non-SFINAEable error (and in off-list talks with @erichkeane, he agrees). as that allows different specializations of the function containing the lambda, which could be of use. However, I'm not 100% sure on the intent. CC @hubert.reinterpretcast as the C++ standards conformance code owner to see if he has an opinion or other recollections here.

[royjacobson]

Apply suggestions from Aaron and rebase.

[royjacobson]

Small doc change

[royjacobson]

clang/include/clang/Basic/DiagnosticParseKinds.td

1037–1041

I can see something like

[Ts...] static(sizeof...(Types) == 0) {}

being eventually useful, but as long as the static is non-conditional allowing a capture list with an empty pack doesn't make sense to me. I think you can always do something like

[]<typename = std::enable_if<sizeof...(Types) == 0>::value> {}

and that should have the same functionality.

Do you or Erich plan to open a CWG issue about this?

[cor3ntin]

clang/include/clang/Basic/DiagnosticParseKinds.td

1037–1041

FYI I agree with @royjacobson on the current wording interpretation.
I don't think sfinae on empty pack offer much benefit - versus the complexity (and the cost of not being able to diagnose non-empty packs until instanciations) so I don't think there is a core issue here either. But until such core issue emerges and is resolved, I don't think we need to change what is done here.

[aaron.ballman]

clang/include/clang/Basic/DiagnosticParseKinds.td

1037–1041

Do you or Erich plan to open a CWG issue about this?

I was contemplating it, but after thinking on it more overnight, I think we should accept this patch as-is. I believe it would be safe and plausible to lift this restriction later if CWG or EWG decides to move in this space, but the amount of utility gained by supporting it now is pretty minimal.

Thanks for the discussion around this!

clang/lib/Frontend/InitPreprocessor.cpp

698

Because we're exposing the feature as a language extension in older language modes, I think we probably want to define the macro in older language modes as well, right?

clang/lib/Parse/ParseExprCXX.cpp

1174

coding style nit.

1265

FWIW, I'm not sure the note adds a whole lot of value. @cor3ntin, do you have a code example in mind where you think the note would be clarifying?

clang/lib/Sema/SemaDeclCXX.cpp

15390–15393

clang/test/Parser/cxx2b-lambdas-ext-warns.cpp

2–4

You weren't using the expected prefix in the test.

[royjacobson]

Apply small suggestions by Aaron

[royjacobson]

I think I didn't get the overload resolution changes quite right, so this will probably change a bit.

clang/lib/Frontend/InitPreprocessor.cpp

698

Because supporting static lambdas requires backporting the overload resolution change as well, I decided not to support it as an extension, and for consistency no regular static operator() as well.

I've asked now on the libcxx Discord and they seem to think that it would still be useful to provide the regular static operator() as an extension, especially for C++20 ranges.

I think backporting the overload resolution change should be fine, but it seems I haven't implemented it quite right so I'm looking into it.

[royjacobson]

• Fix overload resolution and apply it retroactively
• Allow static lambdas and static operator() as extensions
• Define the feature macros in earlier versions and fix the tests

[royjacobson]

GCC have implemented this yesterday, and they also apply the overload resolution change retroactively. So I've done it as well and downgraded the errors to ExtWarns.

I'm not sure that the change to the conversion sequences in the overload resolution is the best way to implement this but it was the cleanest way I found..

[cor3ntin]

I only left a few comments because I'm not familiar enough with that part of the code to be certain the changes are correct but overall it looks fine to me.

clang/include/clang/Sema/Overload.h

524–526 ↗

(On Diff #463346)

clang/lib/Sema/SemaOverload.cpp

7014

7017

Can we move that outside of the scope to avoid duplication?

[royjacobson]

Rebase and address comments.

[cor3ntin]

@aaron.ballman Can you give one last pass at this? The new conversions rules is not something I feel confident blessing (ie I'm not qualified).

[royjacobson]

Rebase (main was broken)

[aaron.ballman]

Double-checking my understanding of the overload resolution changes: we added a new conversion sequence, but we don't expect that conversion sequence to cause a change in overload resolution in practice? (I'm wondering if there's test coverage we should be adding for those changes.)

clang/lib/Parse/ParseExprCXX.cpp

1265

I think we should remove the note here -- we can add a note back when we run into a use case where it would be enlightening.

clang/lib/Sema/SemaOverload.cpp

7018–7020

Can you replace this with: Candidate.Conversions[FirstConvIdx].setStaticObjectArgument(); and get the same behavior?

clang/test/Lexer/cxx-features.cpp

42–48 ↗

(On Diff #463926)

Unrelated changes? (Feel free to land as an NFC change separately though, they look like sensible changes.)

clang/test/SemaCXX/lambda-unevaluated.cpp

125

We can remove this now, right?

[cor3ntin]

clang/lib/Parse/ParseExprCXX.cpp

1265

I was just thinking that with sufficient attributes, templates, require clauses and parameters, the lambda might be cluttered enough that a note would not hurt. I'm not strongly attached to it though

[royjacobson]

Address CR comments

[royjacobson]

In D133659#3824472, @aaron.ballman wrote:

Double-checking my understanding of the overload resolution changes: we added a new conversion sequence, but we don't expect that conversion sequence to cause a change in overload resolution in practice? (I'm wondering if there's test coverage we should be adding for those changes.)

Yeah. The change only allow previously ambiguous calls to now not be ambiguous. Add to that that static and non-static methods can't overload each other, and the fact that GCC have applied this retroactively as well, I think it's pretty safe to just use the usual regression tests. (https://gcc.gnu.org/git/?p=gcc.git;a=commit;h=303976a6076f2839354702fd2caa049fa7cbbdc2)

[aaron.ballman]

LGTM, thank you for all the work on this!

[royjacobson]

Thanks for the patient review and the discussion! @aaron.ballman @cor3ntin

clang/docs/ReleaseNotes.rst

- Skip rebuilding lambda expressions in arguments of immediate invocations.
   `GH51695 <https://github.com/llvm/llvm-project/issues/51695>`_,
   `GH50455 <https://github.com/llvm/llvm-project/issues/50455>`_,
   `GH54872 <https://github.com/llvm/llvm-project/issues/54872>`_,
   `GH54587 <https://github.com/llvm/llvm-project/issues/54587>`_.
 
 C++2b Feature Support
 ^^^^^^^^^^^^^^^^^^^^^
 
+- Implemented `P1169R4: static operator() <https://wg21.link/P1169R4>`_.
+
 CUDA/HIP Language Changes in Clang
 ----------------------------------
 
 Objective-C Language Changes in Clang
 -------------------------------------
 
 OpenCL C Language Changes in Clang
 ----------------------------------

clang/include/clang/Basic/DiagnosticParseKinds.td

def err_this_captured_by_reference : Error<
   "'this' cannot be captured by reference">;
 def err_expected_capture : Error<
   "expected variable name or 'this' in lambda capture list">;
 def err_expected_lambda_body : Error<"expected body of lambda expression">;
 def warn_cxx98_compat_lambda : Warning<
   "lambda expressions are incompatible with C++98">,
   InGroup<CXX98Compat>, DefaultIgnore;
 def err_lambda_decl_specifier_repeated : Error<
-  "%select{'mutable'|'constexpr'|'consteval'}0 cannot appear multiple times in a lambda declarator">;
+  "%select{'mutable'|'static'|'constexpr'|'consteval'}0 cannot "
+  "appear multiple times in a lambda declarator">;
 def err_lambda_capture_misplaced_ellipsis : Error<
   "ellipsis in pack %select{|init-}0capture must appear %select{after|before}0 "
   "the name of the capture">;
 def err_lambda_capture_multiple_ellipses : Error<
   "multiple ellipses in pack capture">;
 def err_capture_default_first : Error<
   "capture default must be first">;
 def ext_decl_attrs_on_lambda : ExtWarn<
def ext_lambda_template_parameter_list: ExtWarn<
   "explicit template parameter list for lambdas is a C++20 extension">,
   InGroup<CXX20>;
 def warn_cxx17_compat_lambda_template_parameter_list: Warning<
   "explicit template parameter list for lambdas is incompatible with "
   "C++ standards before C++20">, InGroup<CXXPre20Compat>, DefaultIgnore;
 def err_lambda_template_parameter_list_empty : Error<
   "lambda template parameter list cannot be empty">;
 
+// C++2b static lambdas
+def err_static_lambda: Error<
+  "static lambdas is a C++2b extension">;
+def warn_cxx20_compat_static_lambda: Warning<
+  "static lambdas are incompatible with C++ standards before C++2b">,
+  InGroup<CXXPre2bCompat>, DefaultIgnore;
+def err_static_mutable_lambda : Error<
+  "lambda cannot be both mutable and static">;
+def err_static_lambda_captures : Error<
+  "a static lambda cannot have any captures">;
+def note_lambda_captures : Note<"captures declared here">;
+
 // Availability attribute
 def err_expected_version : Error<
   "expected a version of the form 'major[.minor[.subminor]]'">;
 def warn_expected_consistent_version_separator : Warning<
   "use same version number separators '_' or '.'; as in "
   "'major[.minor[.subminor]]'">, InGroup<Availability>;
 def err_zero_version : Error<
   "version number must have non-zero major, minor, or sub-minor version">;

clang/include/clang/Basic/DiagnosticSemaKinds.td

 def note_hiding_object : Note<"declaration hides type">;
 
 // C++ operator overloading
 def err_operator_overload_needs_class_or_enum : Error<
   "overloaded %0 must have at least one parameter of class "
   "or enumeration type">;
 
 def err_operator_overload_variadic : Error<"overloaded %0 cannot be variadic">;
+def ext_operator_overload_static : ExtWarn<
+  "making static overloaded %0 is a C++2b extension">, InGroup<CXXPre2bCompat>, DefaultIgnore;
+def err_call_operator_overload_static : Error<
+  "overloaded %0 cannot be declared static before C++2b">;
 def err_operator_overload_static : Error<
   "overloaded %0 cannot be a static member function">;
 def err_operator_overload_default_arg : Error<
   "parameter of overloaded %0 cannot have a default argument">;
 
 def ext_subscript_overload : ExtWarn<
   "overloaded %0 with %select{no|a defaulted|more than one}1 parameter is a C++2b extension">, InGroup<CXXPre2bCompat>, DefaultIgnore;
 def error_subscript_overload : Error<

clang/include/clang/Basic/OperatorKinds.def

 ///
 /// Unary: True if the operator can be declared as a unary operator.
 ///
 /// Binary: True if the operator can be declared as a binary
 /// operator. Note that some operators (e.g., "operator+" and
 /// "operator*") can be both unary and binary.
 ///
 /// MemberOnly: True if this operator can only be declared as a
-/// non-static member function. False if the operator can be both a
-/// non-member function and a non-static member function.
+/// member function. False if the operator can be both a
+/// non-member function and a member function.
 ///
 /// OVERLOADED_OPERATOR_MULTI is used to enumerate the multi-token
 /// overloaded operator names, e.g., "operator delete []". The macro
 /// has all of the parameters of OVERLOADED_OPERATOR except Token,
 /// which is omitted.
 
 #ifndef OVERLOADED_OPERATOR
 #  define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly)

clang/include/clang/Sema/DeclSpec.h

struct LambdaIntroducer {
   SourceRange Range;
   SourceLocation DefaultLoc;
   LambdaCaptureDefault Default;
   SmallVector<LambdaCapture, 4> Captures;
 
   LambdaIntroducer()
     : Default(LCD_None) {}
 
+  bool hasLambdaCapture() const {
+    return Captures.size() > 0 || Default != LCD_None;
+  }
+
   /// Append a capture in a lambda introducer.
   void addCapture(LambdaCaptureKind Kind,
                   SourceLocation Loc,
                   IdentifierInfo* Id,
                   SourceLocation EllipsisLoc,
                   LambdaCaptureInitKind InitKind,
                   ExprResult Init,
                   ParsedType InitCaptureType,

clang/include/clang/Sema/Sema.h

public:
 
   /// Create a new lambda closure type.
   CXXRecordDecl *createLambdaClosureType(SourceRange IntroducerRange,
                                          TypeSourceInfo *Info,
                                          unsigned LambdaDependencyKind,
                                          LambdaCaptureDefault CaptureDefault);
 
   /// Start the definition of a lambda expression.
-  CXXMethodDecl *startLambdaDefinition(CXXRecordDecl *Class,
-                                       SourceRange IntroducerRange,
-                                       TypeSourceInfo *MethodType,
-                                       SourceLocation EndLoc,
-                                       ArrayRef<ParmVarDecl *> Params,
-                                       ConstexprSpecKind ConstexprKind,
-                                       Expr *TrailingRequiresClause);
+  CXXMethodDecl *
+  startLambdaDefinition(CXXRecordDecl *Class, SourceRange IntroducerRange,
+                        TypeSourceInfo *MethodType, SourceLocation EndLoc,
+                        ConstexprSpecKind ConstexprKind, StorageClass SC,
 
   /// Number lambda for linkage purposes if necessary.
   void handleLambdaNumbering(
       CXXRecordDecl *Class, CXXMethodDecl *Method,
       Optional<std::tuple<bool, unsigned, unsigned, Decl *>> Mangling = None);
 
   /// Endow the lambda scope info with the relevant properties.
   void buildLambdaScope(sema::LambdaScopeInfo *LSI,

clang/lib/Frontend/InitPreprocessor.cpp

if (LangOpts.CPlusPlus20) {
     Builder.defineMacro("__cpp_using_enum", "201907L");
   }
   // C++2b features.
   if (LangOpts.CPlusPlus2b) {
     Builder.defineMacro("__cpp_implicit_move", "202011L");
     Builder.defineMacro("__cpp_size_t_suffix", "202011L");
     Builder.defineMacro("__cpp_if_consteval", "202106L");
     Builder.defineMacro("__cpp_multidimensional_subscript", "202110L");
+    Builder.defineMacro("__cpp_static_call_operator", "202207L");
   }
   if (LangOpts.Char8)
     Builder.defineMacro("__cpp_char8_t", "201811L");
   Builder.defineMacro("__cpp_impl_destroying_delete", "201806L");
 
   // TS features.
   if (LangOpts.Coroutines)
     Builder.defineMacro("__cpp_coroutines", "201703L");

clang/lib/Parse/ParseExprCXX.cpp

bool Parser::ParseLambdaIntroducer(LambdaIntroducer &Intro,
 
   T.consumeClose();
   Intro.Range.setEnd(T.getCloseLocation());
   return false;
 }
 
 static void tryConsumeLambdaSpecifierToken(Parser &P,
                                            SourceLocation &MutableLoc,
+                                           SourceLocation &StaticLoc,
                                            SourceLocation &ConstexprLoc,
                                            SourceLocation &ConstevalLoc,
                                            SourceLocation &DeclEndLoc) {
   assert(MutableLoc.isInvalid());
+  assert(StaticLoc.isInvalid());
   assert(ConstexprLoc.isInvalid());
+  assert(ConstevalLoc.isInvalid());
   // Consume constexpr-opt mutable-opt in any sequence, and set the DeclEndLoc
   // to the final of those locations. Emit an error if we have multiple
   // copies of those keywords and recover.
 
-  while (true) {
-    switch (P.getCurToken().getKind()) {
-    case tok::kw_mutable: {
-      if (MutableLoc.isValid()) {
-        P.Diag(P.getCurToken().getLocation(),
-               diag::err_lambda_decl_specifier_repeated)
-            << 0 << FixItHint::CreateRemoval(P.getCurToken().getLocation());
-      }
-      MutableLoc = P.ConsumeToken();
-      DeclEndLoc = MutableLoc;
-      break /*switch*/;
+  auto ConsumeLocation = [&P, &DeclEndLoc](SourceLocation &SpecifierLoc,
+                                           int diag_index) {
+    if (SpecifierLoc.isValid()) {
+          << diag_index
+          << FixItHint::CreateRemoval(P.getCurToken().getLocation());
     }
+    SpecifierLoc = P.ConsumeToken();
+    DeclEndLoc = SpecifierLoc;
+  };
+
+  while (true) {
+    switch (P.getCurToken().getKind()) {
+    case tok::kw_mutable:
+      ConsumeLocation(MutableLoc, 0);
+      break;
+    case tok::kw_static:
+      ConsumeLocation(StaticLoc, 1);
+      break;
     case tok::kw_constexpr:
-      if (ConstexprLoc.isValid()) {
-        P.Diag(P.getCurToken().getLocation(),
-               diag::err_lambda_decl_specifier_repeated)
-            << 1 << FixItHint::CreateRemoval(P.getCurToken().getLocation());
-      }
-      ConstexprLoc = P.ConsumeToken();
-      DeclEndLoc = ConstexprLoc;
-      break /*switch*/;
+      ConsumeLocation(ConstexprLoc, 2);
+      break;
     case tok::kw_consteval:
-      if (ConstevalLoc.isValid()) {
-        P.Diag(P.getCurToken().getLocation(),
-               diag::err_lambda_decl_specifier_repeated)
-            << 2 << FixItHint::CreateRemoval(P.getCurToken().getLocation());
-      }
-      ConstevalLoc = P.ConsumeToken();
-      DeclEndLoc = ConstevalLoc;
-      break /*switch*/;
+      ConsumeLocation(ConstevalLoc, 3);
+      break;
     default:
       return;
     }
   }
 }
 
+static void addStaticToLambdaDeclSpecifier(Parser &P, SourceLocation StaticLoc,
+                                           DeclSpec &DS) {
+  if (StaticLoc.isValid()) {
+    P.Diag(StaticLoc, !P.getLangOpts().CPlusPlus2b
+                          ? diag::err_static_lambda
+                          : diag::warn_cxx20_compat_static_lambda);
+    const char *PrevSpec = nullptr;
+    unsigned DiagID = 0;
+    DS.SetStorageClassSpec(P.getActions(), DeclSpec::SCS_static, StaticLoc,
+                           PrevSpec, DiagID,
+                           P.getActions().getASTContext().getPrintingPolicy());
+    assert(PrevSpec == nullptr && DiagID == 0 &&
+           "Static cannot have been set previously!");
+  }
+}
+
 static void
 addConstexprToLambdaDeclSpecifier(Parser &P, SourceLocation ConstexprLoc,
                                   DeclSpec &DS) {
   if (ConstexprLoc.isValid()) {
     P.Diag(ConstexprLoc, !P.getLangOpts().CPlusPlus17
                              ? diag::ext_constexpr_on_lambda_cxx17
                              : diag::warn_cxx14_compat_constexpr_on_lambda);
     const char *PrevSpec = nullptr;
if (ConstevalLoc.isValid()) {
     unsigned DiagID = 0;
     DS.SetConstexprSpec(ConstexprSpecKind::Consteval, ConstevalLoc, PrevSpec,
                         DiagID);
     if (DiagID != 0)
       P.Diag(ConstevalLoc, DiagID) << PrevSpec;
   }
 }
 
+static void DiagnoseStaticSpecifierRestrictions(Parser &P,
+                                                SourceLocation StaticLoc,
+                                                SourceLocation MutableLoc,
+                                                const LambdaIntroducer &Intro) {
+  if (StaticLoc.isInvalid())
+    return;
+
+  // [expr.prim.lambda.general] p4
+  // The lambda-specifier-seq shall not contain both mutable and static.
+  // If the lambda-specifier-seq contains static, there shall be no
+  // lambda-capture.
+  if (MutableLoc.isValid())
+    P.Diag(StaticLoc, diag::err_static_mutable_lambda);
+  if (Intro.hasLambdaCapture()) {
+    P.Diag(StaticLoc, diag::err_static_lambda_captures);
+    P.Diag(Intro.DefaultLoc.isValid() ? Intro.DefaultLoc
+                                      : Intro.Captures[0].Loc,
+           diag::note_lambda_captures);
+  }
+}
+
 /// ParseLambdaExpressionAfterIntroducer - Parse the rest of a lambda
 /// expression.
 ExprResult Parser::ParseLambdaExpressionAfterIntroducer(
                      LambdaIntroducer &Intro) {
   SourceLocation LambdaBeginLoc = Intro.Range.getBegin();
   Diag(LambdaBeginLoc, diag::warn_cxx98_compat_lambda);
 
   PrettyStackTraceLoc CrashInfo(PP.getSourceManager(), LambdaBeginLoc,
auto ParseLambdaSpecifiers =
           SourceLocation EllipsisLoc) {
         SourceLocation DeclEndLoc = RParenLoc;
 
         // GNU-style attributes must be parsed before the mutable specifier to
         // be compatible with GCC. MSVC-style attributes must be parsed before
         // the mutable specifier to be compatible with MSVC.
         MaybeParseAttributes(PAKM_GNU | PAKM_Declspec, Attr);
 
-        // Parse mutable-opt and/or constexpr-opt or consteval-opt, and update
-        // the DeclEndLoc.
+        // Parse lambda specifiers and update the DeclEndLoc.
         SourceLocation MutableLoc;
+        SourceLocation StaticLoc;
         SourceLocation ConstexprLoc;
         SourceLocation ConstevalLoc;
-        tryConsumeLambdaSpecifierToken(*this, MutableLoc, ConstexprLoc,
-                                       ConstevalLoc, DeclEndLoc);
+        tryConsumeLambdaSpecifierToken(*this, MutableLoc, StaticLoc,
+                                       ConstexprLoc, ConstevalLoc, DeclEndLoc);
+
+        DiagnoseStaticSpecifierRestrictions(*this, StaticLoc, MutableLoc,
+                                            Intro);
 
+        addStaticToLambdaDeclSpecifier(*this, StaticLoc, DS);
         addConstexprToLambdaDeclSpecifier(*this, ConstexprLoc, DS);
         addConstevalToLambdaDeclSpecifier(*this, ConstevalLoc, DS);
         // Parse exception-specification[opt].
         ExceptionSpecificationType ESpecType = EST_None;
         SourceRange ESpecRange;
         SmallVector<ParsedType, 2> DynamicExceptions;
         SmallVector<SourceRange, 2> DynamicExceptionRanges;
         ExprResult NoexceptExpr;
if (Tok.is(tok::l_paren)) {
     // Parse lambda-specifiers.
     ParseLambdaSpecifiers(LParenLoc, /*DeclEndLoc=*/T.getCloseLocation(),
                           ParamInfo, EllipsisLoc);
 
     // Parse requires-clause[opt].
     if (Tok.is(tok::kw_requires))
       ParseTrailingRequiresClause(D);
   } else if (Tok.isOneOf(tok::kw_mutable, tok::arrow, tok::kw___attribute,
-                         tok::kw_constexpr, tok::kw_consteval,
+                         tok::kw_constexpr, tok::kw_consteval, tok::kw_static,
                          tok::kw___private, tok::kw___global, tok::kw___local,
                          tok::kw___constant, tok::kw___generic,
                          tok::kw_requires, tok::kw_noexcept) ||
              (Tok.is(tok::l_square) && NextToken().is(tok::l_square))) {
     if (!getLangOpts().CPlusPlus2b)
       // It's common to forget that one needs '()' before 'mutable', an
       // attribute specifier, the result type, or the requires clause. Deal with
       // this.

clang/lib/Sema/SemaChecking.cpp

bool Sema::CheckFunctionCall(FunctionDecl *FDecl, CallExpr *TheCall,
   bool IsMemberFunction = isa<CXXMemberCallExpr>(TheCall) ||
                           IsMemberOperatorCall;
   VariadicCallType CallType = getVariadicCallType(FDecl, Proto,
                                                   TheCall->getCallee());
   Expr** Args = TheCall->getArgs();
   unsigned NumArgs = TheCall->getNumArgs();
 
   Expr *ImplicitThis = nullptr;
-  if (IsMemberOperatorCall) {
-    // If this is a call to a member operator, hide the first argument
-    // from checkCall.
+  if (IsMemberOperatorCall && !FDecl->isStatic()) {
+    // If this is a call to a non-static member operator, hide the first
+    // argument from checkCall.
     // FIXME: Our choice of AST representation here is less than ideal.
     ImplicitThis = Args[0];
     ++Args;
     --NumArgs;
-  } else if (IsMemberFunction)
+  } else if (IsMemberFunction && !FDecl->isStatic())
     ImplicitThis =
         cast<CXXMemberCallExpr>(TheCall)->getImplicitObjectArgument();
 
   if (ImplicitThis) {
     // ImplicitThis may or may not be a pointer, depending on whether . or -> is
     // used.
     QualType ThisType = ImplicitThis->getType();
     if (!ThisType->isPointerType()) {

clang/lib/Sema/SemaDeclCXX.cpp

void Sema::DefineImplicitLambdaToFunctionPointerConversion(
   assert(!Conv->getReturnType()->isUndeducedType());
 
   QualType ConvRT = Conv->getType()->castAs<FunctionType>()->getReturnType();
   CallingConv CC =
       ConvRT->getPointeeType()->castAs<FunctionType>()->getCallConv();
 
   CXXRecordDecl *Lambda = Conv->getParent();
   FunctionDecl *CallOp = Lambda->getLambdaCallOperator();
-  FunctionDecl *Invoker = Lambda->getLambdaStaticInvoker(CC);
+  FunctionDecl *Invoker =
+      CallOp->isStatic() ? CallOp : Lambda->getLambdaStaticInvoker(CC);
 
   if (auto *TemplateArgs = Conv->getTemplateSpecializationArgs()) {
     CallOp = InstantiateFunctionDeclaration(
         CallOp->getDescribedFunctionTemplate(), TemplateArgs, CurrentLocation);
     if (!CallOp)
       return;
 
+    if (CallOp != Invoker) {
       Invoker = InstantiateFunctionDeclaration(
-        Invoker->getDescribedFunctionTemplate(), TemplateArgs, CurrentLocation);
+          Invoker->getDescribedFunctionTemplate(), TemplateArgs,
+          CurrentLocation);
       if (!Invoker)
         return;
     }
+  }
 
   if (CallOp->isInvalidDecl())
     return;
 
   // Mark the call operator referenced (and add to pending instantiations
   // if necessary).
   // For both the conversion and static-invoker template specializations
   // we construct their body's in this function, so no need to add them
   // to the PendingInstantiations.
   MarkFunctionReferenced(CurrentLocation, CallOp);
 
+  if (Invoker != CallOp) {
     // Fill in the __invoke function with a dummy implementation. IR generation
     // will fill in the actual details. Update its type in case it contained
     // an 'auto'.
     Invoker->markUsed(Context);
     Invoker->setReferenced();
     Invoker->setType(Conv->getReturnType()->getPointeeType());
     Invoker->setBody(new (Context) CompoundStmt(Conv->getLocation()));
+  }
 
   // Construct the body of the conversion function { return __invoke; }.
-  Expr *FunctionRef = BuildDeclRefExpr(Invoker, Invoker->getType(),
-                                       VK_LValue, Conv->getLocation());
+  Expr *FunctionRef = BuildDeclRefExpr(Invoker, Invoker->getType(), VK_LValue,
+                                       Conv->getLocation());
   assert(FunctionRef && "Can't refer to __invoke function?");
   Stmt *Return = BuildReturnStmt(Conv->getLocation(), FunctionRef).get();
   Conv->setBody(CompoundStmt::Create(Context, Return, FPOptionsOverride(),
                                      Conv->getLocation(), Conv->getLocation()));
   Conv->markUsed(Context);
   Conv->setReferenced();
 
   if (ASTMutationListener *L = getASTMutationListener()) {
     L->CompletedImplicitDefinition(Conv);
+    if (Invoker != CallOp) {
       L->CompletedImplicitDefinition(Invoker);
     }
   }
-
-
+}
 
 void Sema::DefineImplicitLambdaToBlockPointerConversion(
-       SourceLocation CurrentLocation,
-       CXXConversionDecl *Conv)
-{
+    SourceLocation CurrentLocation, CXXConversionDecl *Conv) {
   assert(!Conv->getParent()->isGenericLambda());
 
   SynthesizedFunctionScope Scope(*this, Conv);
 
   // Copy-initialize the lambda object as needed to capture it.
   Expr *This = ActOnCXXThis(CurrentLocation).get();
   Expr *DerefThis =CreateBuiltinUnaryOp(CurrentLocation, UO_Deref, This).get();
 
bool Sema::CheckOverloadedOperatorDeclaration(FunctionDecl *FnDecl) {
   //   found in the rest of this subclause do not apply to them unless
   //   explicitly stated in 3.7.3.
   if (Op == OO_Delete || Op == OO_Array_Delete)
     return CheckOperatorDeleteDeclaration(*this, FnDecl);
 
   if (Op == OO_New || Op == OO_Array_New)
     return CheckOperatorNewDeclaration(*this, FnDecl);
 
-  // C++ [over.oper]p6:
-  //   An operator function shall either be a non-static member
-  //   function or be a non-member function and have at least one
-  //   parameter whose type is a class, a reference to a class, an
-  //   enumeration, or a reference to an enumeration.
+  // C++ [over.oper]p7:
+  //   An operator function shall either be a member function or
+  //   be a non-member function and have at least one parameter
+  //   whose type is a class, a reference to a class, an enumeration,
+  //   or a reference to an enumeration.
+  // Note: Before C++23, a member function also has to not be static.
   if (CXXMethodDecl *MethodDecl = dyn_cast<CXXMethodDecl>(FnDecl)) {
-    if (MethodDecl->isStatic())
-      return Diag(FnDecl->getLocation(),
-                  diag::err_operator_overload_static) << FnDecl->getDeclName();
+    if (MethodDecl->isStatic()) {
+      if (Op == OO_Call)
+        Diag(FnDecl->getLocation(),
+             (LangOpts.CPlusPlus2b ? diag::ext_operator_overload_static
+                                   : diag::err_call_operator_overload_static))
+            << FnDecl->getDeclName();
+      else
+        return Diag(FnDecl->getLocation(), diag::err_operator_overload_static)
+               << FnDecl->getDeclName();
+    }
   } else {
     bool ClassOrEnumParam = false;
     for (auto *Param : FnDecl->parameters()) {
       QualType ParamType = Param->getType().getNonReferenceType();
       if (ParamType->isDependentType() || ParamType->isRecordType() ||
           ParamType->isEnumeralType()) {
         ClassOrEnumParam = true;
         break;
#include "clang/Basic/OperatorKinds.def"
   // Overloaded operators other than operator() and operator[] cannot be
   // variadic.
   if (Op != OO_Call &&
       FnDecl->getType()->castAs<FunctionProtoType>()->isVariadic()) {
     return Diag(FnDecl->getLocation(), diag::err_operator_overload_variadic)
            << FnDecl->getDeclName();
   }
 
-  // Some operators must be non-static member functions.
+  // Some operators must be member functions.
   if (MustBeMemberOperator && !isa<CXXMethodDecl>(FnDecl)) {
     return Diag(FnDecl->getLocation(),
                 diag::err_operator_overload_must_be_member)
       << FnDecl->getDeclName();
   }
 
   // C++ [over.inc]p1:
   //   The user-defined function called operator++ implements the

clang/lib/Sema/SemaLambda.cpp

return std::make_tuple(
         &Context.getManglingNumberContext(ASTContext::NeedExtraManglingDecl,
                                           ManglingContextDecl),
         ManglingContextDecl);
   }
 
   llvm_unreachable("unexpected context");
 }
 
-CXXMethodDecl *Sema::startLambdaDefinition(CXXRecordDecl *Class,
-                                           SourceRange IntroducerRange,
-                                           TypeSourceInfo *MethodTypeInfo,
-                                           SourceLocation EndLoc,
-                                           ArrayRef<ParmVarDecl *> Params,
-                                           ConstexprSpecKind ConstexprKind,
-                                           Expr *TrailingRequiresClause) {
+CXXMethodDecl *Sema::startLambdaDefinition(
+    CXXRecordDecl *Class, SourceRange IntroducerRange,
+    TypeSourceInfo *MethodTypeInfo, SourceLocation EndLoc,
+    ArrayRef<ParmVarDecl *> Params, ConstexprSpecKind ConstexprKind,
+    StorageClass SC, Expr *TrailingRequiresClause) {
   QualType MethodType = MethodTypeInfo->getType();
   TemplateParameterList *TemplateParams =
       getGenericLambdaTemplateParameterList(getCurLambda(), *this);
   // If a lambda appears in a dependent context or is a generic lambda (has
   // template parameters) and has an 'auto' return type, deduce it to a
   // dependent type.
   if (Class->isDependentContext() || TemplateParams) {
     const FunctionProtoType *FPT = MethodType->castAs<FunctionProtoType>();
CXXMethodDecl *Sema::startLambdaDefinition(
   DeclarationName MethodName
     = Context.DeclarationNames.getCXXOperatorName(OO_Call);
   DeclarationNameLoc MethodNameLoc =
       DeclarationNameLoc::makeCXXOperatorNameLoc(IntroducerRange);
   CXXMethodDecl *Method = CXXMethodDecl::Create(
       Context, Class, EndLoc,
       DeclarationNameInfo(MethodName, IntroducerRange.getBegin(),
                           MethodNameLoc),
-      MethodType, MethodTypeInfo, SC_None, getCurFPFeatures().isFPConstrained(),
+      MethodType, MethodTypeInfo, SC, getCurFPFeatures().isFPConstrained(),
       /*isInline=*/true, ConstexprKind, EndLoc, TrailingRequiresClause);
   Method->setAccess(AS_public);
   if (!TemplateParams)
     Class->addDecl(Method);
 
   // Temporarily set the lexical declaration context to the current
   // context, so that the Scope stack matches the lexical nesting.
   Method->setLexicalDeclContext(CurContext);
void Sema::ActOnStartOfLambdaDefinition(LambdaIntroducer &Intro,
 
   // Determine the signature of the call operator.
   TypeSourceInfo *MethodTyInfo;
   bool ExplicitParams = true;
   bool ExplicitResultType = true;
   bool ContainsUnexpandedParameterPack = false;
   SourceLocation EndLoc;
   SmallVector<ParmVarDecl *, 8> Params;
+
+  assert(ParamInfo.getDeclSpec().getStorageClassSpec() ==
+             DeclSpec::SCS_unspecified ||
+         ParamInfo.getDeclSpec().getStorageClassSpec() ==
+                 DeclSpec::SCS_static &&
+             "Unexpected storage specifier");
+  bool IsLambdaStatic =
+      ParamInfo.getDeclSpec().getStorageClassSpec() == DeclSpec::SCS_static;
+
   if (ParamInfo.getNumTypeObjects() == 0) {
     // C++11 [expr.prim.lambda]p4:
     //   If a lambda-expression does not include a lambda-declarator, it is as
     //   if the lambda-declarator were ().
     FunctionProtoType::ExtProtoInfo EPI(Context.getDefaultCallingConvention(
         /*IsVariadic=*/false, /*IsCXXMethod=*/true));
     EPI.HasTrailingReturn = true;
     EPI.TypeQuals.addConst();
if (ParamInfo.getNumTypeObjects() == 0) {
     assert(ParamInfo.isFunctionDeclarator() &&
            "lambda-declarator is a function");
     DeclaratorChunk::FunctionTypeInfo &FTI = ParamInfo.getFunctionTypeInfo();
 
     // C++11 [expr.prim.lambda]p5:
     //   This function call operator is declared const (9.3.1) if and only if
     //   the lambda-expression's parameter-declaration-clause is not followed
     //   by mutable. It is neither virtual nor declared volatile. [...]
-    if (!FTI.hasMutableQualifier()) {
+    if (!FTI.hasMutableQualifier() && !IsLambdaStatic) {
       FTI.getOrCreateMethodQualifiers().SetTypeQual(DeclSpec::TQ_const,
                                                     SourceLocation());
     }
 
     MethodTyInfo = GetTypeForDeclarator(ParamInfo, CurScope);
     assert(MethodTyInfo && "no type from lambda-declarator");
     EndLoc = ParamInfo.getSourceRange().getEnd();
 
     ExplicitResultType = FTI.hasTrailingReturnType();
if (MethodTyInfo->getType()->containsUnexpandedParameterPack())
                                       UPPC_DeclarationType);
   }
 
   CXXRecordDecl *Class = createLambdaClosureType(
       Intro.Range, MethodTyInfo, LambdaDependencyKind, Intro.Default);
   CXXMethodDecl *Method =
       startLambdaDefinition(Class, Intro.Range, MethodTyInfo, EndLoc, Params,
                             ParamInfo.getDeclSpec().getConstexprSpecifier(),
+                            IsLambdaStatic ? SC_Static : SC_None,
                             ParamInfo.getTrailingRequiresClause());
   if (ExplicitParams)
     CheckCXXDefaultArguments(Method);
 
   // This represents the function body for the lambda function, check if we
   // have to apply optnone due to a pragma.
   AddRangeBasedOptnone(Method);
 
   // code_seg attribute on lambda apply to the method.
   if (Attr *A = getImplicitCodeSegOrSectionAttrForFunction(Method, /*IsDefinition=*/true))
     Method->addAttr(A);
 
   // Attributes on the lambda apply to the method.
   ProcessDeclAttributes(CurScope, Method, ParamInfo);
FunctionTemplateDecl *ConversionTemplate =
                                       TemplateCallOperator->getTemplateParameters(),
                                       Conversion);
     ConversionTemplate->setAccess(AS_public);
     ConversionTemplate->setImplicit(true);
     Conversion->setDescribedFunctionTemplate(ConversionTemplate);
     Class->addDecl(ConversionTemplate);
   } else
     Class->addDecl(Conversion);
-  // Add a non-static member function that will be the result of
-  // the conversion with a certain unique ID.
-  DeclarationName InvokerName = &S.Context.Idents.get(
-                                                 getLambdaStaticInvokerName());
+
+  // If the lambda is not static, we need to add a static member
+  // function that will be the result of the conversion with a
+  // certain unique ID.
+  // When it is static we just return the static call operator instead.
+  if (CallOperator->isInstance()) {
+    DeclarationName InvokerName =
+        &S.Context.Idents.get(getLambdaStaticInvokerName());
     // FIXME: Instead of passing in the CallOperator->getTypeSourceInfo()
     // we should get a prebuilt TrivialTypeSourceInfo from Context
     // using FunctionTy & Loc and get its TypeLoc as a FunctionProtoTypeLoc
     // then rewire the parameters accordingly, by hoisting up the InvokeParams
     // loop below and then use its Params to set Invoke->setParams(...) below.
     // This would avoid the 'const' qualifier of the calloperator from
     // contaminating the type of the invoker, which is currently adjusted
     // in SemaTemplateDeduction.cpp:DeduceTemplateArguments.  Fixing the
     // trailing return type of the invoker would require a visitor to rebuild
     // the trailing return type and adjusting all back DeclRefExpr's to refer
     // to the new static invoker parameters - not the call operator's.
     CXXMethodDecl *Invoke = CXXMethodDecl::Create(
         S.Context, Class, Loc, DeclarationNameInfo(InvokerName, Loc),
         InvokerFunctionTy, CallOperator->getTypeSourceInfo(), SC_Static,
         S.getCurFPFeatures().isFPConstrained(),
         /*isInline=*/true, ConstexprSpecKind::Unspecified,
         CallOperator->getBody()->getEndLoc());
     for (unsigned I = 0, N = CallOperator->getNumParams(); I != N; ++I)
       InvokerParams[I]->setOwningFunction(Invoke);
     Invoke->setParams(InvokerParams);
     Invoke->setAccess(AS_private);
     Invoke->setImplicit(true);
     if (Class->isGenericLambda()) {
       FunctionTemplateDecl *TemplateCallOperator =
-            CallOperator->getDescribedFunctionTemplate();
-    FunctionTemplateDecl *StaticInvokerTemplate = FunctionTemplateDecl::Create(
-                          S.Context, Class, Loc, InvokerName,
-                          TemplateCallOperator->getTemplateParameters(),
-                          Invoke);
+      FunctionTemplateDecl *StaticInvokerTemplate =
+          FunctionTemplateDecl::Create(
+              TemplateCallOperator->getTemplateParameters(), Invoke);
       StaticInvokerTemplate->setAccess(AS_private);
       StaticInvokerTemplate->setImplicit(true);
       Invoke->setDescribedFunctionTemplate(StaticInvokerTemplate);
       Class->addDecl(StaticInvokerTemplate);
     } else
       Class->addDecl(Invoke);
   }
+}
 
 /// Add a lambda's conversion to function pointers, as described in
 /// C++11 [expr.prim.lambda]p6. Note that in most cases, this should emit only a
 /// single pointer conversion. In the event that the default calling convention
 /// for free and member functions is different, it will emit both conventions.
 static void addFunctionPointerConversions(Sema &S, SourceRange IntroducerRange,
                                           CXXRecordDecl *Class,
                                           CXXMethodDecl *CallOperator) {

clang/lib/Sema/SemaOverload.cpp

if (Args.size() < MinRequiredArgs && !PartialOverloading) {
     // Not enough arguments.
     Candidate.Viable = false;
     Candidate.FailureKind = ovl_fail_too_few_arguments;
     return;
   }
 
   Candidate.Viable = true;
 
-  if (Method->isStatic() || ObjectType.isNull())
-    // The implicit object argument is ignored.
+  // The implicit object argument is ignored in <= C++20 for static member
+  // functions. Since C++23 it is used to break ties between static call
+  // operators and implicit conversions to function pointers (See P1169R4).
+  if ((!LangOpts.CPlusPlus2b && Method->isStatic()) || ObjectType.isNull())
     Candidate.IgnoreObjectArgument = true;
   else {
     unsigned ConvIdx = PO == OverloadCandidateParamOrder::Reversed ? 1 : 0;
     // Determine the implicit conversion sequence for the object
     // parameter.
     Candidate.Conversions[ConvIdx] = TryObjectArgumentInitialization(
         *this, CandidateSet.getLocation(), ObjectType, ObjectClassification,
         Method, ActingContext);
     if (Candidate.Conversions[ConvIdx].isBad()) {
       Candidate.Viable = false;
       Candidate.FailureKind = ovl_fail_bad_conversion;
       return;
     }
   }
 
   // (CUDA B.1): Check for invalid calls between targets.
   if (getLangOpts().CUDA)
     if (const FunctionDecl *Caller = getCurFunctionDecl(/*AllowLambda=*/true))
       if (!IsAllowedCUDACall(Caller, Method)) {
         Candidate.Viable = false;
         Candidate.FailureKind = ovl_fail_bad_target;
         return;
       }
if (FunctionDecl *Caller = S.getCurFunctionDecl(/*AllowLambda=*/true)) {
       auto Cand2Emittable = P2 > EmitThreshold;
       if (Cand1Emittable && !Cand2Emittable)
         return true;
       if (!Cand1Emittable && Cand2Emittable)
         return false;
     }
   }
 
-  // C++ [over.match.best]p1:
+  // C++ [over.match.best]p1: (Changed in C++2b)
   //
   //   -- if F is a static member function, ICS1(F) is defined such
   //      that ICS1(F) is neither better nor worse than ICS1(G) for
   //      any function G, and, symmetrically, ICS1(G) is neither
   //      better nor worse than ICS1(F).
   unsigned StartArg = 0;
   if (Cand1.IgnoreObjectArgument || Cand2.IgnoreObjectArgument)
     StartArg = 1;
Sema::BuildCallToObjectOfClassType(Scope *S, Expr *Obj,
   if (NewFn.isInvalid())
     return true;
 
   SmallVector<Expr *, 8> MethodArgs;
   MethodArgs.reserve(NumParams + 1);
 
   bool IsError = false;
 
-  // Initialize the implicit object parameter.
-  ExprResult ObjRes =
-    PerformObjectArgumentInitialization(Object.get(), /*Qualifier=*/nullptr,
-                                        Best->FoundDecl, Method);
+  // Initialize the implicit object parameter if needed.
+  // Since C++2b, this could also be a call to a static call operator
+  // which we emit as a regular CallExpr.
+  if (Method->isInstance()) {
+    ExprResult ObjRes = PerformObjectArgumentInitialization(
+        Object.get(), /*Qualifier=*/nullptr, Best->FoundDecl, Method);
     if (ObjRes.isInvalid())
       IsError = true;
     else
       Object = ObjRes;
     MethodArgs.push_back(Object.get());
+  }
 
   IsError |= PrepareArgumentsForCallToObjectOfClassType(
       *this, MethodArgs, Method, Args, LParenLoc);
 
   // If this is a variadic call, handle args passed through "...".
   if (Proto->isVariadic()) {
     // Promote the arguments (C99 6.5.2.2p7).
     for (unsigned i = NumParams, e = Args.size(); i < e; i++) {
Sema::BuildCallToObjectOfClassType(Scope *S, Expr *Obj,
 
   DiagnoseSentinelCalls(Method, LParenLoc, Args);
 
   // Once we've built TheCall, all of the expressions are properly owned.
   QualType ResultTy = Method->getReturnType();
   ExprValueKind VK = Expr::getValueKindForType(ResultTy);
   ResultTy = ResultTy.getNonLValueExprType(Context);
 
-  CXXOperatorCallExpr *TheCall = CXXOperatorCallExpr::Create(
-      Context, OO_Call, NewFn.get(), MethodArgs, ResultTy, VK, RParenLoc,
+  CallExpr *TheCall;
+  if (Method->isInstance())
+    TheCall = CXXOperatorCallExpr::Create(Context, OO_Call, NewFn.get(),
+                                          MethodArgs, ResultTy, VK, RParenLoc,
                                           CurFPFeatureOverrides());
+  else
+    TheCall = CallExpr::Create(Context, NewFn.get(), MethodArgs, ResultTy, VK,
+                               RParenLoc, CurFPFeatureOverrides());
 
   if (CheckCallReturnType(Method->getReturnType(), LParenLoc, TheCall, Method))
     return true;
 
   if (CheckFunctionCall(Method, TheCall, Proto))
     return true;
 
   return CheckForImmediateInvocation(MaybeBindToTemporary(TheCall), Method);

clang/lib/Sema/TreeTransform.h

Mangling = std::make_tuple(OldClass->hasKnownLambdaInternalLinkage(),
                                OldClass->getLambdaContextDecl());
 
   // Build the call operator.
   CXXMethodDecl *NewCallOperator = getSema().startLambdaDefinition(
       Class, E->getIntroducerRange(), NewCallOpTSI,
       E->getCallOperator()->getEndLoc(),
       NewCallOpTSI->getTypeLoc().castAs<FunctionProtoTypeLoc>().getParams(),
       E->getCallOperator()->getConstexprKind(),
-      NewTrailingRequiresClause.get());
+      E->getCallOperator()->getStorageClass(), NewTrailingRequiresClause.get());
 
   LSI->CallOperator = NewCallOperator;
 
   getDerived().transformAttrs(E->getCallOperator(), NewCallOperator);
   getDerived().transformedLocalDecl(E->getCallOperator(), {NewCallOperator});
 
   // Number the lambda for linkage purposes if necessary.
   getSema().handleLambdaNumbering(Class, NewCallOperator, Mangling);

clang/test/CXX/over/over.match/over.match.best/over.best.ics/p6.cpp

+// RUN: %clang_cc1 -fsyntax-only -verify=cxx2b -std=c++2b %s
+// RUN: %clang_cc1 -fsyntax-only -verify=cxx20 -std=c++20 %s
+// cxx2b-no-diagnostics
+
+struct __unique {
+    static constexpr auto operator()() { return 4; };  // cxx20-error {{cannot be declared static}} // cxx20-note {{candidate}}
+
+    using P = int();
+    constexpr operator P*() { return operator(); } // cxx20-note {{conversion candidate}}
+};
+
+__unique four{};
+
+int test_four() {
+  // Checks that overload resolution works.
+  return four(); // cxx20-error {{call to object of type '__unique' is ambiguous}}
+}

clang/test/CXX/over/over.oper/p7.cpp

+// RUN: %clang_cc1 -std=c++11 %s -verify=expected,cxx11
+// RUN: %clang_cc1 -std=c++2b %s -verify=expected,cxx2b
+// RUN: %clang_cc1 -std=c++2b -Wpre-c++2b-compat %s -verify=expected,precxx2b
+
+
+struct Functor {
+  static int operator()(int a, int b);
+  // cxx11-error@-1 {{cannot be declared static}}
+  // precxx2b-warning@-2 {{making static overloaded 'operator()' is a C++2b extension}}
+};
+
+struct InvalidParsing1 {
+  extern int operator()(int a, int b);  // expected-error {{storage class specified}}
+};
+
+struct InvalidParsing2 {
+  extern static int operator()(int a, int b);  // expected-error {{storage class specified}} // expected-error {{cannot combine with previous 'extern' declaration specifier}}
+};

clang/test/CodeGenCXX/cxx2b-static-call-operator.cpp

+// RUN: %clang_cc1 -std=c++2b %s -emit-llvm -triple x86_64-linux -o - | FileCheck %s
+// RUN: %clang_cc1 -std=c++2b %s -emit-llvm -triple x86_64-windows-msvc -o - | FileCheck %s
+
+struct Functor {
+  static int operator()(int x, int y) {
+    return x + y;
+  }
+};
+
+auto GetALambda() {
+  return [](int x, int y) static {
+    return x + y;
+  };
+}
+
+void CallsTheLambda() {
+  GetALambda()(1, 2);
+}
+
+// CHECK:      define {{.*}}CallsTheLambda{{.*}}
+// CHECK-NEXT: entry:
+// CHECK-NEXT:   %call = call noundef i32 {{.*}}(i32 noundef 1, i32 noundef 2)
+// CHECK-NEXT:   ret void
+// CHECK-NEXT: }
+
+void call_static_call_operator() {
+  Functor f;
+  f(101, 102);
+  f.operator()(201, 202);
+  Functor{}(301, 302);
+}
+
+// CHECK:      define {{.*}}call_static_call_operator{{.*}}
+// CHECK-NEXT: entry:
+// CHECK:        {{.*}} = call noundef i32 {{.*}}Functor{{.*}}(i32 noundef 101, i32 noundef 102)
+// CHECK-NEXT:   {{.*}} = call noundef i32 {{.*}}Functor{{.*}}(i32 noundef 201, i32 noundef 202)
+// CHECK-NEXT:   {{.*}} = call noundef i32 {{.*}}Functor{{.*}}(i32 noundef 301, i32 noundef 302)
+// CHECK-NEXT:   ret void
+// CHECK-NEXT: }
+
+struct FunctorConsteval {
+  consteval static int operator()(int x, int y) {
+      return x + y;
+  }
+};
+
+struct FunctorConstexpr {
+  constexpr static int operator()(int x, int y) {
+      return x + y;
+  }
+};
+
+constexpr auto my_lambda = []() constexpr {
+  return 3;
+};
+
+void test_consteval_constexpr() {
+  int x = 0;
+  int y = FunctorConstexpr{}(x, 2);
+  constexpr int z1 = FunctorConsteval{}(2, 2);
+  constexpr int z2 = FunctorConstexpr{}(2, 2);
+  
+  static_assert(z1 == 4);
+  static_assert(z2 == 4);
+
+  constexpr auto my_lambda = []() constexpr static {
+      return 3;
+  };
+  constexpr int (*f)(void) = my_lambda;
+  constexpr int k = f();
+  static_assert(k == 3);
+}
+
+template <class T>
+struct DepFunctor {
+  static int operator()(T t) {
+    return int(t);
+  }
+};
+
+template<class T>
+auto dep_lambda1() {
+  return [](T t) static -> int {
+    return t;
+  };
+}
+
+auto dep_lambda2() {
+  return [](auto t) static -> int {
+    return t;
+  };
+}
+
+void test_dep_functors() {
+  int x = DepFunctor<float>{}(1.0f);
+  int y = DepFunctor<bool>{}(true);
+
+  int a = dep_lambda1<float>()(1.0f);
+  int b = dep_lambda1<bool>()(true);
+
+  int h = dep_lambda2()(1.0f);
+  int i = dep_lambda2()(true);
+}
+
+// CHECK:      define {{.*}}test_dep_functors{{.*}}
+// CHECK-NEXT: entry:
+// CHECK:        %call = call noundef i32 {{.*}}DepFunctor{{.*}}(float noundef 1.000000e+00)
+// CHECK:        %call1 = call noundef i32 {{.*}}DepFunctor{{.*}}(i1 noundef zeroext true)
+// CHECK:        %call2 = call noundef i32 {{.*}}dep_lambda1{{.*}}(float noundef 1.000000e+00)
+// CHECK:        %call3 = call noundef i32 {{.*}}dep_lambda1{{.*}}(i1 noundef zeroext true)
+// CHECK:        %call4 = call noundef i32 {{.*}}dep_lambda2{{.*}}(float noundef 1.000000e+00)
+// CHECK:        %call5 = call noundef i32 {{.*}}dep_lambda2{{.*}}(i1 noundef zeroext true)
+// CHECK:        ret void
+// CHECK-NEXT: }
+
+
+struct __unique {
+    static constexpr auto operator()() { return 4; };
+
+    using P = int();
+    constexpr operator P*() { return operator(); }
+};
+
+__unique four{};
+
+int test_four() {
+  // Checks that overload resolution works.
+  return four();
+}

clang/test/Parser/cxx2b-lambdas-ext-warns.cpp

+// RUN: %clang_cc1 -std=c++20 %s -verify=expected,cxx20
+// RUN: %clang_cc1 -std=c++2b %s -verify=expected,cxx2b
+// RUN: %clang_cc1 -std=c++2b -Wpre-c++2b-compat %s -verify=expected,precxx2b
+
+//cxx2b-no-diagnostics
+
+auto L1 = [] constexpr {};
+// cxx20-warning@-1 {{lambda without a parameter clause is a C++2b extension}}
+auto L2 = []() static {};
+// cxx20-error@-1 {{static lambdas is a C++2b extension}}
+// precxx2b-warning@-2 {{static lambdas are incompatible with C++ standards before C++2b}}
+auto L3 = [] static {};
+// cxx20-warning@-1 {{lambda without a parameter clause is a C++2b extension}}
+// cxx20-error@-2 {{static lambdas is a C++2b extension}}
+// precxx2b-warning@-3 {{static lambdas are incompatible with C++ standards before C++2b}}

clang/test/Parser/cxx2b-lambdas.cpp

auto XL3 = []( constexpr mutable constexpr {}; // expected-error{{invalid storage class specifier}} \
                                                // expected-note{{to match this '('}} \
                                                // expected-error{{expected body}} \
                                                // expected-warning{{duplicate 'constexpr'}}
 
 // http://llvm.org/PR49736
 auto XL4 = [] requires true {}; // expected-error{{expected body}}
 auto XL5 = []<auto> requires true requires true {}; // expected-error{{expected body}}
 auto XL6 = []<auto> requires true noexcept requires true {}; // expected-error{{expected body}}
+
+auto XL7 = []() static static {}; // expected-error {{cannot appear multiple times}}
+auto XL8 = []() static mutable {}; // expected-error {{cannot be both mutable and static}}
+auto XL9 = []() static consteval {};
+auto XL10 = []() static constexpr {};
+
+auto XL11 = [] static {};
+auto XL12 = []() static {};
+auto XL13 = []() static extern {};  // expected-error {{expected body of lambda expression}}
+auto XL14 = []() extern {};  // expected-error {{expected body of lambda expression}}
+
+
+void static_captures() {
+  int x;
+  auto SC1 = [&]() static {}; // expected-error {{a static lambda cannot have any captures}} // expected-note {{captures declared here}}
+  auto SC4 = [x]() static {}; // expected-error {{a static lambda cannot have any captures}} // expected-note {{captures declared here}}
+  auto SC2 = [&x]() static {}; // expected-error {{a static lambda cannot have any captures}} // expected-note {{captures declared here}}
+  auto SC3 = [y=x]() static {}; // expected-error {{a static lambda cannot have any captures}} // expected-note {{captures declared here}}
+  auto SC5 = [&y = x]() static {}; // expected-error {{a static lambda cannot have any captures}} // expected-note {{captures declared here}}
+  auto SC6 = [=]() static {}; // expected-error {{a static lambda cannot have any captures}} // expected-note {{captures declared here}}
+  struct X {
+    int z;
+    void f() {
+      [this]() static {}(); // expected-error {{a static lambda cannot have any captures}} // expected-note {{captures declared here}}
+      [*this]() static {}(); // expected-error {{a static lambda cannot have any captures}} // expected-note {{captures declared here}}
+    }
+  };
+}

clang/test/SemaCXX/lambda-unevaluated.cpp

 // RUN: %clang_cc1 -std=c++20 %s -verify
+// RUN: %clang_cc1 -std=c++2b %s -verify
 
 
 template <auto> struct Nothing {};
 Nothing<[]() { return 0; }()> nothing;
 
 template <typename> struct NothingT {};
 Nothing<[]() { return 0; }> nothingT;
 

 }
 } // namespace GH51414
 
 namespace GH51641 {
 template <class T>
 void foo(decltype(+[](T) {}) lambda, T param);
 static_assert(!__is_same(decltype(foo<int>), void));
 } // namespace GH51641
+
+#if __cplusplus > 202002L
+namespace StaticLambdas {
+template <auto> struct Nothing {};
+Nothing<[]() static { return 0; }()> nothing;
+
+template <typename> struct NothingT {};
+Nothing<[]() static { return 0; }> nothingT;
+
+template <typename T>
+concept True = [] static { return true; }();
+static_assert(True<int>);
+
+static_assert(sizeof([] static { return 0; }));
+static_assert(sizeof([] static { return 0; }()));
+
+void f()  noexcept(noexcept([] static { return 0; }()));
+
+using a = decltype([] static { return 0; });
+using b = decltype([] static { return 0; }());
+using c = decltype([]() static noexcept(noexcept([] { return 0; }())) { return 0; });
+using d = decltype(sizeof([] static { return 0; }));
+
+}
+#endif

clang/test/SemaCXX/overloaded-operator-decl.cpp

 
 struct PR10839 {
   operator int; // expected-error{{'operator int' cannot be the name of a variable or data member}}
   int operator+; // expected-error{{'operator+' cannot be the name of a variable or data member}}
 };
 
 namespace PR14120 {
   struct A {
-    static void operator()(int& i) { ++i; } // expected-error{{overloaded 'operator()' cannot be a static member function}}
+    static void operator()(int& i) { ++i; } // expected-error{{overloaded 'operator()' cannot be declared static}}
   };
   void f() {
     int i = 0;
     A()(i);
   }
 }

clang/www/cxx_status.html

</tr>
     <tr>
       <td>Using unknown pointers and references in constant expressions</td>
       <td><a href="https://wg21.link/P2280R4">P2280R4</a></td>
       <td class="none" align="center">No</td>
     </tr>
     <tr>
       <td>static <code>operator()</code></td>
       <td><a href="https://wg21.link/P1169R4">P1169R4</a></td>
-      <td class="none" align="center">No</td>
+      <td class="unreleased" align="center">Clang 16</td>
     </tr>
     <tr>
       <td>Extended floating-point types and standard names</td>
       <td><a href="https://wg21.link/P1467R9">P1467R9</a></td>
       <td class="none" align="center">No</td>
     </tr>
     <tr>
       <td>Class template argument deduction from inherited constructors</td>