[clang][C++2b] Fix operator[] with parameter pack expansions

[Tyker]

Summary

operator[] currently crashes when used with parameter packs (https://godbolt.org/z/1z9qGbPcr, https://godbolt.org/z/7cGeabzYW)

This patch fixes these issues.

[cor3ntin]

This looks very similar to https://reviews.llvm.org/D149637 which landed a couple of days ago. Did you confirm there is still an issue on tip of main?

[Tyker]

In D150008#4323784, @cor3ntin wrote:

This looks very similar to https://reviews.llvm.org/D149637 which landed a couple of days ago. Did you confirm there is still an issue on tip of main?

I checked with the original crash I had and it is working with D149637.

clang/lib/Sema/TreeTransform.h

ExprResult RebuildUnaryExprOrTypeTrait(Expr *SubExpr, SourceLocation OpLoc,
 
     return Result;
   }
 
   /// Build a new array subscript expression.
   ///
   /// By default, performs semantic analysis to build the new expression.
   /// Subclasses may override this routine to provide different behavior.
-  ExprResult RebuildArraySubscriptExpr(Expr *LHS,
-                                             SourceLocation LBracketLoc,
-                                             Expr *RHS,
-                                             SourceLocation RBracketLoc) {
+  ExprResult RebuildArraySubscriptExpr(Expr *LHS, SourceLocation LBracketLoc,
+                                       MultiExprArg Args,
     return getSema().ActOnArraySubscriptExpr(/*Scope=*/nullptr, LHS,
-                                             LBracketLoc, RHS,
-                                             RBracketLoc);
+                                             LBracketLoc, Args, RBracketLoc);
   }
 
   /// Build a new matrix subscript expression.
   ///
   /// By default, performs semantic analysis to build the new expression.
   /// Subclasses may override this routine to provide different behavior.
   ExprResult RebuildMatrixSubscriptExpr(Expr *Base, Expr *RowIdx,
                                         Expr *ColumnIdx,
ExprResult TreeTransform<Derived>::TransformMSPropertySubscriptExpr(
   if (IdxRes.isInvalid())
     return ExprError();
 
   if (!getDerived().AlwaysRebuild() &&
       BaseRes.get() == E->getBase() &&
       IdxRes.get() == E->getIdx())
     return E;
 
-  return getDerived().RebuildArraySubscriptExpr(
-      BaseRes.get(), SourceLocation(), IdxRes.get(), E->getRBracketLoc());
+  Expr *IdxExpr = IdxRes.get();
+  return getDerived().RebuildArraySubscriptExpr(BaseRes.get(), SourceLocation(),
+                                                MultiExprArg(IdxExpr),
+                                                E->getRBracketLoc());
 }
 
 template <typename Derived>
 StmtResult TreeTransform<Derived>::TransformSEHTryStmt(SEHTryStmt *S) {
   StmtResult TryBlock = getDerived().TransformCompoundStmt(S->getTryBlock());
   if (TryBlock.isInvalid())
     return StmtError();
 

 
 template<typename Derived>
 ExprResult
 TreeTransform<Derived>::TransformArraySubscriptExpr(ArraySubscriptExpr *E) {
   ExprResult LHS = getDerived().TransformExpr(E->getLHS());
   if (LHS.isInvalid())
     return ExprError();
 
-  ExprResult RHS = getDerived().TransformExpr(E->getRHS());
-  if (RHS.isInvalid())
+  /// During Template instantiation, parameter packs maybe be expanded so even
+  /// if we have a single LHS in ArraySubscriptExpr we may have multiple or none
+  /// after pack expansion.
+  bool ArgChanged = false;
+  SmallVector<Expr *, 8> Args;
+  auto RHS = E->getRHS();
+  if (getDerived().TransformExprs(&RHS, 1, true, Args, &ArgChanged))
     return ExprError();
 
-
-  if (!getDerived().AlwaysRebuild() &&
-      LHS.get() == E->getLHS() &&
-      RHS.get() == E->getRHS())
+  if (!getDerived().AlwaysRebuild() && LHS.get() == E->getLHS() && !ArgChanged)
     return E;
 
   return getDerived().RebuildArraySubscriptExpr(
-      LHS.get(),
-      /*FIXME:*/ E->getLHS()->getBeginLoc(), RHS.get(), E->getRBracketLoc());
+      LHS.get(), /*FIXME:*/ E->getLHS()->getBeginLoc(), Args,
+      E->getRBracketLoc());
 }
 
 template <typename Derived>
 ExprResult
 TreeTransform<Derived>::TransformMatrixSubscriptExpr(MatrixSubscriptExpr *E) {
   ExprResult Base = getDerived().TransformExpr(E->getBase());
   if (Base.isInvalid())
     return ExprError();

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

struct T2 {
   constexpr auto operator[](auto... arg) {
     return (1 + ... + arg);
   }
 };
 
 static_assert(T2{}[] == 1);
 static_assert(T2{}[1] == 2);
 static_assert(T2{}[1, 1] == 3);
+
+struct A0 {
+  int operator[](int, int) { return 0; }
+};
+A0 a;
+template <typename... n> int f(n... i) {
+  return a[i...];
+}
+int variadic() {
+  f(0, 1);
+}
+
+template <int> struct A1 {
+  template <typename... n> auto operator[](n... indices) {// expected-note {{'operator[]<int, int>' declared here}}
+    return (*this)[indices...]; // expected-error {{function 'operator[]<int, int>' with deduced return type cannot be used before it is defined}}
+  }
+};
+int variadic1() {
+  A1<0> a;
+  if (a[0, 1]) {}// expected-note {{in instantiation of function template specialization 'A1<0>::operator[]<int, int>' requested here}}
+}
+
+template <typename... n>
+int variadic20(n... i) {
+  int arr[5] = {};
+  return arr[i...];// expected-error 2 {{type 'int[5]' does not provide a subscript operator}}
+}
+
+void variadic2() {
+  variadic20();// expected-note {{in instantiation of function template specialization 'variadic20<>' requested here}}
+  variadic20(0);
+  variadic20(1, 2);// expected-note {{in instantiation of function template specialization 'variadic20<int, int>' requested here}}
+}