Skip to content

Commit 86e3852

Browse files
mizvekovmizvekov
committed
[clang] Improve ast-dumper text printing of TemplateArgument
This improves and unifies our approach to printing all template arguments. The same approach to printing types is extended to all TemplateArguments: A sugared version is printed in quotes, followed by printing the canonical form, unless they would print the same. Special improvements are done to add more detail to template template arguments. It's planned in a future patch to use this improved TemplateName printer for other places besides TemplateArguments. Note: The sugared/desugared printing does not show up for TemplateNames in tests yet, because we do a poor job of preserving their type sugar. This will be improved in a future patch.
1 parent 0f85b25 commit 86e3852

17 files changed

+275
-128
lines changed

‎clang/docs/ReleaseNotes.rst‎

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -98,6 +98,8 @@ ABI Changes in This Version
9898
AST Dumping Potentially Breaking Changes
9999
----------------------------------------
100100

101+
- The text ast-dumper has improved printing of TemplateArguments.
102+
101103
Clang Frontend Potentially Breaking Changes
102104
-------------------------------------------
103105
- Removed support for constructing on-stack ``TemplateArgumentList``\ s; interfaces should instead

‎clang/include/clang/AST/TextNodeDumper.h‎

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -213,6 +213,8 @@ class TextNodeDumper
213213
void dumpTemplateSpecializationKind(TemplateSpecializationKind TSK);
214214
void dumpNestedNameSpecifier(const NestedNameSpecifier *NNS);
215215
void dumpConceptReference(const ConceptReference *R);
216+
void dumpTemplateArgument(const TemplateArgument &TA);
217+
void dumpTemplateName(TemplateName TN);
216218

217219
void dumpDeclRef(const Decl *D, StringRef Label = {});
218220

‎clang/lib/AST/TextNodeDumper.cpp‎

Lines changed: 89 additions & 14 deletions
Original file line numberDiff line numberDiff line change
@@ -947,6 +947,26 @@ void TextNodeDumper::dumpDeclRef(const Decl *D, StringRef Label) {
947947
});
948948
}
949949

950+
void TextNodeDumper::dumpTemplateArgument(const TemplateArgument &TA) {
951+
llvm::SmallString<128> Str;
952+
{
953+
llvm::raw_svector_ostream SS(Str);
954+
TA.print(PrintPolicy, SS, /*IncludeType=*/true);
955+
}
956+
OS << " '" << Str << "'";
957+
958+
if (TemplateArgument CanonTA = Context->getCanonicalTemplateArgument(TA);
959+
!CanonTA.structurallyEquals(TA)) {
960+
llvm::SmallString<128> CanonStr;
961+
{
962+
llvm::raw_svector_ostream SS(CanonStr);
963+
CanonTA.print(PrintPolicy, SS, /*IncludeType=*/true);
964+
}
965+
if (CanonStr != Str)
966+
OS << ":'" << CanonStr << "'";
967+
}
968+
}
969+
950970
const char *TextNodeDumper::getCommandName(unsigned CommandID) {
951971
if (Traits)
952972
return Traits->getCommandInfo(CommandID)->Name;
@@ -1086,45 +1106,100 @@ void TextNodeDumper::VisitNullTemplateArgument(const TemplateArgument &) {
10861106

10871107
void TextNodeDumper::VisitTypeTemplateArgument(const TemplateArgument &TA) {
10881108
OS << " type";
1089-
dumpType(TA.getAsType());
1109+
dumpTemplateArgument(TA);
10901110
}
10911111

10921112
void TextNodeDumper::VisitDeclarationTemplateArgument(
10931113
const TemplateArgument &TA) {
10941114
OS << " decl";
1115+
dumpTemplateArgument(TA);
10951116
dumpDeclRef(TA.getAsDecl());
10961117
}
10971118

1098-
void TextNodeDumper::VisitNullPtrTemplateArgument(const TemplateArgument &) {
1119+
void TextNodeDumper::VisitNullPtrTemplateArgument(const TemplateArgument &TA) {
10991120
OS << " nullptr";
1121+
dumpTemplateArgument(TA);
11001122
}
11011123

11021124
void TextNodeDumper::VisitIntegralTemplateArgument(const TemplateArgument &TA) {
1103-
OS << " integral " << TA.getAsIntegral();
1125+
OS << " integral";
1126+
dumpTemplateArgument(TA);
1127+
}
1128+
1129+
void TextNodeDumper::dumpTemplateName(TemplateName TN) {
1130+
switch (TN.getKind()) {
1131+
case TemplateName::Template:
1132+
AddChild([=] { Visit(TN.getAsTemplateDecl()); });
1133+
return;
1134+
case TemplateName::UsingTemplate: {
1135+
const UsingShadowDecl *USD = TN.getAsUsingShadowDecl();
1136+
AddChild([=] { Visit(USD); });
1137+
AddChild("target", [=] { Visit(USD->getTargetDecl()); });
1138+
return;
1139+
}
1140+
case TemplateName::QualifiedTemplate: {
1141+
OS << " qualified";
1142+
const QualifiedTemplateName *QTN = TN.getAsQualifiedTemplateName();
1143+
if (QTN->hasTemplateKeyword())
1144+
OS << " keyword";
1145+
dumpNestedNameSpecifier(QTN->getQualifier());
1146+
dumpTemplateName(QTN->getUnderlyingTemplate());
1147+
return;
1148+
}
1149+
case TemplateName::DependentTemplate: {
1150+
OS << " dependent";
1151+
const DependentTemplateName *DTN = TN.getAsDependentTemplateName();
1152+
dumpNestedNameSpecifier(DTN->getQualifier());
1153+
return;
1154+
}
1155+
case TemplateName::SubstTemplateTemplateParm: {
1156+
const SubstTemplateTemplateParmStorage *STS =
1157+
TN.getAsSubstTemplateTemplateParm();
1158+
OS << " subst index " << STS->getIndex();
1159+
if (std::optional<unsigned int> PackIndex = STS->getPackIndex())
1160+
OS << " pack_index " << *PackIndex;
1161+
if (const TemplateTemplateParmDecl *P = STS->getParameter())
1162+
AddChild("parameter", [=] { Visit(P); });
1163+
dumpDeclRef(STS->getAssociatedDecl(), "associated");
1164+
AddChild("replacement", [=] { dumpTemplateName(STS->getReplacement()); });
1165+
return;
1166+
}
1167+
// FIXME: Implement these.
1168+
case TemplateName::OverloadedTemplate:
1169+
OS << " overloaded";
1170+
return;
1171+
case TemplateName::AssumedTemplate:
1172+
OS << " assumed";
1173+
return;
1174+
case TemplateName::SubstTemplateTemplateParmPack:
1175+
OS << " subst_pack";
1176+
return;
1177+
}
1178+
llvm_unreachable("Unexpected TemplateName Kind");
11041179
}
11051180

11061181
void TextNodeDumper::VisitTemplateTemplateArgument(const TemplateArgument &TA) {
1107-
if (TA.getAsTemplate().getKind() == TemplateName::UsingTemplate)
1108-
OS << " using";
1109-
OS << " template ";
1110-
TA.getAsTemplate().dump(OS);
1182+
OS << " template";
1183+
dumpTemplateArgument(TA);
1184+
dumpTemplateName(TA.getAsTemplate());
11111185
}
11121186

11131187
void TextNodeDumper::VisitTemplateExpansionTemplateArgument(
11141188
const TemplateArgument &TA) {
1115-
if (TA.getAsTemplateOrTemplatePattern().getKind() ==
1116-
TemplateName::UsingTemplate)
1117-
OS << " using";
1118-
OS << " template expansion ";
1119-
TA.getAsTemplateOrTemplatePattern().dump(OS);
1189+
OS << " template expansion";
1190+
dumpTemplateArgument(TA);
1191+
dumpTemplateName(TA.getAsTemplateOrTemplatePattern());
11201192
}
11211193

1122-
void TextNodeDumper::VisitExpressionTemplateArgument(const TemplateArgument &) {
1194+
void TextNodeDumper::VisitExpressionTemplateArgument(
1195+
const TemplateArgument &TA) {
11231196
OS << " expr";
1197+
dumpTemplateArgument(TA);
11241198
}
11251199

1126-
void TextNodeDumper::VisitPackTemplateArgument(const TemplateArgument &) {
1200+
void TextNodeDumper::VisitPackTemplateArgument(const TemplateArgument &TA) {
11271201
OS << " pack";
1202+
dumpTemplateArgument(TA);
11281203
}
11291204

11301205
static void dumpBasePath(raw_ostream &OS, const CastExpr *Node) {

‎clang/test/AST/ast-dump-decl.cpp‎

Lines changed: 14 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -459,21 +459,23 @@ namespace testClassTemplateDecl {
459459

460460
// CHECK: ClassTemplateDecl 0x{{.+}} <{{.+}}:[[@LINE-148]]:3, col:31> col:31 TestTemplateDefaultNonType{{$}}
461461
// CHECK-NEXT: |-NonTypeTemplateParmDecl 0x{{.+}} <col:12, col:20> col:16 'int' depth 0 index 0 I{{$}}
462-
// CHECK-NEXT: | `-TemplateArgument <col:20> expr{{$}}
462+
// CHECK-NEXT: | `-TemplateArgument <col:20> expr '42'{{$}}
463463
// CHECK-NEXT: | `-IntegerLiteral 0x{{.+}} <col:20> 'int' 42{{$}}
464464
// CHECK-NEXT: `-CXXRecordDecl 0x{{.+}} <col:24, col:31> col:31 struct TestTemplateDefaultNonType{{$}}
465465

466466
// CHECK: ClassTemplateDecl 0x{{.+}} <{{.+}}:{{.*}}:3, col:68> col:68 TestTemplateTemplateDefaultType{{$}}
467467
// CHECK-NEXT: |-TemplateTemplateParmDecl 0x{{.+}} <col:12, col:42> col:37 depth 0 index 0 TT{{$}}
468468
// CHECK-NEXT: | |-TemplateTypeParmDecl 0x{{.+}} <col:21> col:29 typename depth 1 index 0{{$}}
469-
// CHECK-NEXT: | `-TemplateArgument <col:42> template TestClassTemplate{{$}}
470-
// CHECK-NEXT: `-CXXRecordDecl 0x{{.+}} <col:61, col:68> col:68 struct TestTemplateTemplateDefaultType{{$}}
469+
// CHECK-NEXT: | `-TemplateArgument <col:42> template 'testClassTemplateDecl::TestClassTemplate'{{$}}
470+
// CHECK-NEXT: | `-ClassTemplateDecl 0x{{.+}} <line:{{.+}}:3, line:{{.+}}:3> line:{{.+}}:30 TestClassTemplate{{$}}
471+
// CHECK-NEXT: `-CXXRecordDecl 0x{{.+}} <line:{{.*}}:61, col:68> col:68 struct TestTemplateTemplateDefaultType{{$}}
471472

472473
// CHECK: ClassTemplateDecl 0x{{.+}} prev 0x{{.+}} <{{.+}}:{{.*}}:3, col:82> col:48 TestTemplateTemplateDefaultType{{$}}
473474
// CHECK-NEXT: |-TemplateTemplateParmDecl 0x{{.+}} <col:12, col:37> col:37 depth 0 index 0 TT{{$}}
474475
// CHECK-NEXT: | |-TemplateTypeParmDecl 0x{{.+}} <col:21> col:29 typename depth 1 index 0{{$}}
475-
// CHECK-NEXT: | `-TemplateArgument <line:{{.*}}:42> template TestClassTemplate{{$}}
476-
// CHECK-NEXT: | `-inherited from TemplateTemplateParm 0x{{.+}} 'TT'{{$}}
476+
// CHECK-NEXT: | `-TemplateArgument <line:{{.*}}:42> template 'testClassTemplateDecl::TestClassTemplate'{{$}}
477+
// CHECK-NEXT: | |-inherited from TemplateTemplateParm 0x{{.+}} 'TT'{{$}}
478+
// CHECK-NEXT: | `-ClassTemplateDecl 0x{{.+}} <line:{{.+}}:3, line:{{.+}}:3> line:{{.+}}:30 TestClassTemplate
477479
// CHECK-NEXT: `-CXXRecordDecl 0x{{.+}} prev 0x{{.+}} <line:{{.*}}:41, col:82> col:48 struct TestTemplateTemplateDefaultType definition{{$}}
478480
// CHECK-NEXT: |-DefinitionData empty aggregate standard_layout trivially_copyable pod trivial literal has_constexpr_non_copy_move_ctor can_const_default_init{{$}}
479481
// CHECK-NEXT: | |-DefaultConstructor exists trivial constexpr needs_implicit defaulted_is_constexpr{{$}}
@@ -683,7 +685,8 @@ namespace TestTemplateTemplateParmDecl {
683685
// CHECK: FunctionTemplateDecl
684686
// CHECK-NEXT: TemplateTemplateParmDecl{{.*}} T
685687
// CHECK-NEXT: TemplateTypeParmDecl{{.*}} typename
686-
// CHECK-NEXT: TemplateArgument{{.*}} template A
688+
// CHECK-NEXT: TemplateArgument{{.*}} template 'TestTemplateTemplateParmDecl::A'
689+
// CHECK-NEXT: ClassTemplateDecl {{.*}} A
687690
// CHECK-NEXT: TemplateTemplateParmDecl{{.*}} ... U
688691
// CHECK-NEXT: TemplateTypeParmDecl{{.*}} typename
689692

@@ -710,12 +713,12 @@ namespace TestTemplateArgument {
710713
template<int> class testIntegral { };
711714
template class testIntegral<1>;
712715
// CHECK: ClassTemplateSpecializationDecl{{.*}} class testIntegral
713-
// CHECK: TemplateArgument{{.*}} integral 1
716+
// CHECK: TemplateArgument{{.*}} integral '1'
714717

715718
template<template<typename> class> class testTemplate { };
716719
template class testTemplate<A>;
717720
// CHECK: ClassTemplateSpecializationDecl{{.*}} class testTemplate
718-
// CHECK: TemplateArgument{{.*}} A
721+
// CHECK: TemplateArgument{{.*}} 'TestTemplateArgument::A'
719722

720723
template<template<typename> class ...T> class C {
721724
B<T...> testTemplateExpansion;
@@ -731,10 +734,10 @@ namespace TestTemplateArgument {
731734
template<int, int ...> class testPack { };
732735
template class testPack<0, 1, 2>;
733736
// CHECK: ClassTemplateSpecializationDecl{{.*}} class testPack
734-
// CHECK: TemplateArgument{{.*}} integral 0
737+
// CHECK: TemplateArgument{{.*}} integral '0'
735738
// CHECK-NEXT: TemplateArgument{{.*}} pack
736-
// CHECK-NEXT: TemplateArgument{{.*}} integral 1
737-
// CHECK-NEXT: TemplateArgument{{.*}} integral 2
739+
// CHECK-NEXT: TemplateArgument{{.*}} integral '1'
740+
// CHECK-NEXT: TemplateArgument{{.*}} integral '2'
738741
}
739742

740743
namespace testUsingDecl {

‎clang/test/AST/ast-dump-openmp-begin-declare-variant_template_2.cpp‎

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -79,7 +79,7 @@ int test() {
7979
// CHECK-NEXT: | | `-ReturnStmt [[ADDR_22:0x[a-z0-9]*]] <line:10:3, col:10>
8080
// CHECK-NEXT: | | `-IntegerLiteral [[ADDR_23:0x[a-z0-9]*]] <col:10> 'int' 0
8181
// CHECK-NEXT: | `-FunctionDecl [[ADDR_24:0x[a-z0-9]*]] <line:9:1, line:11:1> line:9:5 used also_before_mismatch 'int ({{.*}})'
82-
// CHECK-NEXT: | |-TemplateArgument integral 0
82+
// CHECK-NEXT: | |-TemplateArgument integral '0'
8383
// CHECK-NEXT: | `-CompoundStmt [[ADDR_25:0x[a-z0-9]*]] <col:32, line:11:1>
8484
// CHECK-NEXT: | `-ReturnStmt [[ADDR_26:0x[a-z0-9]*]] <line:10:3, col:10>
8585
// CHECK-NEXT: | `-IntegerLiteral [[ADDR_23]] <col:10> 'int' 0
@@ -179,7 +179,7 @@ int test() {
179179
// CHECK-NEXT: | | `-OMPDeclareVariantAttr [[ADDR_101:0x[a-z0-9]*]] <<invalid sloc>> Implicit implementation={extension(allow_templates)}
180180
// CHECK-NEXT: | | `-DeclRefExpr [[ADDR_102:0x[a-z0-9]*]] <col:1> 'int ({{.*}})' {{.*}}Function [[ADDR_103:0x[a-z0-9]*]] 'only_def[implementation={extension(allow_templates)}]' 'int ({{.*}})'
181181
// CHECK-NEXT: | `-FunctionDecl [[ADDR_104:0x[a-z0-9]*]] <col:1, col:18> col:5 used only_def 'int ({{.*}})'
182-
// CHECK-NEXT: | |-TemplateArgument integral 0
182+
// CHECK-NEXT: | |-TemplateArgument integral '0'
183183
// CHECK-NEXT: | `-OMPDeclareVariantAttr [[ADDR_105:0x[a-z0-9]*]] <<invalid sloc>> Implicit implementation={extension(allow_templates)}
184184
// CHECK-NEXT: | `-DeclRefExpr [[ADDR_106:0x[a-z0-9]*]] <col:1> 'int ({{.*}})' {{.*}}Function [[ADDR_107:0x[a-z0-9]*]] 'only_def[implementation={extension(allow_templates)}]' 'int ({{.*}})'
185185
// CHECK-NEXT: |-FunctionTemplateDecl [[ADDR_108:0x[a-z0-9]*]] <line:37:1, line:40:1> line:38:1 only_def[implementation={extension(allow_templates)}]
@@ -189,7 +189,7 @@ int test() {
189189
// CHECK-NEXT: | | `-ReturnStmt [[ADDR_110:0x[a-z0-9]*]] <line:39:3, col:10>
190190
// CHECK-NEXT: | | `-IntegerLiteral [[ADDR_111:0x[a-z0-9]*]] <col:10> 'int' 0
191191
// CHECK-NEXT: | `-FunctionDecl [[ADDR_107]] <line:38:1, line:40:1> line:38:1 only_def[implementation={extension(allow_templates)}] 'int ({{.*}})'
192-
// CHECK-NEXT: | |-TemplateArgument integral 0
192+
// CHECK-NEXT: | |-TemplateArgument integral '0'
193193
// CHECK-NEXT: | `-CompoundStmt [[ADDR_112:0x[a-z0-9]*]] <col:20, line:40:1>
194194
// CHECK-NEXT: | `-ReturnStmt [[ADDR_113:0x[a-z0-9]*]] <line:39:3, col:10>
195195
// CHECK-NEXT: | `-IntegerLiteral [[ADDR_111]] <col:10> 'int' 0

‎clang/test/AST/ast-dump-template-name.cpp‎

Lines changed: 54 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,54 @@
1+
// RUN: %clang_cc1 -std=c++26 -ast-dump -ast-dump-filter=Test %s | FileCheck %s
2+
3+
template <template <class> class TT> using N = TT<int>;
4+
5+
namespace qualified {
6+
namespace foo {
7+
template <class T> struct A;
8+
} // namespace foo
9+
using TestQualified = N<foo::A>;
10+
} // namespace qualified
11+
12+
// CHECK: Dumping qualified::TestQualified:
13+
// CHECK-NEXT: TypeAliasDecl
14+
// CHECK-NEXT: `-ElaboratedType
15+
// CHECK-NEXT: `-TemplateSpecializationType
16+
// CHECK-NEXT: |-TemplateArgument template 'qualified::foo::A' qualified{{$}}
17+
// CHECK-NEXT: | |-NestedNameSpecifier Namespace 0x{{.+}} 'foo'{{$}}
18+
// CHECK-NEXT: | `-ClassTemplateDecl {{.+}} A{{$}}
19+
20+
namespace dependent {
21+
template <class T> struct B {
22+
using TestDependent = N<T::template X>;
23+
};
24+
} // namespace dependent
25+
26+
// CHECK: Dumping dependent::B::TestDependent:
27+
// CHECK-NEXT: TypeAliasDecl
28+
// CHECK-NEXT: `-ElaboratedType
29+
// CHECK-NEXT: `-TemplateSpecializationType
30+
// CHECK-NEXT: |-TemplateArgument template 'template X' dependent{{$}}
31+
// CHECK-NEXT: | `-NestedNameSpecifier TypeSpec 'T'{{$}}
32+
33+
namespace subst {
34+
template <class> struct A;
35+
36+
template <template <class> class TT> struct B {
37+
template <template <class> class> struct C {};
38+
using type = C<TT>;
39+
};
40+
using TestSubst = B<A>::type;
41+
} // namespace subst
42+
43+
// CHECK: Dumping subst::TestSubst:
44+
// CHECK-NEXT: TypeAliasDecl
45+
// CHECK-NEXT: `-ElaboratedType
46+
// CHECK-NEXT: `-TypedefType
47+
// CHECK-NEXT: |-TypeAlias
48+
// CHECK-NEXT: `-ElaboratedType
49+
// CHECK-NEXT: `-TemplateSpecializationType
50+
// CHECK-NEXT: |-TemplateArgument template 'subst::A' subst index 0
51+
// CHECK-NEXT: | |-parameter: TemplateTemplateParmDecl {{.+}} depth 0 index 0 TT{{$}}
52+
// CHECK-NEXT: | |-associated ClassTemplateSpecialization {{.+}} 'B'{{$}}
53+
// CHECK-NEXT: | `-replacement:
54+
// CHECK-NEXT: | `-ClassTemplateDecl {{.+}} A{{$}}

‎clang/test/AST/ast-dump-using-template.cpp‎

Lines changed: 5 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -28,9 +28,11 @@ using B = X<S>;
2828
// CHECK: TypeAliasDecl
2929
// CHECK-NEXT: `-ElaboratedType {{.*}} 'X<ns::S>' sugar
3030
// CHECK-NEXT: `-TemplateSpecializationType {{.*}} 'X<ns::S>' sugar X
31-
// CHECK-NEXT: |-TemplateArgument using template S
32-
// CHECK-NEXT: `-RecordType {{.*}} 'X<ns::S>'
33-
// CHECK-NEXT: `-ClassTemplateSpecialization {{.*}} 'X'
31+
// CHECK-NEXT: |-TemplateArgument template 'ns::S'
32+
// CHECK-NEXT: | |-UsingShadowDecl {{.*}} implicit ClassTemplate {{.*}} 'S'
33+
// CHECK-NEXT: | `-target: ClassTemplateDecl {{.*}} S
34+
// CHECK-NEXT: `-RecordType {{.*}} 'X<ns::S>'
35+
// CHECK-NEXT: `-ClassTemplateSpecialization {{.*}} 'X'
3436

3537
// TemplateName in DeducedTemplateSpecializationType.
3638
S DeducedTemplateSpecializationT(123);

‎clang/test/AST/constraints-explicit-instantiation.cpp‎

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -21,17 +21,17 @@ struct A {
2121

2222
// This checks that `canary1<1>` and `canaray2<2>` are instantiated, thus
2323
// indirectly validating that the correct candidates of `A::f` were really
24-
// instantiated each time.
24+
// instantiated each time.
2525
// The `static_assert`s validate we don't instantiate wrong candidates.
2626

2727
// CHECK:{{.*}}FunctionTemplateDecl {{.*}} canary1
2828
// CHECK: {{.*}}TemplateArgument integral
29-
// CHECK-SAME: {{1$}}
29+
// CHECK-SAME: {{'1'$}}
3030
template struct A<1>;
3131

3232
// CHECK: {{.*}}FunctionTemplateDecl {{.*}} canary2
3333
// CHECK: {{.*}}TemplateArgument integral
34-
// CHECK-SAME: {{2$}}
34+
// CHECK-SAME: {{'2'$}}
3535
template struct A<2>;
3636

3737
template struct A<3>;

‎clang/test/OpenMP/align_clause_ast_print.cpp‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -114,7 +114,7 @@ int template_test() {
114114
// DUMP: FunctionDecl {{.*}}run 'double ()'
115115
// DUMP: TemplateArgument type 'double'
116116
// DUMP: BuiltinType {{.*}}'double'
117-
// DUMP: TemplateArgument integral 1
117+
// DUMP: TemplateArgument integral '1U'
118118
// DUMP: OMPAllocateDeclAttr {{.*}}Implicit OMPNullMemAlloc
119119
// DUMP: ConstantExpr {{.*}}'unsigned int'
120120
// DUMP: value: Int 1

‎clang/test/OpenMP/generic_loop_ast_print.cpp‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -50,7 +50,7 @@
5050
//PRINT: }
5151
//DUMP: FunctionDecl{{.*}}templ_foo 'void (int)'
5252
//DUMP: TemplateArgument type 'int'
53-
//DUMP: TemplateArgument integral 2
53+
//DUMP: TemplateArgument integral '2'
5454
//DUMP: ParmVarDecl{{.*}}'int'
5555
//DUMP: OMPSimdDirective
5656
//DUMP: OMPCollapseClause

0 commit comments

Comments
 (0)