https://github.com/hokein updated
https://github.com/llvm/llvm-project/pull/142585
>From 1a233dbb9d58cf488551caf29d441f2c6a5b68b5 Mon Sep 17 00:00:00 2001
From: Haojian Wu <hokein...@gmail.com>
Date: Tue, 3 Jun 2025 08:42:37 +0200
Subject: [PATCH 1/2] [clang][modules] Remove the workaround for the lambda
issue.
This code was originally introduced to fix issue #110401. The issue was the
same lambda problem, which has since been properly fixed by PR #109167 and its
follow-ups.
---
clang/lib/AST/DeclCXX.cpp | 31 +------------------------------
1 file changed, 1 insertion(+), 30 deletions(-)
diff --git a/clang/lib/AST/DeclCXX.cpp b/clang/lib/AST/DeclCXX.cpp
index f1f31d8be78c9..42b11e60d4584 100644
--- a/clang/lib/AST/DeclCXX.cpp
+++ b/clang/lib/AST/DeclCXX.cpp
@@ -1702,36 +1702,7 @@ static NamedDecl* getLambdaCallOperatorHelper(const
CXXRecordDecl &RD) {
assert(allLookupResultsAreTheSame(Calls) &&
"More than one lambda call operator!");
-
- // FIXME: If we have multiple call operators, we might be in a situation
- // where we merged this lambda with one from another module; in that
- // case, return our method (instead of that of the other lambda).
- //
- // This avoids situations where, given two modules A and B, if we
- // try to instantiate A's call operator in a function in B, anything
- // in the call operator that relies on local decls in the surrounding
- // function will crash because it tries to find A's decls, but we only
- // instantiated B's:
- //
- // template <typename>
- // void f() {
- // using T = int; // We only instantiate B's version of this.
- // auto L = [](T) { }; // But A's call operator would want A's here.
- // }
- //
- // Walk the call operator’s redecl chain to find the one that belongs
- // to this module.
- //
- // TODO: We need to fix this properly (see
- // https://github.com/llvm/llvm-project/issues/90154).
- Module *M = RD.getOwningModule();
- for (Decl *D : Calls.front()->redecls()) {
- auto *MD = cast<NamedDecl>(D);
- if (MD->getOwningModule() == M)
- return MD;
- }
-
- llvm_unreachable("Couldn't find our call operator!");
+ return Calls.front();
}
FunctionTemplateDecl* CXXRecordDecl::getDependentLambdaCallOperator() const {
>From ab9ea84bbae33719761c43de0a4231bb030006df Mon Sep 17 00:00:00 2001
From: Haojian Wu <hokein...@gmail.com>
Date: Sat, 10 May 2025 07:44:51 +0200
Subject: [PATCH 2/2] [clang][AST] Reduce AST node size
---
clang/include/clang/AST/Expr.h | 31 +++++----
clang/include/clang/AST/ExprCXX.h | 74 +++++++++++----------
clang/include/clang/AST/Stmt.h | 78 +++++++++++++++++++++++
clang/include/clang/AST/StmtCXX.h | 2 +-
clang/lib/AST/Expr.cpp | 7 +-
clang/lib/AST/ExprCXX.cpp | 3 +-
clang/lib/Serialization/ASTReaderStmt.cpp | 14 ++--
clang/lib/Serialization/ASTWriterStmt.cpp | 6 +-
8 files changed, 149 insertions(+), 66 deletions(-)
diff --git a/clang/include/clang/AST/Expr.h b/clang/include/clang/AST/Expr.h
index 87bb9df9cef8f..b0dbfefcfe0dd 100644
--- a/clang/include/clang/AST/Expr.h
+++ b/clang/include/clang/AST/Expr.h
@@ -3127,7 +3127,9 @@ class CallExpr : public Expr {
/// Bluntly set a new number of arguments without doing any checks
whatsoever.
/// Only used during construction of a CallExpr in a few places in Sema.
/// FIXME: Find a way to remove it.
- void setNumArgsUnsafe(unsigned NewNumArgs) { NumArgs = NewNumArgs; }
+ void setNumArgsUnsafe(unsigned NewNumArgs) {
+ NumArgs = NewNumArgs;
+ }
typedef ExprIterator arg_iterator;
typedef ConstExprIterator const_arg_iterator;
@@ -4579,7 +4581,6 @@ class ShuffleVectorExpr : public Expr {
// indices. The number of values in this list is always
// 2+the number of indices in the vector type.
Stmt **SubExprs;
- unsigned NumExprs;
public:
ShuffleVectorExpr(const ASTContext &C, ArrayRef<Expr*> args, QualType Type,
@@ -4605,25 +4606,27 @@ class ShuffleVectorExpr : public Expr {
/// getNumSubExprs - Return the size of the SubExprs array. This includes
the
/// constant expression, the actual arguments passed in, and the function
/// pointers.
- unsigned getNumSubExprs() const { return NumExprs; }
+ unsigned getNumSubExprs() const { return ShuffleVectorExprBits.NumExprs; }
/// Retrieve the array of expressions.
Expr **getSubExprs() { return reinterpret_cast<Expr **>(SubExprs); }
/// getExpr - Return the Expr at the specified index.
Expr *getExpr(unsigned Index) {
- assert((Index < NumExprs) && "Arg access out of range!");
+ assert((Index < ShuffleVectorExprBits.NumExprs) &&
+ "Arg access out of range!");
return cast<Expr>(SubExprs[Index]);
}
const Expr *getExpr(unsigned Index) const {
- assert((Index < NumExprs) && "Arg access out of range!");
+ assert((Index < ShuffleVectorExprBits.NumExprs) &&
+ "Arg access out of range!");
return cast<Expr>(SubExprs[Index]);
}
void setExprs(const ASTContext &C, ArrayRef<Expr *> Exprs);
llvm::APSInt getShuffleMaskIdx(unsigned N) const {
- assert((N < NumExprs - 2) && "Shuffle idx out of range!");
+ assert((N < ShuffleVectorExprBits.NumExprs - 2) && "Shuffle idx out of
range!");
assert(isa<ConstantExpr>(getExpr(N + 2)) &&
"Index expression must be a ConstantExpr");
return cast<ConstantExpr>(getExpr(N + 2))->getAPValueResult().getInt();
@@ -4631,10 +4634,12 @@ class ShuffleVectorExpr : public Expr {
// Iterators
child_range children() {
- return child_range(&SubExprs[0], &SubExprs[0]+NumExprs);
+ return child_range(&SubExprs[0],
+ &SubExprs[0] + ShuffleVectorExprBits.NumExprs);
}
const_child_range children() const {
- return const_child_range(&SubExprs[0], &SubExprs[0] + NumExprs);
+ return const_child_range(&SubExprs[0],
+ &SubExprs[0] + ShuffleVectorExprBits.NumExprs);
}
};
@@ -4776,13 +4781,13 @@ class ChooseExpr : public Expr {
enum { COND, LHS, RHS, END_EXPR };
Stmt* SubExprs[END_EXPR]; // Left/Middle/Right hand sides.
SourceLocation BuiltinLoc, RParenLoc;
- bool CondIsTrue;
+
public:
ChooseExpr(SourceLocation BLoc, Expr *cond, Expr *lhs, Expr *rhs, QualType t,
ExprValueKind VK, ExprObjectKind OK, SourceLocation RP,
bool condIsTrue)
- : Expr(ChooseExprClass, t, VK, OK), BuiltinLoc(BLoc), RParenLoc(RP),
- CondIsTrue(condIsTrue) {
+ : Expr(ChooseExprClass, t, VK, OK), BuiltinLoc(BLoc), RParenLoc(RP) {
+ ChooseExprBits.CondIsTrue = condIsTrue;
SubExprs[COND] = cond;
SubExprs[LHS] = lhs;
SubExprs[RHS] = rhs;
@@ -4798,9 +4803,9 @@ class ChooseExpr : public Expr {
bool isConditionTrue() const {
assert(!isConditionDependent() &&
"Dependent condition isn't true or false");
- return CondIsTrue;
+ return ChooseExprBits.CondIsTrue;
}
- void setIsConditionTrue(bool isTrue) { CondIsTrue = isTrue; }
+ void setIsConditionTrue(bool isTrue) { ChooseExprBits.CondIsTrue = isTrue; }
bool isConditionDependent() const {
return getCond()->isTypeDependent() || getCond()->isValueDependent();
diff --git a/clang/include/clang/AST/ExprCXX.h
b/clang/include/clang/AST/ExprCXX.h
index 6ed049c915481..4c9636f990db0 100644
--- a/clang/include/clang/AST/ExprCXX.h
+++ b/clang/include/clang/AST/ExprCXX.h
@@ -2974,10 +2974,6 @@ class TypeTraitExpr final
/// __array_extent(int[10][20], 1) == 20
/// \endcode
class ArrayTypeTraitExpr : public Expr {
- /// The trait. An ArrayTypeTrait enum in MSVC compat unsigned.
- LLVM_PREFERRED_TYPE(ArrayTypeTrait)
- unsigned ATT : 2;
-
/// The value of the type trait. Unspecified if dependent.
uint64_t Value = 0;
@@ -2999,21 +2995,27 @@ class ArrayTypeTraitExpr : public Expr {
ArrayTypeTraitExpr(SourceLocation loc, ArrayTypeTrait att,
TypeSourceInfo *queried, uint64_t value, Expr *dimension,
SourceLocation rparen, QualType ty)
- : Expr(ArrayTypeTraitExprClass, ty, VK_PRValue, OK_Ordinary), ATT(att),
+ : Expr(ArrayTypeTraitExprClass, ty, VK_PRValue, OK_Ordinary),
Value(value), Dimension(dimension), Loc(loc), RParen(rparen),
QueriedType(queried) {
assert(att <= ATT_Last && "invalid enum value!");
- assert(static_cast<unsigned>(att) == ATT && "ATT overflow!");
+ ArrayTypeTraitExprBits.ATT = att;
+ assert(static_cast<unsigned>(att) == ArrayTypeTraitExprBits.ATT &&
+ "ATT overflow!");
setDependence(computeDependence(this));
}
explicit ArrayTypeTraitExpr(EmptyShell Empty)
- : Expr(ArrayTypeTraitExprClass, Empty), ATT(0) {}
+ : Expr(ArrayTypeTraitExprClass, Empty) {
+ ArrayTypeTraitExprBits.ATT = 0;
+ }
SourceLocation getBeginLoc() const LLVM_READONLY { return Loc; }
SourceLocation getEndLoc() const LLVM_READONLY { return RParen; }
- ArrayTypeTrait getTrait() const { return static_cast<ArrayTypeTrait>(ATT); }
+ ArrayTypeTrait getTrait() const {
+ return static_cast<ArrayTypeTrait>(ArrayTypeTraitExprBits.ATT);
+ }
QualType getQueriedType() const { return QueriedType->getType(); }
@@ -3045,14 +3047,6 @@ class ArrayTypeTraitExpr : public Expr {
/// __is_lvalue_expr(1) == false
/// \endcode
class ExpressionTraitExpr : public Expr {
- /// The trait. A ExpressionTrait enum in MSVC compatible unsigned.
- LLVM_PREFERRED_TYPE(ExpressionTrait)
- unsigned ET : 31;
-
- /// The value of the type trait. Unspecified if dependent.
- LLVM_PREFERRED_TYPE(bool)
- unsigned Value : 1;
-
/// The location of the type trait keyword.
SourceLocation Loc;
@@ -3068,24 +3062,32 @@ class ExpressionTraitExpr : public Expr {
ExpressionTraitExpr(SourceLocation loc, ExpressionTrait et, Expr *queried,
bool value, SourceLocation rparen, QualType resultType)
: Expr(ExpressionTraitExprClass, resultType, VK_PRValue, OK_Ordinary),
- ET(et), Value(value), Loc(loc), RParen(rparen),
- QueriedExpression(queried) {
+ Loc(loc), RParen(rparen), QueriedExpression(queried) {
+ ExpressionTraitExprBits.ET = et;
+ ExpressionTraitExprBits.Value = value;
+
assert(et <= ET_Last && "invalid enum value!");
- assert(static_cast<unsigned>(et) == ET && "ET overflow!");
+ assert(static_cast<unsigned>(et) == ExpressionTraitExprBits.ET &&
+ "ET overflow!");
setDependence(computeDependence(this));
}
explicit ExpressionTraitExpr(EmptyShell Empty)
- : Expr(ExpressionTraitExprClass, Empty), ET(0), Value(false) {}
+ : Expr(ExpressionTraitExprClass, Empty) {
+ ExpressionTraitExprBits.ET = 0;
+ ExpressionTraitExprBits.Value = false;
+ }
SourceLocation getBeginLoc() const LLVM_READONLY { return Loc; }
SourceLocation getEndLoc() const LLVM_READONLY { return RParen; }
- ExpressionTrait getTrait() const { return static_cast<ExpressionTrait>(ET); }
+ ExpressionTrait getTrait() const {
+ return static_cast<ExpressionTrait>(ExpressionTraitExprBits.ET);
+ }
Expr *getQueriedExpression() const { return QueriedExpression; }
- bool getValue() const { return Value; }
+ bool getValue() const { return ExpressionTraitExprBits.Value; }
static bool classof(const Stmt *T) {
return T->getStmtClass() == ExpressionTraitExprClass;
@@ -4506,22 +4508,15 @@ class PackIndexingExpr final
// The pack being indexed, followed by the index
Stmt *SubExprs[2];
- // The size of the trailing expressions.
- unsigned TransformedExpressions : 31;
-
- LLVM_PREFERRED_TYPE(bool)
- unsigned FullySubstituted : 1;
-
PackIndexingExpr(QualType Type, SourceLocation EllipsisLoc,
SourceLocation RSquareLoc, Expr *PackIdExpr, Expr
*IndexExpr,
ArrayRef<Expr *> SubstitutedExprs = {},
bool FullySubstituted = false)
: Expr(PackIndexingExprClass, Type, VK_LValue, OK_Ordinary),
EllipsisLoc(EllipsisLoc), RSquareLoc(RSquareLoc),
- SubExprs{PackIdExpr, IndexExpr},
- TransformedExpressions(SubstitutedExprs.size()),
- FullySubstituted(FullySubstituted) {
-
+ SubExprs{PackIdExpr, IndexExpr} {
+ PackIndexingExprBits.TransformedExpressions = SubstitutedExprs.size();
+ PackIndexingExprBits.FullySubstituted = FullySubstituted;
auto *Exprs = getTrailingObjects<Expr *>();
llvm::uninitialized_copy(SubstitutedExprs, Exprs);
@@ -4534,7 +4529,7 @@ class PackIndexingExpr final
PackIndexingExpr(EmptyShell Empty) : Expr(PackIndexingExprClass, Empty) {}
unsigned numTrailingObjects(OverloadToken<Expr *>) const {
- return TransformedExpressions;
+ return PackIndexingExprBits.TransformedExpressions;
}
public:
@@ -4548,11 +4543,14 @@ class PackIndexingExpr final
unsigned NumTransformedExprs);
// The index expression and all elements of the pack have been substituted.
- bool isFullySubstituted() const { return FullySubstituted; }
+ bool isFullySubstituted() const {
+ return PackIndexingExprBits.FullySubstituted;
+ }
/// Determine if the expression was expanded to empty.
bool expandsToEmptyPack() const {
- return isFullySubstituted() && TransformedExpressions == 0;
+ return isFullySubstituted() &&
+ PackIndexingExprBits.TransformedExpressions == 0;
}
/// Determine the location of the 'sizeof' keyword.
@@ -4590,7 +4588,8 @@ class PackIndexingExpr final
/// Return the trailing expressions, regardless of the expansion.
ArrayRef<Expr *> getExpressions() const {
- return {getTrailingObjects<Expr *>(), TransformedExpressions};
+ return {getTrailingObjects<Expr *>(),
+ PackIndexingExprBits.TransformedExpressions};
}
static bool classof(const Stmt *T) {
@@ -4988,7 +4987,6 @@ class CXXFoldExpr : public Expr {
// than the number of expansions.
UnsignedOrNone NumExpansions = std::nullopt;
Stmt *SubExprs[SubExpr::Count];
- BinaryOperatorKind Opcode;
public:
CXXFoldExpr(QualType T, UnresolvedLookupExpr *Callee,
@@ -5021,7 +5019,7 @@ class CXXFoldExpr : public Expr {
SourceLocation getLParenLoc() const { return LParenLoc; }
SourceLocation getRParenLoc() const { return RParenLoc; }
SourceLocation getEllipsisLoc() const { return EllipsisLoc; }
- BinaryOperatorKind getOperator() const { return Opcode; }
+ BinaryOperatorKind getOperator() const { return CXXFoldExprBits.Opcode; }
UnsignedOrNone getNumExpansions() const { return NumExpansions; }
diff --git a/clang/include/clang/AST/Stmt.h b/clang/include/clang/AST/Stmt.h
index 3be25c735772a..a6f380b32c19f 100644
--- a/clang/include/clang/AST/Stmt.h
+++ b/clang/include/clang/AST/Stmt.h
@@ -19,6 +19,7 @@
#include "clang/AST/OperationKinds.h"
#include "clang/AST/StmtIterator.h"
#include "clang/Basic/CapturedStmt.h"
+#include "clang/Basic/ExpressionTraits.h"
#include "clang/Basic/IdentifierTable.h"
#include "clang/Basic/LLVM.h"
#include "clang/Basic/Lambda.h"
@@ -736,6 +737,15 @@ class alignas(void *) Stmt {
unsigned ProducedByFoldExpansion : 1;
};
+ class ShuffleVectorExprBitfields {
+ friend class ShuffleVectorExpr;
+
+ LLVM_PREFERRED_TYPE(ExprBitfields)
+ unsigned : NumExprBits;
+
+ unsigned NumExprs;
+ };
+
class StmtExprBitfields {
friend class ASTStmtReader;
friend class StmtExpr;
@@ -749,6 +759,17 @@ class alignas(void *) Stmt {
unsigned TemplateDepth;
};
+ class ChooseExprBitfields {
+ friend class ASTStmtReader;
+ friend class ChooseExpr;
+
+ LLVM_PREFERRED_TYPE(ExprBitfields)
+ unsigned : NumExprBits;
+
+ LLVM_PREFERRED_TYPE(bool)
+ bool CondIsTrue : 1;
+ };
+
//===--- C++ Expression bitfields classes ---===//
class CXXOperatorCallExprBitfields {
@@ -1184,6 +1205,57 @@ class alignas(void *) Stmt {
SourceLocation RequiresKWLoc;
};
+ class ArrayTypeTraitExprBitfields {
+ friend class ArrayTypeTraitExpr;
+ friend class ASTStmtReader;
+ LLVM_PREFERRED_TYPE(ExprBitfields)
+ unsigned : NumExprBits;
+
+ /// The trait. An ArrayTypeTrait enum in MSVC compat unsigned.
+ LLVM_PREFERRED_TYPE(ArrayTypeTrait)
+ unsigned ATT : 2;
+ };
+
+ class ExpressionTraitExprBitfields {
+ friend class ExpressionTraitExpr;
+ friend class ASTStmtReader;
+ LLVM_PREFERRED_TYPE(ExprBitfields)
+ unsigned : NumExprBits;
+
+ /// The trait. A ExpressionTrait enum in MSVC compatible unsigned.
+ LLVM_PREFERRED_TYPE(ExpressionTrait)
+ unsigned ET : 31;
+
+ /// The value of the type trait. Unspecified if dependent.
+ LLVM_PREFERRED_TYPE(bool)
+ unsigned Value : 1;
+ };
+
+ class CXXFoldExprBitfields {
+ friend class CXXFoldExpr;
+ friend class ASTStmtReader;
+ friend class ASTStmtWriter;
+
+ LLVM_PREFERRED_TYPE(ExprBitfields)
+ unsigned : NumExprBits;
+
+ BinaryOperatorKind Opcode;
+ };
+
+ class PackIndexingExprBitfields {
+ friend class PackIndexingExpr;
+ friend class ASTStmtWriter;
+ friend class ASTStmtReader;
+
+ LLVM_PREFERRED_TYPE(ExprBitfields)
+ unsigned : NumExprBits;
+ // The size of the trailing expressions.
+ unsigned TransformedExpressions : 31;
+
+ LLVM_PREFERRED_TYPE(bool)
+ unsigned FullySubstituted : 1;
+ };
+
//===--- C++ Coroutines bitfields classes ---===//
class CoawaitExprBitfields {
@@ -1279,9 +1351,11 @@ class alignas(void *) Stmt {
PseudoObjectExprBitfields PseudoObjectExprBits;
SourceLocExprBitfields SourceLocExprBits;
ParenExprBitfields ParenExprBits;
+ ShuffleVectorExprBitfields ShuffleVectorExprBits;
// GNU Extensions.
StmtExprBitfields StmtExprBits;
+ ChooseExprBitfields ChooseExprBits;
// C++ Expressions
CXXOperatorCallExprBitfields CXXOperatorCallExprBits;
@@ -1308,6 +1382,10 @@ class alignas(void *) Stmt {
SubstNonTypeTemplateParmExprBitfields SubstNonTypeTemplateParmExprBits;
LambdaExprBitfields LambdaExprBits;
RequiresExprBitfields RequiresExprBits;
+ ArrayTypeTraitExprBitfields ArrayTypeTraitExprBits;
+ ExpressionTraitExprBitfields ExpressionTraitExprBits;
+ CXXFoldExprBitfields CXXFoldExprBits;
+ PackIndexingExprBitfields PackIndexingExprBits;
// C++ Coroutines expressions
CoawaitExprBitfields CoawaitBits;
diff --git a/clang/include/clang/AST/StmtCXX.h
b/clang/include/clang/AST/StmtCXX.h
index 8b4ef24ed376a..a15a445fbea40 100644
--- a/clang/include/clang/AST/StmtCXX.h
+++ b/clang/include/clang/AST/StmtCXX.h
@@ -133,11 +133,11 @@ class CXXTryStmt final : public Stmt,
/// analysis of the constituent components. The original syntactic components
/// can be extracted using getLoopVariable and getRangeInit.
class CXXForRangeStmt : public Stmt {
- SourceLocation ForLoc;
enum { INIT, RANGE, BEGINSTMT, ENDSTMT, COND, INC, LOOPVAR, BODY, END };
// SubExprs[RANGE] is an expression or declstmt.
// SubExprs[COND] and SubExprs[INC] are expressions.
Stmt *SubExprs[END];
+ SourceLocation ForLoc;
SourceLocation CoawaitLoc;
SourceLocation ColonLoc;
SourceLocation RParenLoc;
diff --git a/clang/lib/AST/Expr.cpp b/clang/lib/AST/Expr.cpp
index 3993db84978a8..17d2cb4a30f30 100644
--- a/clang/lib/AST/Expr.cpp
+++ b/clang/lib/AST/Expr.cpp
@@ -4393,7 +4393,8 @@ ShuffleVectorExpr::ShuffleVectorExpr(const ASTContext &C,
ArrayRef<Expr *> args,
QualType Type, SourceLocation BLoc,
SourceLocation RP)
: Expr(ShuffleVectorExprClass, Type, VK_PRValue, OK_Ordinary),
- BuiltinLoc(BLoc), RParenLoc(RP), NumExprs(args.size()) {
+ BuiltinLoc(BLoc), RParenLoc(RP) {
+ ShuffleVectorExprBits.NumExprs = args.size();
SubExprs = new (C) Stmt*[args.size()];
for (unsigned i = 0; i != args.size(); i++)
SubExprs[i] = args[i];
@@ -4404,8 +4405,8 @@ ShuffleVectorExpr::ShuffleVectorExpr(const ASTContext &C,
ArrayRef<Expr *> args,
void ShuffleVectorExpr::setExprs(const ASTContext &C, ArrayRef<Expr *> Exprs) {
if (SubExprs) C.Deallocate(SubExprs);
- this->NumExprs = Exprs.size();
- SubExprs = new (C) Stmt*[NumExprs];
+ this->ShuffleVectorExprBits.NumExprs = Exprs.size();
+ SubExprs = new (C) Stmt *[ShuffleVectorExprBits.NumExprs];
memcpy(SubExprs, Exprs.data(), sizeof(Expr *) * Exprs.size());
}
diff --git a/clang/lib/AST/ExprCXX.cpp b/clang/lib/AST/ExprCXX.cpp
index 5c712e146e5a8..bd43ed5ab2f9a 100644
--- a/clang/lib/AST/ExprCXX.cpp
+++ b/clang/lib/AST/ExprCXX.cpp
@@ -2003,7 +2003,8 @@ CXXFoldExpr::CXXFoldExpr(QualType T, UnresolvedLookupExpr
*Callee,
UnsignedOrNone NumExpansions)
: Expr(CXXFoldExprClass, T, VK_PRValue, OK_Ordinary), LParenLoc(LParenLoc),
EllipsisLoc(EllipsisLoc), RParenLoc(RParenLoc),
- NumExpansions(NumExpansions), Opcode(Opcode) {
+ NumExpansions(NumExpansions) {
+ CXXFoldExprBits.Opcode = Opcode;
// We rely on asserted invariant to distinguish left and right folds.
assert(((LHS && LHS->containsUnexpandedParameterPack()) !=
(RHS && RHS->containsUnexpandedParameterPack())) &&
diff --git a/clang/lib/Serialization/ASTReaderStmt.cpp
b/clang/lib/Serialization/ASTReaderStmt.cpp
index f1bb33a19107e..01c838b955755 100644
--- a/clang/lib/Serialization/ASTReaderStmt.cpp
+++ b/clang/lib/Serialization/ASTReaderStmt.cpp
@@ -2156,7 +2156,7 @@ void ASTStmtReader::VisitTypeTraitExpr(TypeTraitExpr *E) {
void ASTStmtReader::VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E) {
VisitExpr(E);
- E->ATT = (ArrayTypeTrait)Record.readInt();
+ E->ArrayTypeTraitExprBits.ATT = (ArrayTypeTrait)Record.readInt();
E->Value = (unsigned int)Record.readInt();
SourceRange Range = readSourceRange();
E->Loc = Range.getBegin();
@@ -2167,8 +2167,8 @@ void
ASTStmtReader::VisitArrayTypeTraitExpr(ArrayTypeTraitExpr *E) {
void ASTStmtReader::VisitExpressionTraitExpr(ExpressionTraitExpr *E) {
VisitExpr(E);
- E->ET = (ExpressionTrait)Record.readInt();
- E->Value = (bool)Record.readInt();
+ E->ExpressionTraitExprBits.ET = (ExpressionTrait)Record.readInt();
+ E->ExpressionTraitExprBits.Value = (bool)Record.readInt();
SourceRange Range = readSourceRange();
E->QueriedExpression = Record.readSubExpr();
E->Loc = Range.getBegin();
@@ -2209,14 +2209,14 @@ void ASTStmtReader::VisitSizeOfPackExpr(SizeOfPackExpr
*E) {
void ASTStmtReader::VisitPackIndexingExpr(PackIndexingExpr *E) {
VisitExpr(E);
- E->TransformedExpressions = Record.readInt();
- E->FullySubstituted = Record.readInt();
+ E->PackIndexingExprBits.TransformedExpressions = Record.readInt();
+ E->PackIndexingExprBits.FullySubstituted = Record.readInt();
E->EllipsisLoc = readSourceLocation();
E->RSquareLoc = readSourceLocation();
E->SubExprs[0] = Record.readStmt();
E->SubExprs[1] = Record.readStmt();
auto **Exprs = E->getTrailingObjects<Expr *>();
- for (unsigned I = 0; I < E->TransformedExpressions; ++I)
+ for (unsigned I = 0; I < E->PackIndexingExprBits.TransformedExpressions; ++I)
Exprs[I] = Record.readExpr();
}
@@ -2275,7 +2275,7 @@ void ASTStmtReader::VisitCXXFoldExpr(CXXFoldExpr *E) {
E->SubExprs[0] = Record.readSubExpr();
E->SubExprs[1] = Record.readSubExpr();
E->SubExprs[2] = Record.readSubExpr();
- E->Opcode = (BinaryOperatorKind)Record.readInt();
+ E->CXXFoldExprBits.Opcode = (BinaryOperatorKind)Record.readInt();
}
void ASTStmtReader::VisitCXXParenListInitExpr(CXXParenListInitExpr *E) {
diff --git a/clang/lib/Serialization/ASTWriterStmt.cpp
b/clang/lib/Serialization/ASTWriterStmt.cpp
index fc24b76b79def..767e7405752c2 100644
--- a/clang/lib/Serialization/ASTWriterStmt.cpp
+++ b/clang/lib/Serialization/ASTWriterStmt.cpp
@@ -2212,8 +2212,8 @@ void ASTStmtWriter::VisitSizeOfPackExpr(SizeOfPackExpr
*E) {
void ASTStmtWriter::VisitPackIndexingExpr(PackIndexingExpr *E) {
VisitExpr(E);
- Record.push_back(E->TransformedExpressions);
- Record.push_back(E->FullySubstituted);
+ Record.push_back(E->PackIndexingExprBits.TransformedExpressions);
+ Record.push_back(E->PackIndexingExprBits.FullySubstituted);
Record.AddSourceLocation(E->getEllipsisLoc());
Record.AddSourceLocation(E->getRSquareLoc());
Record.AddStmt(E->getPackIdExpression());
@@ -2278,7 +2278,7 @@ void ASTStmtWriter::VisitCXXFoldExpr(CXXFoldExpr *E) {
Record.AddStmt(E->SubExprs[0]);
Record.AddStmt(E->SubExprs[1]);
Record.AddStmt(E->SubExprs[2]);
- Record.push_back(E->Opcode);
+ Record.push_back(E->CXXFoldExprBits.Opcode);
Code = serialization::EXPR_CXX_FOLD;
}
_______________________________________________
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
