[Clang] Implement static operator[]

[royjacobson]

Summary

After accepted in Kona, update the code to accept static operator[] as well.

No big code changes: accept this operator as static in SemaDeclCXX, update AST call generation in SemaOverload and update feature macros + tests accordingly.

[cor3ntin]

Thanks for working on this, it was fast!
It looks good except for an issue with the diagnostic (which was partly pre-existing)

clang/include/clang/Basic/DiagnosticSemaKinds.td

9116–9117

Hum, I did not notice that before but this looks wrong.
If I get that right, this is how it's usually done.

ie it should not be err_ (it's a warning) and in C++23 mode it's not an ExtWarn (which are turned into error in pendantic mode afaik). There are many similar patterns in the same file

[royjacobson]

1. Update warnings according to Corentin's comment
2. Somehow I missed the CodeGen was completely broken. Made a few necessary follow up changes in SemaOverload and ran the tests this time...

clang/include/clang/Basic/DiagnosticSemaKinds.td

9116–9117

thanks! looks much cleaner now.

[cor3ntin]

clang/lib/Sema/SemaOverload.cpp

14462–14467

This looks weird, did you clang-format?

[cor3ntin]

Beside the formatting nitpick this looks good

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

15

I think this is missing a test like
Functor::operator[](42, 42) for completeness

[royjacobson]

Add a missing test case.

[royjacobson]

clang/lib/Sema/SemaOverload.cpp

14462–14467

clang-format insists on this, personally I wouldn't write it like this either :)

[royjacobson]

In D138387#3944211, @cor3ntin wrote:

Beside the formatting nitpick this looks good

Thanks! I'll wait until next week to let other people have a chance to take a look.

[erichkeane]

LGTM, thanks!

clang/docs/ReleaseNotes.rst

 - Do not hide templated base members introduced via using-decl in derived class
   (useful specially for constrained members). Fixes `GH50886 <https://github.com/llvm/llvm-project/issues/50886>`_.
 - Implemented CWG2635 as a Defect Report, which prohibits structured bindings from being constrained.
 
 C++2b Feature Support
 ^^^^^^^^^^^^^^^^^^^^^
 
 - Support label at end of compound statement (`P2324 <https://wg21.link/p2324r2>`_).
-- Implemented `P1169R4: static operator() <https://wg21.link/P1169R4>`_.
+- Implemented `P1169R4: static operator() <https://wg21.link/P1169R4>`_ and `P2589R1: static operator[] <https://wg21.link/P2589R1>`_.
 - Implemented "char8_t Compatibility and Portability Fix" (`P2513R3 <https://wg21.link/P2513R3>`_).
   This change was applied to C++20 as a Defect Report.
 - Implemented "Permitting static constexpr variables in constexpr functions" (`P2647R1 <https://wg21.link/P2647R1>_`).
 
 CUDA/HIP Language Changes in Clang
 ----------------------------------
 
  - Allow the use of ``__noinline__`` as a keyword (instead of ``__attribute__((noinline))``)

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 warn_cxx20_compat_operator_overload_static : Warning<
+  "declaring overloaded %0 as 'static' is incompatible with C++ standards "
+  "before C++2b">, InGroup<CXXPre2bCompat>, DefaultIgnore;
 def ext_operator_overload_static : ExtWarn<
-  "declaring overloaded %0 as 'static' is a C++2b extension">,
-  InGroup<CXXPre2bCompat>, DefaultIgnore;
-def err_call_operator_overload_static : ExtWarn<
   "declaring overloaded %0 as 'static' is a C++2b extension">, InGroup<CXX2b>;
 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/lib/Frontend/InitPreprocessor.cpp

if (LangOpts.CPlusPlus20) {
     //Builder.defineMacro("__cpp_modules", "201907L");
     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_multidimensional_subscript", "202211L");
   }
 
   // We provide those C++2b features as extensions in earlier language modes, so
   // we also define their feature test macros.
   if (LangOpts.CPlusPlus11)
     Builder.defineMacro("__cpp_static_call_operator", "202207L");
   Builder.defineMacro("__cpp_named_character_escapes", "202207L");
 

clang/lib/Sema/SemaDeclCXX.cpp

bool Sema::CheckOverloadedOperatorDeclaration(FunctionDecl *FnDecl) {
   //   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 could not be static. The only member
   //       function allowed to be static is the call operator function.
   if (CXXMethodDecl *MethodDecl = dyn_cast<CXXMethodDecl>(FnDecl)) {
     if (MethodDecl->isStatic()) {
-      if (Op == OO_Call)
+      if (Op == OO_Call || Op == OO_Subscript)
         Diag(FnDecl->getLocation(),
-             (LangOpts.CPlusPlus2b ? diag::ext_operator_overload_static
-                                   : diag::err_call_operator_overload_static))
+             (LangOpts.CPlusPlus2b
+                  ? diag::warn_cxx20_compat_operator_overload_static
+                  : diag::ext_operator_overload_static))
             << FnDecl;
       else
         return Diag(FnDecl->getLocation(), diag::err_operator_overload_static)
                << FnDecl;
     }
   } else {
     bool ClassOrEnumParam = false;
     for (auto *Param : FnDecl->parameters()) {

clang/lib/Sema/SemaOverload.cpp

case OR_Success: {
         // We matched an overloaded operator. Build a call to that
         // operator.
 
         CheckMemberOperatorAccess(LLoc, Args[0], ArgExpr, Best->FoundDecl);
 
         // Convert the arguments.
         CXXMethodDecl *Method = cast<CXXMethodDecl>(FnDecl);
         SmallVector<Expr *, 2> MethodArgs;
+
+        // Handle 'this' parameter if the selected function is not static.
+        if (Method->isInstance()) {
           ExprResult Arg0 = PerformObjectArgumentInitialization(
               Args[0], /*Qualifier=*/nullptr, Best->FoundDecl, Method);
           if (Arg0.isInvalid())
             return ExprError();
 
           MethodArgs.push_back(Arg0.get());
+        }
+
         bool IsError = PrepareArgumentsForCallToObjectOfClassType(
             *this, MethodArgs, Method, ArgExpr, LLoc);
         if (IsError)
           return ExprError();
 
         // Build the actual expression node.
         DeclarationNameInfo OpLocInfo(OpName, LLoc);
         OpLocInfo.setCXXOperatorNameRange(SourceRange(LLoc, RLoc));
         ExprResult FnExpr = CreateFunctionRefExpr(
             *this, FnDecl, Best->FoundDecl, Base, HadMultipleCandidates,
             OpLocInfo.getLoc(), OpLocInfo.getInfo());
         if (FnExpr.isInvalid())
           return ExprError();
 
         // Determine the result type
         QualType ResultTy = FnDecl->getReturnType();
         ExprValueKind VK = Expr::getValueKindForType(ResultTy);
         ResultTy = ResultTy.getNonLValueExprType(Context);
 
-        CXXOperatorCallExpr *TheCall = CXXOperatorCallExpr::Create(
-            Context, OO_Subscript, FnExpr.get(), MethodArgs, ResultTy, VK, RLoc,
-            CurFPFeatureOverrides());
+        CallExpr *TheCall;
+        if (Method->isInstance())
+          TheCall = CXXOperatorCallExpr::Create(
+              Context, OO_Subscript, FnExpr.get(), MethodArgs, ResultTy, VK,
+              RLoc, CurFPFeatureOverrides());
+        else
+          TheCall =
+              CallExpr::Create(Context, FnExpr.get(), MethodArgs, ResultTy, VK,
+                               RLoc, CurFPFeatureOverrides());
+
         if (CheckCallReturnType(FnDecl->getReturnType(), LLoc, TheCall, FnDecl))
           return ExprError();
 
         if (CheckFunctionCall(Method, TheCall,
                               Method->getType()->castAs<FunctionProtoType>()))
           return ExprError();
 
         return CheckForImmediateInvocation(MaybeBindToTemporary(TheCall),

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-warning@-1 {{is a C++2b extension}}
-  // precxx2b-warning@-2 {{declaring overloaded 'operator()' as 'static' is a C++2b extension}}
+  static int operator[](int a1);
+  // cxx11-warning@-2 {{declaring overloaded 'operator()' as 'static' is a C++2b extension}}
+  // cxx11-warning@-2 {{declaring overloaded 'operator[]' as 'static' is a C++2b extension}}
+  // precxx2b-warning@-4 {{incompatible with C++ standards before C++2b}}
+  // precxx2b-warning@-4 {{incompatible with C++ standards before C++2b}}
 };
 
 struct InvalidParsing1 {
   extern int operator()(int a, int b);  // expected-error {{storage class specified}}
+  extern int operator[](int a1);  // 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}}
+  extern static int operator[](int a);  // expected-error {{storage class specified}} // expected-error {{cannot combine with previous 'extern' declaration specifier}}
 };

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

 // CHECK-NEXT:   ret void
 // CHECK-NEXT: }
 
 void call_static_call_operator() {
   Functor f;
   f(101, 102);
   f.operator()(201, 202);
   Functor{}(301, 302);
+  Functor::operator()(401, 402);
 }
 
 // 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:   {{.*}} = call noundef i32 {{.*}}Functor{{.*}}(i32 noundef 401, i32 noundef 402)
 // CHECK-NEXT:   ret void
 // CHECK-NEXT: }
 
 struct FunctorConsteval {
   consteval static int operator()(int x, int y) {
       return x + y;
   }
 };

clang/test/CodeGenCXX/cxx2b-static-subscript-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;
+  }
+};
+
+void call_static_subscript_operator() {
+  Functor f;
+  f[101, 102];
+  f.operator[](201, 202);
+  Functor{}[301, 302];
+  Functor::operator[](401, 402);
+}
+
+// CHECK:      define {{.*}}call_static_subscript_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:   {{.*}} = call noundef i32 {{.*}}Functor{{.*}}(i32 noundef 401, i32 noundef 402)
+// 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;
+  }
+};
+
+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);
+}
+
+template <class T>
+struct DepFunctor {
+  static int operator[](T t) {
+    return int(t);
+  }
+};
+
+void test_dep_functors() {
+  int x = DepFunctor<float>{}[1.0f];
+  int y = DepFunctor<bool>{}[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:        ret void
+// CHECK-NEXT: }

clang/test/Lexer/cxx-features.cpp

 #if check(size_t_suffix, 0, 0, 0, 0, 0, 202011)
 #error "wrong value for __cpp_size_t_suffix"
 #endif
 
 #if check(if_consteval, 0, 0, 0, 0, 0, 202106)
 #error "wrong value for __cpp_if_consteval"
 #endif
 
-#if check(multidimensional_subscript, 0, 0, 0, 0, 0, 202110)
+#if check(multidimensional_subscript, 0, 0, 0, 0, 0, 202211)
 #error "wrong value for __cpp_multidimensional_subscript"
 #endif
 
 #if check(static_call_operator, 0, 202207, 202207, 202207, 202207, 202207)
 #error "wrong value for __cpp_static_call_operator"
 #endif
 
 #if check(named_character_escapes, 202207, 202207, 202207, 202207, 202207, 202207)

clang/www/cxx_status.html

<tr>
       <td>Explicit lifetime management</td>
       <td><a href="https://wg21.link/P2590R2">P2590R2</a></td>
       <td class="none" align="center">No</td>
     </tr>
     <!-- November 2022 (Kona) papers -->
     <tr>
       <td>static <code>operator[]</code></td>
       <td><a href="https://wg21.link/P2589R1">P2589R1</a></td>
-      <td class="none" align="center">No</td>
+      <td class="unreleased" align="center">16</td>
     </tr>
     <tr>
       <td>Permitting static constexpr variables in constexpr functions (DR)</td>
       <td><a href="https://wg21.link/P2647R1">P2647R1</a></td>
       <td class="unreleased" align="center">Clang 16</td>
     </tr>
     <tr>
       <td>consteval needs to propagate up (DR)</td>