Eliminate CXXExpansionInitListExpr

Sirraide · Sirraide · commit 8a4a548b2ec5 · 2025-12-03T18:17:15.000+01:00
diff --git a/clang/include/clang/AST/ComputeDependence.h b/clang/include/clang/AST/ComputeDependence.h
@@ -94,7 +94,6 @@ class DesignatedInitExpr;
 class ParenListExpr;
 class PseudoObjectExpr;
 class AtomicExpr;
-class CXXExpansionInitListExpr;
 class ArraySectionExpr;
 class OMPArrayShapingExpr;
 class OMPIteratorExpr;
@@ -192,8 +191,6 @@ ExprDependence computeDependence(ParenListExpr *E);
 ExprDependence computeDependence(PseudoObjectExpr *E);
 ExprDependence computeDependence(AtomicExpr *E);
 
-ExprDependence computeDependence(CXXExpansionInitListExpr *E);
-
 ExprDependence computeDependence(ArraySectionExpr *E);
 ExprDependence computeDependence(OMPArrayShapingExpr *E);
 ExprDependence computeDependence(OMPIteratorExpr *E);
diff --git a/clang/include/clang/AST/ExprCXX.h b/clang/include/clang/AST/ExprCXX.h
@@ -5499,79 +5499,6 @@ class BuiltinBitCastExpr final
   }
 };
 
-/// Represents an expansion-init-list of an enumerating expansion statement.
-///
-/// For example, in
-/// \verbatim
-///   template for (auto x : { 1, 2, 3 }) {
-///     // ...
-///   }
-/// \endverbatim
-///
-/// the '{ 1, 2, 3 }' part is parsed and stored as a 'CXXExpansionInitListExpr';
-/// syntactically, this *looks* very similar to an initializer list, but it
-/// isn't actually an expression: '{ 1, 2, 3 }' as a whole is never evaluated
-/// or emitted, only the individual expressions '1', '2', and '3' are. We still
-/// represent it as an expression in the AST for simplicity.
-///
-/// \see CXXEnumeratingExpansionStmtPattern
-class CXXExpansionInitListExpr final
-    : public Expr,
-      llvm::TrailingObjects<CXXExpansionInitListExpr, Expr *> {
-  friend class ASTStmtReader;
-  friend TrailingObjects;
-
-  const unsigned NumExprs;
-  SourceLocation LBraceLoc;
-  SourceLocation RBraceLoc;
-
-  CXXExpansionInitListExpr(EmptyShell ES, unsigned NumExprs);
-  CXXExpansionInitListExpr(ArrayRef<Expr *> Exprs, SourceLocation LBraceLoc,
-                           SourceLocation RBraceLoc);
-
-public:
-  static CXXExpansionInitListExpr *Create(const ASTContext &C,
-                                          ArrayRef<Expr *> Exprs,
-                                          SourceLocation LBraceLoc,
-                                          SourceLocation RBraceLoc);
-
-  static CXXExpansionInitListExpr *
-  CreateEmpty(const ASTContext &C, EmptyShell Empty, unsigned NumExprs);
-
-  ArrayRef<Expr *> getExprs() const { return getTrailingObjects(NumExprs); }
-  MutableArrayRef<Expr *> getExprs() { return getTrailingObjects(NumExprs); }
-  unsigned getNumExprs() const { return NumExprs; }
-
-  bool containsPackExpansion() const;
-
-  SourceLocation getBeginLoc() const { return getLBraceLoc(); }
-  SourceLocation getEndLoc() const { return getRBraceLoc(); }
-
-  SourceLocation getLBraceLoc() const { return LBraceLoc; }
-  SourceLocation getRBraceLoc() const { return RBraceLoc; }
-
-  child_range children() {
-    const_child_range CCR =
-        const_cast<const CXXExpansionInitListExpr *>(this)->children();
-    return child_range(cast_away_const(CCR.begin()),
-                       cast_away_const(CCR.end()));
-  }
-
-  const_child_range children() const {
-    Stmt **Stmts = getTrailingStmts();
-    return const_child_range(Stmts, Stmts + NumExprs);
-  }
-
-  static bool classof(const Stmt *T) {
-    return T->getStmtClass() == CXXExpansionInitListExprClass;
-  }
-
-private:
-  Stmt **getTrailingStmts() const {
-    return reinterpret_cast<Stmt **>(const_cast<Expr **>(getTrailingObjects()));
-  }
-};
-
 /// Helper that selects an expression from an expansion init list depending
 /// on the current expansion index.
 ///
@@ -5585,17 +5512,17 @@ class CXXExpansionInitListSelectExpr : public Expr {
 public:
   CXXExpansionInitListSelectExpr(EmptyShell Empty);
   CXXExpansionInitListSelectExpr(const ASTContext &C,
-                                 CXXExpansionInitListExpr *Range, Expr *Idx);
+                                 InitListExpr *Range, Expr *Idx);
 
-  CXXExpansionInitListExpr *getRangeExpr() {
-    return cast<CXXExpansionInitListExpr>(SubExprs[RANGE]);
+  InitListExpr *getRangeExpr() {
+    return cast<InitListExpr>(SubExprs[RANGE]);
   }
 
-  const CXXExpansionInitListExpr *getRangeExpr() const {
-    return cast<CXXExpansionInitListExpr>(SubExprs[RANGE]);
+  const InitListExpr *getRangeExpr() const {
+    return cast<InitListExpr>(SubExprs[RANGE]);
   }
 
-  void setRangeExpr(CXXExpansionInitListExpr *E) { SubExprs[RANGE] = E; }
+  void setRangeExpr(InitListExpr *E) { SubExprs[RANGE] = E; }
 
   Expr *getIndexExpr() { return SubExprs[INDEX]; }
   const Expr *getIndexExpr() const { return SubExprs[INDEX]; }
diff --git a/clang/include/clang/AST/RecursiveASTVisitor.h b/clang/include/clang/AST/RecursiveASTVisitor.h
@@ -3130,7 +3130,6 @@ DEF_TRAVERSE_STMT(CXXIteratingExpansionStmtPattern, {})
 DEF_TRAVERSE_STMT(CXXDestructuringExpansionStmtPattern, {})
 DEF_TRAVERSE_STMT(CXXDependentExpansionStmtPattern, {})
 DEF_TRAVERSE_STMT(CXXExpansionStmtInstantiation, {})
-DEF_TRAVERSE_STMT(CXXExpansionInitListExpr, {})
 DEF_TRAVERSE_STMT(CXXExpansionInitListSelectExpr, {})
 DEF_TRAVERSE_STMT(CXXDestructuringExpansionSelectExpr, {})
 
diff --git a/clang/include/clang/AST/StmtCXX.h b/clang/include/clang/AST/StmtCXX.h
@@ -586,8 +586,6 @@ class CXXExpansionStmtPattern : public Stmt {
     return getBody() ? getBody()->getEndLoc() : RParenLoc;
   }
 
-  bool hasDependentSize() const;
-
   CXXExpansionStmtDecl *getDecl() { return ParentDecl; }
   const CXXExpansionStmtDecl *getDecl() const { return ParentDecl; }
 
@@ -632,7 +630,7 @@ class CXXExpansionStmtPattern : public Stmt {
 /// an initializer list, but it isn't actually an expression in and of itself
 /// (in that it is never evaluated or emitted) and instead is just treated as
 /// a group of expressions. The expansion initializer of this is always a
-/// 'CXXExpansionInitListExpr'.
+/// syntactic-form 'InitListExpr'.
 ///
 /// Example:
 /// \verbatim
@@ -644,7 +642,7 @@ class CXXExpansionStmtPattern : public Stmt {
 /// Note that the expression-list may also contain pack expansions, e.g.
 /// '{ 1, xs... }', in which case the expansion size is dependent.
 ///
-/// Here, the '{ 1, 2, 3 }' is parsed as a 'CXXExpansionInitListExpr'. This node
+/// 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
diff --git a/clang/include/clang/AST/TextNodeDumper.h b/clang/include/clang/AST/TextNodeDumper.h
@@ -314,7 +314,6 @@ class TextNodeDumper
   VisitCXXDependentScopeMemberExpr(const CXXDependentScopeMemberExpr *Node);
   void VisitCXXDestructuringExpansionSelectExpr(
       const CXXDestructuringExpansionSelectExpr *Node);
-  void VisitCXXExpansionInitListExpr(const CXXExpansionInitListExpr *Node);
   void VisitObjCAtCatchStmt(const ObjCAtCatchStmt *Node);
   void VisitObjCEncodeExpr(const ObjCEncodeExpr *Node);
   void VisitObjCMessageExpr(const ObjCMessageExpr *Node);
diff --git a/clang/include/clang/Basic/StmtNodes.td b/clang/include/clang/Basic/StmtNodes.td
@@ -187,7 +187,6 @@ def ConceptSpecializationExpr : StmtNode<Expr>;
 def RequiresExpr : StmtNode<Expr>;
 
 // C++26 Expansion statement support expressions
-def CXXExpansionInitListExpr : StmtNode<Expr>;
 def CXXExpansionInitListSelectExpr : StmtNode<Expr>;
 def CXXDestructuringExpansionSelectExpr : StmtNode<Expr>;
 
diff --git a/clang/include/clang/Serialization/ASTBitCodes.h b/clang/include/clang/Serialization/ASTBitCodes.h
@@ -1942,7 +1942,6 @@ enum StmtCode {
   EXPR_CXX_FOLD,                           // CXXFoldExpr
   EXPR_CONCEPT_SPECIALIZATION,             // ConceptSpecializationExpr
   EXPR_REQUIRES,                           // RequiresExpr
-  EXPR_CXX_EXPANSION_INIT_LIST,            // CXXExpansionInitListExpr
   EXPR_CXX_EXPANSION_INIT_LIST_SELECT,     // CXXExpansionInitListSelectExpr
   EXPR_CXX_DESTRUCTURING_EXPANSION_SELECT, // CXXDestructuringExpansionSelectExpr
 
diff --git a/clang/lib/AST/ASTImporter.cpp b/clang/lib/AST/ASTImporter.cpp
@@ -711,7 +711,6 @@ namespace clang {
     VisitSubstNonTypeTemplateParmPackExpr(SubstNonTypeTemplateParmPackExpr *E);
     ExpectedStmt VisitPseudoObjectExpr(PseudoObjectExpr *E);
     ExpectedStmt VisitCXXParenListInitExpr(CXXParenListInitExpr *E);
-    ExpectedStmt VisitCXXExpansionInitListExpr(CXXExpansionInitListExpr *E);
     ExpectedStmt
     VisitCXXExpansionInitListSelectExpr(CXXExpansionInitListSelectExpr *E);
     ExpectedStmt VisitCXXDestructuringExpansionSelectExpr(
@@ -9480,22 +9479,6 @@ ASTNodeImporter::VisitCXXParenListInitExpr(CXXParenListInitExpr *E) {
                                       ToInitLoc, ToBeginLoc, ToEndLoc);
 }
 
-ExpectedStmt
-ASTNodeImporter::VisitCXXExpansionInitListExpr(CXXExpansionInitListExpr *E) {
-  Error Err = Error::success();
-  SmallVector<Expr *> ToExprs;
-  auto ToLBraceLoc = importChecked(Err, E->getLBraceLoc());
-  auto ToRBraceLoc = importChecked(Err, E->getRBraceLoc());
-  for (Expr *FromInst : E->getExprs())
-    ToExprs.push_back(importChecked(Err, FromInst));
-
-  if (Err)
-    return std::move(Err);
-
-  return CXXExpansionInitListExpr::Create(Importer.getToContext(), ToExprs,
-                                          ToLBraceLoc, ToRBraceLoc);
-}
-
 ExpectedStmt ASTNodeImporter::VisitCXXExpansionInitListSelectExpr(
     CXXExpansionInitListSelectExpr *E) {
   Error Err = Error::success();
diff --git a/clang/lib/AST/ComputeDependence.cpp b/clang/lib/AST/ComputeDependence.cpp
@@ -959,10 +959,3 @@ ExprDependence clang::computeDependence(OpenACCAsteriskSizeExpr *E) {
   // way.
   return ExprDependence::None;
 }
-
-ExprDependence clang::computeDependence(CXXExpansionInitListExpr *ILE) {
-  auto D = ExprDependence::None;
-  for (Expr *E : ILE->getExprs())
-    D |= E->getDependence();
-  return D;
-}
diff --git a/clang/lib/AST/Expr.cpp b/clang/lib/AST/Expr.cpp
@@ -3689,7 +3689,6 @@ bool Expr::HasSideEffects(const ASTContext &Ctx,
   case RecoveryExprClass:
   case CXXFoldExprClass:
   case CXXExpansionInitListSelectExprClass:
-  case CXXExpansionInitListExprClass:
   case CXXDestructuringExpansionSelectExprClass:
     // Make a conservative assumption for dependent nodes.
     return IncludePossibleEffects;
diff --git a/clang/lib/AST/ExprCXX.cpp b/clang/lib/AST/ExprCXX.cpp
@@ -2021,52 +2021,18 @@ CXXFoldExpr::CXXFoldExpr(QualType T, UnresolvedLookupExpr *Callee,
   setDependence(computeDependence(this));
 }
 
-CXXExpansionInitListExpr::CXXExpansionInitListExpr(EmptyShell ES,
-                                                   unsigned NumExprs)
-    : Expr(CXXExpansionInitListExprClass, ES), NumExprs(NumExprs) {}
-
-CXXExpansionInitListExpr::CXXExpansionInitListExpr(ArrayRef<Expr *> Exprs,
-                                                   SourceLocation LBraceLoc,
-                                                   SourceLocation RBraceLoc)
-    : Expr(CXXExpansionInitListExprClass, QualType(), VK_PRValue, OK_Ordinary),
-      NumExprs(static_cast<unsigned>(Exprs.size())), LBraceLoc(LBraceLoc),
-      RBraceLoc(RBraceLoc) {
-  llvm::uninitialized_copy(Exprs, getTrailingObjects());
-  setDependence(computeDependence(this));
-}
-
-CXXExpansionInitListExpr *
-CXXExpansionInitListExpr::Create(const ASTContext &C, ArrayRef<Expr *> Exprs,
-                                 SourceLocation LBraceLoc,
-                                 SourceLocation RBraceLoc) {
-  void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(Exprs.size()));
-  return new (Mem) CXXExpansionInitListExpr(Exprs, LBraceLoc, RBraceLoc);
-}
-
-CXXExpansionInitListExpr *
-CXXExpansionInitListExpr::CreateEmpty(const ASTContext &C, EmptyShell Empty,
-                                      unsigned NumExprs) {
-  void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(NumExprs));
-  return new (Mem) CXXExpansionInitListExpr(Empty, NumExprs);
-}
-
 CXXExpansionInitListSelectExpr::CXXExpansionInitListSelectExpr(EmptyShell Empty)
     : Expr(CXXExpansionInitListSelectExprClass, Empty) {}
 
 CXXExpansionInitListSelectExpr::CXXExpansionInitListSelectExpr(
-    const ASTContext &C, CXXExpansionInitListExpr *Range, Expr *Idx)
+    const ASTContext &C, InitListExpr *Range, Expr *Idx)
     : Expr(CXXExpansionInitListSelectExprClass, C.DependentTy, VK_PRValue,
            OK_Ordinary) {
   setDependence(ExprDependence::TypeValueInstantiation);
   SubExprs[RANGE] = Range;
   SubExprs[INDEX] = Idx;
 }
 
-bool CXXExpansionInitListExpr::containsPackExpansion() const {
-  return llvm::any_of(getExprs(),
-                      [](const Expr *E) { return isa<PackExpansionExpr>(E); });
-}
-
 CXXDestructuringExpansionSelectExpr::CXXDestructuringExpansionSelectExpr(
     EmptyShell Empty)
     : Expr(CXXDestructuringExpansionSelectExprClass, Empty) {}
diff --git a/clang/lib/AST/ExprClassification.cpp b/clang/lib/AST/ExprClassification.cpp
@@ -216,7 +216,6 @@ static Cl::Kinds ClassifyInternal(ASTContext &Ctx, const Expr *E) {
   case Expr::SourceLocExprClass:
   case Expr::ConceptSpecializationExprClass:
   case Expr::RequiresExprClass:
-  case Expr::CXXExpansionInitListExprClass:
   case Expr::CXXExpansionInitListSelectExprClass:
   case Expr::CXXDestructuringExpansionSelectExprClass:
     return Cl::CL_PRValue;
diff --git a/clang/lib/AST/ExprConstant.cpp b/clang/lib/AST/ExprConstant.cpp
@@ -20276,7 +20276,6 @@ static ICEDiag CheckICE(const Expr* E, const ASTContext &Ctx) {
   case Expr::SYCLUniqueStableNameExprClass:
   case Expr::CXXParenListInitExprClass:
   case Expr::HLSLOutArgExprClass:
-  case Expr::CXXExpansionInitListExprClass:
   case Expr::CXXExpansionInitListSelectExprClass:
   case Expr::CXXDestructuringExpansionSelectExprClass:
     return ICEDiag(IK_NotICE, E->getBeginLoc());
diff --git a/clang/lib/AST/ItaniumMangle.cpp b/clang/lib/AST/ItaniumMangle.cpp
@@ -4946,7 +4946,6 @@ void CXXNameMangler::mangleExpression(const Expr *E, unsigned Arity,
   case Expr::CXXParenListInitExprClass:
   case Expr::PackIndexingExprClass:
   case Expr::CXXExpansionInitListSelectExprClass:
-  case Expr::CXXExpansionInitListExprClass:
   case Expr::CXXDestructuringExpansionSelectExprClass:
     llvm_unreachable("unexpected statement kind");
 
diff --git a/clang/lib/AST/StmtCXX.cpp b/clang/lib/AST/StmtCXX.cpp
@@ -162,28 +162,6 @@ VarDecl *CXXExpansionStmtPattern::getExpansionVariable() {
   return cast<VarDecl>(LV);
 }
 
-bool CXXExpansionStmtPattern::hasDependentSize() const {
-  if (isa<CXXEnumeratingExpansionStmtPattern>(this))
-    return cast<CXXExpansionInitListSelectExpr>(
-               getExpansionVariable()->getInit())
-        ->getRangeExpr()
-        ->containsPackExpansion();
-
-  if (auto *Iterating = dyn_cast<CXXIteratingExpansionStmtPattern>(this)) {
-    const Expr *Begin = Iterating->getBeginVar()->getInit();
-    const Expr *End = Iterating->getEndVar()->getInit();
-    return Begin->isInstantiationDependent() || End->isInstantiationDependent();
-  }
-
-  if (isa<CXXDestructuringExpansionStmtPattern>(this))
-    return false;
-
-  if (isa<CXXDependentExpansionStmtPattern>(this))
-    return true;
-
-  llvm_unreachable("Invalid expansion statement class");
-}
-
 CXXIteratingExpansionStmtPattern::CXXIteratingExpansionStmtPattern(
     EmptyShell Empty)
     : CXXExpansionStmtPattern(CXXIteratingExpansionStmtPatternClass, Empty) {}
diff --git a/clang/lib/AST/StmtPrinter.cpp b/clang/lib/AST/StmtPrinter.cpp
@@ -490,13 +490,6 @@ void StmtPrinter::VisitCXXExpansionStmtInstantiation(
   llvm_unreachable("should never be printed");
 }
 
-void StmtPrinter::VisitCXXExpansionInitListExpr(
-    CXXExpansionInitListExpr *Node) {
-  OS << "{ ";
-  llvm::interleaveComma(Node->getExprs(), OS, [&](Expr *E) { PrintExpr(E); });
-  OS << " }";
-}
-
 void StmtPrinter::VisitCXXExpansionInitListSelectExpr(
     CXXExpansionInitListSelectExpr *Node) {
   PrintExpr(Node->getRangeExpr());
diff --git a/clang/lib/AST/StmtProfile.cpp b/clang/lib/AST/StmtProfile.cpp
@@ -2431,11 +2431,6 @@ void StmtProfiler::VisitSourceLocExpr(const SourceLocExpr *E) {
 
 void StmtProfiler::VisitEmbedExpr(const EmbedExpr *E) { VisitExpr(E); }
 
-void StmtProfiler::VisitCXXExpansionInitListExpr(
-    const CXXExpansionInitListExpr *E) {
-  VisitExpr(E);
-}
-
 void StmtProfiler::VisitCXXExpansionInitListSelectExpr(
     const CXXExpansionInitListSelectExpr *E) {
   VisitExpr(E);
diff --git a/clang/lib/AST/TextNodeDumper.cpp b/clang/lib/AST/TextNodeDumper.cpp
@@ -1836,12 +1836,6 @@ void TextNodeDumper::VisitCXXDependentScopeMemberExpr(
   OS << " " << (Node->isArrow() ? "->" : ".") << Node->getMember();
 }
 
-void TextNodeDumper::VisitCXXExpansionInitListExpr(
-    const CXXExpansionInitListExpr *Node) {
-  if (Node->containsPackExpansion())
-    OS << " contains_pack";
-}
-
 void TextNodeDumper::VisitCXXDestructuringExpansionSelectExpr(
     const CXXDestructuringExpansionSelectExpr *Node) {
   dumpDeclRef(Node->getDecompositionDecl());
diff --git a/clang/lib/Sema/SemaExceptionSpec.cpp b/clang/lib/Sema/SemaExceptionSpec.cpp
@@ -1289,7 +1289,6 @@ CanThrowResult Sema::canThrow(const Stmt *S) {
   case Expr::VAArgExprClass:
   case Expr::CXXParenListInitExprClass:
   case Expr::CXXExpansionInitListSelectExprClass:
-  case Expr::CXXExpansionInitListExprClass:
   case Expr::CXXDestructuringExpansionSelectExprClass:
     return canSubStmtsThrow(*this, S);
 
diff --git a/clang/lib/Serialization/ASTReaderStmt.cpp b/clang/lib/Serialization/ASTReaderStmt.cpp
diff --git a/clang/lib/Serialization/ASTWriterStmt.cpp b/clang/lib/Serialization/ASTWriterStmt.cpp
diff --git a/clang/lib/StaticAnalyzer/Core/ExprEngine.cpp b/clang/lib/StaticAnalyzer/Core/ExprEngine.cpp
diff --git a/clang/tools/libclang/CXCursor.cpp b/clang/tools/libclang/CXCursor.cpp
