github-actions[bot] wrote:
<!--LLVM CODE FORMAT COMMENT: {clang-format}-->
:warning: C/C++ code formatter, clang-format found issues in your code.
:warning:
<details>
<summary>
You can test this locally with the following command:
</summary>
``````````bash
git-clang-format --diff 7dd34baf5505d689161c3a8678322a394d7a2929
1b016f8b86eb004568e2779d19cc030e8c487762 --extensions cpp,h --
clang/lib/AST/ItaniumMangle.cpp libcxxabi/src/demangle/ItaniumDemangle.h
libcxxabi/test/test_demangle.pass.cpp
llvm/include/llvm/Demangle/ItaniumDemangle.h
``````````
</details>
<details>
<summary>
View the diff from clang-format here.
</summary>
``````````diff
diff --git a/clang/lib/AST/ItaniumMangle.cpp b/clang/lib/AST/ItaniumMangle.cpp
index e870942539..ddf401f993 100644
--- a/clang/lib/AST/ItaniumMangle.cpp
+++ b/clang/lib/AST/ItaniumMangle.cpp
@@ -603,7 +603,7 @@ private:
void mangleInitListElements(const InitListExpr *InitList);
void mangleRequirement(SourceLocation RequiresExprLoc,
const concepts::Requirement *Req);
- void mangleReferenceToPack(const NamedDecl* ND);
+ void mangleReferenceToPack(const NamedDecl *ND);
void mangleExpression(const Expr *E, unsigned Arity = UnknownArity,
bool AsTemplateArg = false);
void mangleCXXCtorType(CXXCtorType T, const CXXRecordDecl *InheritedFrom);
@@ -4354,8 +4354,7 @@ void CXXNameMangler::mangleType(const PackIndexingType
*T) {
Out << "Dy";
mangleType(T->getPattern());
mangleExpression(T->getIndexExpr());
- }
- else
+ } else
mangleType(T->getSelectedType());
}
@@ -4790,49 +4789,65 @@ void CXXNameMangler::mangleRequirement(SourceLocation
RequiresExprLoc,
}
}
-void CXXNameMangler::mangleReferenceToPack(const NamedDecl* Pack) {
- if (const TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(Pack))
- mangleTemplateParameter(TTP->getDepth(), TTP->getIndex());
- else if (const NonTypeTemplateParmDecl *NTTP
- = dyn_cast<NonTypeTemplateParmDecl>(Pack))
- mangleTemplateParameter(NTTP->getDepth(), NTTP->getIndex());
- else if (const TemplateTemplateParmDecl *TempTP
- = dyn_cast<TemplateTemplateParmDecl>(Pack))
- mangleTemplateParameter(TempTP->getDepth(), TempTP->getIndex());
- else
- mangleFunctionParam(cast<ParmVarDecl>(Pack));
+void CXXNameMangler::mangleReferenceToPack(const NamedDecl *Pack) {
+ if (const TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(Pack))
+ mangleTemplateParameter(TTP->getDepth(), TTP->getIndex());
+ else if (const NonTypeTemplateParmDecl *NTTP =
+ dyn_cast<NonTypeTemplateParmDecl>(Pack))
+ mangleTemplateParameter(NTTP->getDepth(), NTTP->getIndex());
+ else if (const TemplateTemplateParmDecl *TempTP =
+ dyn_cast<TemplateTemplateParmDecl>(Pack))
+ mangleTemplateParameter(TempTP->getDepth(), TempTP->getIndex());
+ else
+ mangleFunctionParam(cast<ParmVarDecl>(Pack));
}
void CXXNameMangler::mangleExpression(const Expr *E, unsigned Arity,
bool AsTemplateArg) {
// <expression> ::= <unary operator-name> <expression>
// ::= <binary operator-name> <expression> <expression>
- // ::= <trinary operator-name> <expression> <expression>
<expression>
- // ::= cv <type> expression # conversion with one
argument
- // ::= cv <type> _ <expression>* E # conversion with a
different number of arguments
- // ::= dc <type> <expression> # dynamic_cast<type>
(expression)
- // ::= sc <type> <expression> # static_cast<type>
(expression)
- // ::= cc <type> <expression> # const_cast<type>
(expression)
- // ::= rc <type> <expression> # reinterpret_cast<type>
(expression)
+ // ::= <trinary operator-name> <expression> <expression>
+ // <expression>
+ // ::= cv <type> expression # conversion with one
+ // argument
+ // ::= cv <type> _ <expression>* E # conversion with a different
+ // number of arguments
+ // ::= dc <type> <expression> # dynamic_cast<type>
+ // (expression)
+ // ::= sc <type> <expression> # static_cast<type>
+ // (expression)
+ // ::= cc <type> <expression> # const_cast<type>
+ // (expression)
+ // ::= rc <type> <expression> # reinterpret_cast<type>
+ // (expression)
// ::= st <type> # sizeof (a type)
// ::= at <type> # alignof (a type)
// ::= <template-param>
// ::= <function-param>
- // ::= fpT # 'this' expression (part
of <function-param>)
- // ::= sr <type> <unqualified-name> #
dependent name
- // ::= sr <type> <unqualified-name> <template-args> #
dependent template-id
- // ::= sy <expression> <expression> # pack
indexing expression
- // ::= ds <expression> <expression> #
expr.*expr
- // ::= sZ <template-param> # size of
a parameter pack
+ // ::= fpT # 'this' expression (part
+ // of <function-param>)
+ // ::= sr <type> <unqualified-name> #
dependent
+ // name
+ // ::= sr <type> <unqualified-name> <template-args> #
dependent
+ // template-id
+ // ::= sy <expression> <expression> # pack
+ // indexing expression
+ // ::= ds <expression> <expression> #
+ // expr.*expr
+ // ::= sZ <template-param> # size of
a
+ // parameter pack
// ::= sZ <function-param> # size of a function parameter
pack
- // ::= u <source-name> <template-arg>* E # vendor extended
expression
+ // ::= u <source-name> <template-arg>* E # vendor extended
+ // expression
// ::= <expr-primary>
// <expr-primary> ::= L <type> <value number> E # integer literal
// ::= L <type> <value float> E # floating literal
// ::= L <type> <string type> E # string literal
// ::= L <nullptr type> E # nullptr literal "LDnE"
- // ::= L <pointer type> 0 E # null pointer template
argument
- // ::= L <type> <real-part float> _ <imag-part float> E #
complex floating point literal (C99); not used by clang
+ // ::= L <pointer type> 0 E # null pointer template
+ // argument
+ // ::= L <type> <real-part float> _ <imag-part float> E #
+ // complex floating point literal (C99); not used by clang
// ::= L <mangled-name> E # external name
QualType ImplicitlyConvertedToType;
@@ -5837,16 +5852,16 @@ recurse:
}
case Expr::PackIndexingExprClass: {
- auto *PE = cast<PackIndexingExpr>(E);
- if(PE->isFullySubstituted()) {
- E = PE->getSelectedExpr();
- goto recurse;
- }
- NotPrimaryExpr();
- Out << "sy";
- mangleReferenceToPack(PE->getPackDecl());
- mangleExpression(PE->getIndexExpr());
- break;
+ auto *PE = cast<PackIndexingExpr>(E);
+ if (PE->isFullySubstituted()) {
+ E = PE->getSelectedExpr();
+ goto recurse;
+ }
+ NotPrimaryExpr();
+ Out << "sy";
+ mangleReferenceToPack(PE->getPackDecl());
+ mangleExpression(PE->getIndexExpr());
+ break;
}
case Expr::CXXThisExprClass:
diff --git a/libcxxabi/src/demangle/ItaniumDemangle.h
b/libcxxabi/src/demangle/ItaniumDemangle.h
index a65de9fee4..374aae13ff 100644
--- a/libcxxabi/src/demangle/ItaniumDemangle.h
+++ b/libcxxabi/src/demangle/ItaniumDemangle.h
@@ -1529,9 +1529,7 @@ public:
PackIndexing(const Node *Pattern_, const Node *Index_)
: Node(KPackIndexing), Pattern(Pattern_), Index(Index_) {}
- template <typename Fn> void match(Fn F) const {
- F(Pattern, Index);
- }
+ template <typename Fn> void match(Fn F) const { F(Pattern, Index); }
void printLeft(OutputBuffer &OB) const override {
OB.printOpen('(');
diff --git a/llvm/include/llvm/Demangle/ItaniumDemangle.h
b/llvm/include/llvm/Demangle/ItaniumDemangle.h
index e62de5d06a..e05362fd83 100644
--- a/llvm/include/llvm/Demangle/ItaniumDemangle.h
+++ b/llvm/include/llvm/Demangle/ItaniumDemangle.h
@@ -1531,9 +1531,7 @@ public:
PackIndexing(const Node *Pattern_, const Node *Index_)
: Node(KPackIndexing), Pattern(Pattern_), Index(Index_) {}
- template <typename Fn> void match(Fn F) const {
- F(Pattern, Index);
- }
+ template <typename Fn> void match(Fn F) const { F(Pattern, Index); }
void printLeft(OutputBuffer &OB) const override {
ParameterPackExpansion PPE(Pattern);
@@ -1544,7 +1542,6 @@ public:
}
};
-
class TemplateArgs final : public Node {
NodeArray Params;
Node *Requires;
@@ -4537,9 +4534,8 @@ Node *AbstractManglingParser<Derived, Alloc>::parseType()
{
// ::= Dy <type> <expression> # pack indexing (C++26)
case 'y': {
First += 2;
- Node *Pattern = look() == 'T' ?
- getDerived().parseTemplateParam()
- : getDerived().parseFunctionParam();
+ Node *Pattern = look() == 'T' ? getDerived().parseTemplateParam()
+ : getDerived().parseFunctionParam();
if (Pattern == nullptr)
return nullptr;
Node *Index = getDerived().parseExpr();
@@ -5393,11 +5389,10 @@ Node *AbstractManglingParser<Derived,
Alloc>::parseExpr() {
return make<ParameterPackExpansion>(Child);
}
if (consumeIf("sy")) {
- Node *Pattern = look() == 'T' ?
- getDerived().parseTemplateParam()
- : getDerived().parseFunctionParam();
+ Node *Pattern = look() == 'T' ? getDerived().parseTemplateParam()
+ : getDerived().parseFunctionParam();
if (Pattern == nullptr)
- return nullptr;
+ return nullptr;
Node *Index = getDerived().parseExpr();
if (Index == nullptr)
return nullptr;
``````````
</details>
https://github.com/llvm/llvm-project/pull/123513
_______________________________________________
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
