[clang] PackIndexingExpr

Author: zyn0217

clang/include/clang/AST/ExprCXX.h

@@ -4417,8 +4417,9 @@ class PackIndexingExpr final
 public:
   static PackIndexingExpr *Create(ASTContext &Context,
                                   SourceLocation EllipsisLoc,
-                                  SourceLocation RSquareLoc, Expr *PackIdExpr,
-                                  Expr *IndexExpr, std::optional<int64_t> Index,
+                                  SourceLocation RSquareLoc, QualType Type,
+                                  Expr *PackIdExpr, Expr *IndexExpr,
+                                  std::optional<int64_t> Index,
                                   ArrayRef<Expr *> SubstitutedExprs = {},
                                   bool ExpandedToEmptyPack = false);
   static PackIndexingExpr *CreateDeserialized(ASTContext &Context,
@@ -4465,6 +4466,28 @@ class PackIndexingExpr final
     return {getTrailingObjects<Expr *>(), TransformedExpressions};
   }
 
+  /// Returns the number of expansion, if known.
+  /// Note we have four states for pack expansion,
+  ///
+  /// 1) The PackIndexingExpr has never been expanded. In this case,
+  /// \code expandsToEmptyPack() == false && getNumExpansions() == nullopt \endcode
+  ///
+  /// 2) The PackIndexingExpr has been expanded, but it expands to empty.
+  /// \code expandsToEmptyPack() == true && getNumExpansions() == 0 \endcode
+  ///
+  /// 3) The PackIndexingExpr has been expanded, but the expansion should be
+  /// held off because the expansion size is unknown.
+  /// \code
+  /// expandsToEmptyPack() == false && getNumExpansions() == nullopt
+  /// \endcode
+  ///
+  /// 4) The PackIndexingExpr has been expanded to non-dependent expressions.
+  /// \code
+  /// expandsToEmptyPack() == false && getNumExpansions() ==
+  /// getExpressions().size()
+  /// \endcode
+  std::optional<unsigned> getNumExpansions() const;
+
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == PackIndexingExprClass;
   }

clang/lib/AST/ComputeDependence.cpp

@@ -385,7 +385,7 @@ ExprDependence clang::computeDependence(PackIndexingExpr *E) {
          ExprDependence::Instantiation;
 
   ArrayRef<Expr *> Exprs = E->getExpressions();
-  if (Exprs.empty())
+  if (!E->getNumExpansions())
     D |= PatternDep | ExprDependence::Instantiation;
 
   else if (!E->getIndexExpr()->isInstantiationDependent()) {

clang/lib/AST/ExprCXX.cpp

@@ -1714,13 +1714,9 @@ NonTypeTemplateParmDecl *SubstNonTypeTemplateParmExpr::getParameter() const {
 
 PackIndexingExpr *PackIndexingExpr::Create(
     ASTContext &Context, SourceLocation EllipsisLoc, SourceLocation RSquareLoc,
-    Expr *PackIdExpr, Expr *IndexExpr, std::optional<int64_t> Index,
-    ArrayRef<Expr *> SubstitutedExprs, bool ExpandedToEmptyPack) {
-  QualType Type;
-  if (Index && !SubstitutedExprs.empty())
-    Type = SubstitutedExprs[*Index]->getType();
-  else
-    Type = Context.DependentTy;
+    QualType Type, Expr *PackIdExpr, Expr *IndexExpr,
+    std::optional<int64_t> Index, ArrayRef<Expr *> SubstitutedExprs,
+    bool ExpandedToEmptyPack) {
 
   void *Storage =
       Context.Allocate(totalSizeToAlloc<Expr *>(SubstitutedExprs.size()));
@@ -1729,6 +1725,17 @@ PackIndexingExpr *PackIndexingExpr::Create(
                        SubstitutedExprs, ExpandedToEmptyPack);
 }
 
+std::optional<unsigned> PackIndexingExpr::getNumExpansions() const {
+  if (!TransformedExpressions && !expandsToEmptyPack())
+    return std::nullopt;
+  if (llvm::any_of(getExpressions(), [](Expr *E) {
+        return isa<PackExpansionExpr>(E) &&
+               !cast<PackExpansionExpr>(E)->getNumExpansions();
+      }))
+    return std::nullopt;
+  return TransformedExpressions;
+}
+
 NamedDecl *PackIndexingExpr::getPackDecl() const {
   if (auto *D = dyn_cast<DeclRefExpr>(getPackIdExpression()); D) {
     NamedDecl *ND = dyn_cast<NamedDecl>(D->getDecl());

clang/lib/Sema/SemaTemplateVariadic.cpp

@@ -1121,16 +1121,29 @@ Sema::BuildPackIndexingExpr(Expr *PackExpression, SourceLocation EllipsisLoc,
     IndexExpr = Res.get();
   }
 
-  if (Index && (!ExpandedExprs.empty() || EmptyPack)) {
+  bool ContainsUnexpandedParameterPack =
+      llvm::any_of(ExpandedExprs, [](Expr *E) {
+        return isa<PackExpansionExpr>(E) &&
+               !cast<PackExpansionExpr>(E)->getNumExpansions();
+      });
+
+  if (!ContainsUnexpandedParameterPack && Index &&
+      (!ExpandedExprs.empty() || EmptyPack)) {
     if (*Index < 0 || EmptyPack || *Index >= int64_t(ExpandedExprs.size())) {
       Diag(PackExpression->getBeginLoc(), diag::err_pack_index_out_of_bound)
           << *Index << PackExpression << ExpandedExprs.size();
       return ExprError();
     }
   }
 
+  QualType Type;
+  if (!ContainsUnexpandedParameterPack && Index && !ExpandedExprs.empty())
+    Type = ExpandedExprs[*Index]->getType();
+  else
+    Type = Context.DependentTy;
+
   return PackIndexingExpr::Create(getASTContext(), EllipsisLoc, RSquareLoc,
-                                  PackExpression, IndexExpr, Index,
+                                  Type, PackExpression, IndexExpr, Index,
                                   ExpandedExprs, EmptyPack);
 }
 

clang/lib/Sema/TreeTransform.h

@@ -15113,8 +15113,7 @@ TreeTransform<Derived>::TransformPackIndexingExpr(PackIndexingExpr *E) {
     // be expanded.
     bool ShouldExpand = true;
     bool RetainExpansion = false;
-    std::optional<unsigned> OrigNumExpansions;
-    std::optional<unsigned> NumExpansions = OrigNumExpansions;
+    std::optional<unsigned> NumExpansions;
     if (getDerived().TryExpandParameterPacks(
             E->getEllipsisLoc(), Pattern->getSourceRange(), Unexpanded,
             ShouldExpand, RetainExpansion, NumExpansions))
@@ -15135,7 +15134,7 @@ TreeTransform<Derived>::TransformPackIndexingExpr(PackIndexingExpr *E) {
         return true;
       if (Out.get()->containsUnexpandedParameterPack()) {
         Out = getDerived().RebuildPackExpansion(Out.get(), E->getEllipsisLoc(),
-                                                OrigNumExpansions);
+                                                /*NumExpansions=*/std::nullopt);
         if (Out.isInvalid())
           return true;
       }
@@ -15151,7 +15150,7 @@ TreeTransform<Derived>::TransformPackIndexingExpr(PackIndexingExpr *E) {
         return true;
 
       Out = getDerived().RebuildPackExpansion(Out.get(), E->getEllipsisLoc(),
-                                              OrigNumExpansions);
+                                              /*NumExpansions=*/std::nullopt);
       if (Out.isInvalid())
         return true;
       ExpandedExprs.push_back(Out.get());

clang/test/SemaCXX/cxx2c-pack-indexing.cpp

@@ -231,3 +231,22 @@ struct type_info {
 namespace GH93650 {
 auto func(auto... inputArgs) { return typeid(inputArgs...[0]); }
 } // namespace GH93650
+
+namespace init_capture_pack {
+
+void init_capture() {
+  auto L = [](auto... x) {
+    return [x...](auto... y) {
+      return [... w = y]() {
+        return w...[3];
+      };
+    };
+  };
+  static_assert(L()(0, 1, 2, 3)() == 3);
+  L()('a', 'b', 'c')();
+  // expected-error@-6 {{invalid index 3 for pack w of size 3}}
+  // expected-note@-8 {{while substituting}}
+  // expected-note@-3 {{requested here}}
+}
+
+}