Only use a single CXXExpansionSelectExpr

Author: Sirraide

clang/include/clang/AST/DeclTemplate.h

@@ -3375,16 +3375,8 @@ class TemplateParamObjectDecl : public ValueDecl,
 /// 'CXXExpansionStmtInstantiation' is. The latter is also what's used for
 /// codegen and constant evaluation.
 ///
-/// There are three kinds of expansion statements; they correspond to three
-/// derived classes of 'CXXExpansionStmtPattern'. There is also a fourth derived
-/// class that is used if we don't know what kind of expansion statement we're
-/// dealing with (because the thing we're expanding is dependent). See the
-/// comment on those classes for more information about how they work:
-///
-///   1. CXXEnumeratingExpansionStmtPattern
-///   2. CXXIteratingExpansionStmtPattern
-///   3. CXXDestructuringExpansionStmtPattern
-///   4. CXXDependentExpansionStmtPattern
+/// There are different kinds of expansion statements; see the comment on
+/// 'CXXExpansionStmtPattern' for more information.
 ///
 /// As an example, if the user writes the following expansion statement:
 /// \verbatim
@@ -3394,10 +3386,9 @@ class TemplateParamObjectDecl : public ValueDecl,
 ///   }
 /// \endverbatim
 ///
-/// The 'CXXExpansionStmtPattern' of this particular 'CXXExpansionStmtDecl' is a
-/// 'CXXDestructuringExpansionStmtPattern', which stores, amongst other things,
-/// the declaration of the variable 'x' as well as the expansion-initializer
-/// 'a'.
+/// The 'CXXExpansionStmtPattern' of this particular 'CXXExpansionStmtDecl'
+/// stores, amongst other things, the declaration of the variable 'x' as well
+/// as the expansion-initializer 'a'.
 ///
 /// After expansion, we end up with a 'CXXExpansionStmtInstantiation' that
 /// is *equivalent* to the AST shown below. Note that only the inner '{}' (i.e.

clang/include/clang/AST/ExprCXX.h

@@ -5499,20 +5499,19 @@ class BuiltinBitCastExpr final
   }
 };
 
-/// Helper that selects an expression from an expansion init list depending
+/// Helper that selects an expression from an InitListExpr depending
 /// on the current expansion index.
 ///
-/// \see CXXEnumeratingExpansionStmtPattern
-class CXXExpansionInitListSelectExpr : public Expr {
+/// \see CXXExpansionStmtPattern
+class CXXExpansionSelectExpr : public Expr {
   friend class ASTStmtReader;
 
   enum SubExpr { RANGE, INDEX, COUNT };
   Expr *SubExprs[COUNT];
 
 public:
-  CXXExpansionInitListSelectExpr(EmptyShell Empty);
-  CXXExpansionInitListSelectExpr(const ASTContext &C,
-                                 InitListExpr *Range, Expr *Idx);
+  CXXExpansionSelectExpr(EmptyShell Empty);
+  CXXExpansionSelectExpr(const ASTContext &C, InitListExpr *Range, Expr *Idx);
 
   InitListExpr *getRangeExpr() {
     return cast<InitListExpr>(SubExprs[RANGE]);
@@ -5543,61 +5542,9 @@ class CXXExpansionInitListSelectExpr : public Expr {
   }
 
   static bool classof(const Stmt *T) {
-    return T->getStmtClass() == CXXExpansionInitListSelectExprClass;
+    return T->getStmtClass() == CXXExpansionSelectExprClass;
   }
 };
-
-/// This class serves the same purpose as CXXExpansionInitListSelectExpr, but
-/// for destructuring expansion statements; that is, instead of selecting among
-/// a list of expressions, it selects from a list of 'BindingDecl's.
-///
-/// \see CXXEnumeratingExpansionStmtPattern
-/// \see CXXDestructuringExpansionStmtPattern
-class CXXDestructuringExpansionSelectExpr : public Expr {
-  friend class ASTStmtReader;
-
-  DecompositionDecl *Decomposition;
-  Expr *Index;
-
-public:
-  CXXDestructuringExpansionSelectExpr(EmptyShell Empty);
-  CXXDestructuringExpansionSelectExpr(const ASTContext &C,
-                                      DecompositionDecl *Decomposition,
-                                      Expr *Index);
-
-  DecompositionDecl *getDecompositionDecl() {
-    return cast<DecompositionDecl>(Decomposition);
-  }
-
-  const DecompositionDecl *getDecompositionDecl() const {
-    return cast<DecompositionDecl>(Decomposition);
-  }
-
-  void setDecompositionDecl(DecompositionDecl *E) { Decomposition = E; }
-
-  Expr *getIndexExpr() { return Index; }
-  const Expr *getIndexExpr() const { return Index; }
-  void setIndexExpr(Expr *E) { Index = E; }
-
-  SourceLocation getBeginLoc() const { return Decomposition->getBeginLoc(); }
-  SourceLocation getEndLoc() const { return Decomposition->getEndLoc(); }
-
-  child_range children() {
-    return child_range(reinterpret_cast<Stmt **>(&Index),
-                       reinterpret_cast<Stmt **>(&Index + 1));
-  }
-
-  const_child_range children() const {
-    return const_child_range(
-        reinterpret_cast<Stmt **>(const_cast<Expr **>(&Index)),
-        reinterpret_cast<Stmt **>(const_cast<Expr **>(&Index + 1)));
-  }
-
-  static bool classof(const Stmt *T) {
-    return T->getStmtClass() == CXXDestructuringExpansionSelectExprClass;
-  }
-};
-
 } // namespace clang
 
 #endif // LLVM_CLANG_AST_EXPRCXX_H

clang/include/clang/AST/RecursiveASTVisitor.h

@@ -3127,8 +3127,7 @@ DEF_TRAVERSE_STMT(RequiresExpr, {
 
 DEF_TRAVERSE_STMT(CXXExpansionStmtPattern, {})
 DEF_TRAVERSE_STMT(CXXExpansionStmtInstantiation, {})
-DEF_TRAVERSE_STMT(CXXExpansionInitListSelectExpr, {})
-DEF_TRAVERSE_STMT(CXXDestructuringExpansionSelectExpr, {})
+DEF_TRAVERSE_STMT(CXXExpansionSelectExpr, {})
 
 // These literals (all of them) do not need any action.
 DEF_TRAVERSE_STMT(IntegerLiteral, {})

clang/include/clang/AST/StmtCXX.h

@@ -554,14 +554,14 @@ class CoreturnStmt : public Stmt {
 /// Here, the '{ 1, 2, 3 }' is parsed as an 'InitListExpr'. This node
 /// handles storing (and pack-expanding) the individual expressions.
 ///
-/// Sema then wraps this with a 'CXXExpansionInitListSelectExpr', which also
+/// Sema then wraps this with a 'CXXExpansionSelectExpr', which also
 /// contains a reference to an integral NTTP that is used as the expansion
 /// index; this index is either dependent (if the expansion-size is dependent),
 /// or set to a value of I in the I-th expansion during the expansion process.
 ///
-/// The actual expansion is done by 'BuildCXXExpansionInitListSelectExpr()': for
+/// The actual expansion is done by 'BuildCXXExpansionSelectExpr()': for
 /// example, during the 2nd expansion of '{ a, b, c }', I is equal to 1, and
-/// BuildCXXExpansionInitListSelectExpr(), when called via TreeTransform,
+/// BuildCXXExpansionSelectExpr(), when called via TreeTransform,
 /// 'instantiates' the expression '{ a, b, c }' to just 'b'.
 ///
 /// 2. Represents an unexpanded iterating expansion statement.
@@ -601,9 +601,8 @@ class CoreturnStmt : public Stmt {
 ///   }
 /// \endverbatim
 ///
-/// Sema wraps the initializer with a CXXDestructuringExpansionSelectExpr, which
-/// selects a binding based on the current expansion index; this is analogous to
-/// how 'CXXExpansionInitListSelectExpr' is used.
+/// Sema wraps the initializer with a CXXExpansionSelectExpr, which selects a
+/// binding based on the current expansion index.
 ///
 /// 4. Represents an expansion statement whose expansion-initializer is
 /// type-dependent.

clang/include/clang/AST/TextNodeDumper.h

@@ -313,8 +313,6 @@ class TextNodeDumper
   void VisitSizeOfPackExpr(const SizeOfPackExpr *Node);
   void
   VisitCXXDependentScopeMemberExpr(const CXXDependentScopeMemberExpr *Node);
-  void VisitCXXDestructuringExpansionSelectExpr(
-      const CXXDestructuringExpansionSelectExpr *Node);
   void VisitObjCAtCatchStmt(const ObjCAtCatchStmt *Node);
   void VisitObjCEncodeExpr(const ObjCEncodeExpr *Node);
   void VisitObjCMessageExpr(const ObjCMessageExpr *Node);

clang/include/clang/Basic/StmtNodes.td

@@ -183,8 +183,7 @@ def ConceptSpecializationExpr : StmtNode<Expr>;
 def RequiresExpr : StmtNode<Expr>;
 
 // C++26 Expansion statement support expressions
-def CXXExpansionInitListSelectExpr : StmtNode<Expr>;
-def CXXDestructuringExpansionSelectExpr : StmtNode<Expr>;
+def CXXExpansionSelectExpr : StmtNode<Expr>;
 
 // Obj-C Expressions.
 def ObjCStringLiteral : StmtNode<Expr>;

clang/include/clang/Serialization/ASTBitCodes.h

@@ -1923,18 +1923,17 @@ enum StmtCode {
   EXPR_TYPE_TRAIT,                  // TypeTraitExpr
   EXPR_ARRAY_TYPE_TRAIT,            // ArrayTypeTraitIntExpr
 
-  EXPR_PACK_EXPANSION,                     // PackExpansionExpr
-  EXPR_PACK_INDEXING,                      // PackIndexingExpr
-  EXPR_SIZEOF_PACK,                        // SizeOfPackExpr
-  EXPR_SUBST_NON_TYPE_TEMPLATE_PARM,       // SubstNonTypeTemplateParmExpr
-  EXPR_SUBST_NON_TYPE_TEMPLATE_PARM_PACK,  // SubstNonTypeTemplateParmPackExpr
-  EXPR_FUNCTION_PARM_PACK,                 // FunctionParmPackExpr
-  EXPR_MATERIALIZE_TEMPORARY,              // MaterializeTemporaryExpr
-  EXPR_CXX_FOLD,                           // CXXFoldExpr
-  EXPR_CONCEPT_SPECIALIZATION,             // ConceptSpecializationExpr
-  EXPR_REQUIRES,                           // RequiresExpr
-  EXPR_CXX_EXPANSION_INIT_LIST_SELECT,     // CXXExpansionInitListSelectExpr
-  EXPR_CXX_DESTRUCTURING_EXPANSION_SELECT, // CXXDestructuringExpansionSelectExpr
+  EXPR_PACK_EXPANSION,                    // PackExpansionExpr
+  EXPR_PACK_INDEXING,                     // PackIndexingExpr
+  EXPR_SIZEOF_PACK,                       // SizeOfPackExpr
+  EXPR_SUBST_NON_TYPE_TEMPLATE_PARM,      // SubstNonTypeTemplateParmExpr
+  EXPR_SUBST_NON_TYPE_TEMPLATE_PARM_PACK, // SubstNonTypeTemplateParmPackExpr
+  EXPR_FUNCTION_PARM_PACK,                // FunctionParmPackExpr
+  EXPR_MATERIALIZE_TEMPORARY,             // MaterializeTemporaryExpr
+  EXPR_CXX_FOLD,                          // CXXFoldExpr
+  EXPR_CONCEPT_SPECIALIZATION,            // ConceptSpecializationExpr
+  EXPR_REQUIRES,                          // RequiresExpr
+  EXPR_CXX_EXPANSION_SELECT,              // CXXExpansionSelectExpr
 
   // CUDA
   EXPR_CUDA_KERNEL_CALL, // CUDAKernelCallExpr

clang/lib/AST/ASTImporter.cpp

@@ -704,10 +704,7 @@ namespace clang {
     VisitSubstNonTypeTemplateParmPackExpr(SubstNonTypeTemplateParmPackExpr *E);
     ExpectedStmt VisitPseudoObjectExpr(PseudoObjectExpr *E);
     ExpectedStmt VisitCXXParenListInitExpr(CXXParenListInitExpr *E);
-    ExpectedStmt
-    VisitCXXExpansionInitListSelectExpr(CXXExpansionInitListSelectExpr *E);
-    ExpectedStmt VisitCXXDestructuringExpansionSelectExpr(
-        CXXDestructuringExpansionSelectExpr *E);
+    ExpectedStmt VisitCXXExpansionSelectExpr(CXXExpansionSelectExpr *E);
 
     // Helper for chaining together multiple imports. If an error is detected,
     // subsequent imports will return default constructed nodes, so that failure
@@ -9457,28 +9454,16 @@ ASTNodeImporter::VisitCXXParenListInitExpr(CXXParenListInitExpr *E) {
                                       ToInitLoc, ToBeginLoc, ToEndLoc);
 }
 
-ExpectedStmt ASTNodeImporter::VisitCXXExpansionInitListSelectExpr(
-    CXXExpansionInitListSelectExpr *E) {
+ExpectedStmt ASTNodeImporter::VisitCXXExpansionSelectExpr(
+    CXXExpansionSelectExpr *E) {
   Error Err = Error::success();
   auto ToRange = importChecked(Err, E->getRangeExpr());
   auto ToIndex = importChecked(Err, E->getIndexExpr());
   if (Err)
     return std::move(Err);
 
   return new (Importer.getToContext())
-      CXXExpansionInitListSelectExpr(Importer.getToContext(), ToRange, ToIndex);
-}
-
-ExpectedStmt ASTNodeImporter::VisitCXXDestructuringExpansionSelectExpr(
-    CXXDestructuringExpansionSelectExpr *E) {
-  Error Err = Error::success();
-  auto ToDecompositionDecl = importChecked(Err, E->getDecompositionDecl());
-  auto ToIndex = importChecked(Err, E->getIndexExpr());
-  if (Err)
-    return std::move(Err);
-
-  return new (Importer.getToContext()) CXXDestructuringExpansionSelectExpr(
-      Importer.getToContext(), ToDecompositionDecl, ToIndex);
+      CXXExpansionSelectExpr(Importer.getToContext(), ToRange, ToIndex);
 }
 
 Error ASTNodeImporter::ImportOverriddenMethods(CXXMethodDecl *ToMethod,

clang/lib/AST/Expr.cpp

@@ -3688,8 +3688,7 @@ bool Expr::HasSideEffects(const ASTContext &Ctx,
   case FunctionParmPackExprClass:
   case RecoveryExprClass:
   case CXXFoldExprClass:
-  case CXXExpansionInitListSelectExprClass:
-  case CXXDestructuringExpansionSelectExprClass:
+  case CXXExpansionSelectExprClass:
     // Make a conservative assumption for dependent nodes.
     return IncludePossibleEffects;
 

clang/lib/AST/ExprCXX.cpp

@@ -2021,26 +2021,14 @@ CXXFoldExpr::CXXFoldExpr(QualType T, UnresolvedLookupExpr *Callee,
   setDependence(computeDependence(this));
 }
 
-CXXExpansionInitListSelectExpr::CXXExpansionInitListSelectExpr(EmptyShell Empty)
-    : Expr(CXXExpansionInitListSelectExprClass, Empty) {}
+CXXExpansionSelectExpr::CXXExpansionSelectExpr(EmptyShell Empty)
+    : Expr(CXXExpansionSelectExprClass, Empty) {}
 
-CXXExpansionInitListSelectExpr::CXXExpansionInitListSelectExpr(
+CXXExpansionSelectExpr::CXXExpansionSelectExpr(
     const ASTContext &C, InitListExpr *Range, Expr *Idx)
-    : Expr(CXXExpansionInitListSelectExprClass, C.DependentTy, VK_PRValue,
+    : Expr(CXXExpansionSelectExprClass, C.DependentTy, VK_PRValue,
            OK_Ordinary) {
   setDependence(ExprDependence::TypeValueInstantiation);
   SubExprs[RANGE] = Range;
   SubExprs[INDEX] = Idx;
 }
-
-CXXDestructuringExpansionSelectExpr::CXXDestructuringExpansionSelectExpr(
-    EmptyShell Empty)
-    : Expr(CXXDestructuringExpansionSelectExprClass, Empty) {}
-
-CXXDestructuringExpansionSelectExpr::CXXDestructuringExpansionSelectExpr(
-    const ASTContext &C, DecompositionDecl *Decomposition, Expr *Index)
-    : Expr(CXXDestructuringExpansionSelectExprClass, C.DependentTy, VK_PRValue,
-           OK_Ordinary),
-      Decomposition(Decomposition), Index(Index) {
-  setDependence(ExprDependence::TypeValueInstantiation);
-}