Skip to content

Commit 2546c2c

Browse files
mizvekovmizvekov
committed
[clang] Avoid crash due to unimplemented StructuralValue support in the template differ
This was not implemented in #78041 This patch does not implement this fucntionality, it just falls back to the expression when possible. Otherwise, such as when dealing with canonical types to begin with, this will just ignore the argument as if it wasn't even there. Fixes #93068
1 parent dd2d132 commit 2546c2c

File tree

4 files changed

+114
-42
lines changed

4 files changed

+114
-42
lines changed

‎clang/docs/ReleaseNotes.rst‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -790,6 +790,7 @@ Miscellaneous Clang Crashes Fixed
790790

791791
- Do not attempt to dump the layout of dependent types or invalid declarations
792792
when ``-fdump-record-layouts-complete`` is passed. Fixes #GH83684.
793+
- Unhandled StructuralValues in the template differ (#GH93068).
793794

794795
OpenACC Specific Changes
795796
------------------------

‎clang/lib/AST/ASTDiagnostic.cpp‎

Lines changed: 64 additions & 42 deletions
Original file line numberDiff line numberDiff line change
@@ -1215,46 +1215,19 @@ class TemplateDiff {
12151215
bool &NeedAddressOf) {
12161216
if (!Iter.isEnd()) {
12171217
switch (Iter->getKind()) {
1218-
default:
1219-
llvm_unreachable("unknown ArgumentKind");
1220-
case TemplateArgument::Integral:
1221-
Value = Iter->getAsIntegral();
1222-
HasInt = true;
1223-
IntType = Iter->getIntegralType();
1224-
return;
1225-
case TemplateArgument::Declaration: {
1226-
VD = Iter->getAsDecl();
1227-
QualType ArgType = Iter->getParamTypeForDecl();
1228-
QualType VDType = VD->getType();
1229-
if (ArgType->isPointerType() &&
1230-
Context.hasSameType(ArgType->getPointeeType(), VDType))
1231-
NeedAddressOf = true;
1232-
return;
1233-
}
1234-
case TemplateArgument::NullPtr:
1235-
IsNullPtr = true;
1236-
return;
1237-
case TemplateArgument::Expression:
1238-
E = Iter->getAsExpr();
1239-
}
1240-
} else if (!Default->isParameterPack()) {
1241-
E = Default->getDefaultArgument().getArgument().getAsExpr();
1242-
}
1243-
1244-
if (!Iter.hasDesugaredTA()) return;
1245-
1246-
const TemplateArgument& TA = Iter.getDesugaredTA();
1247-
switch (TA.getKind()) {
1248-
default:
1249-
llvm_unreachable("unknown ArgumentKind");
1218+
case TemplateArgument::StructuralValue:
1219+
// FIXME: Diffing of structural values is not implemented.
1220+
// There is no possible fallback in this case, this will show up
1221+
// as '(no argument)'.
1222+
return;
12501223
case TemplateArgument::Integral:
1251-
Value = TA.getAsIntegral();
1224+
Value = Iter->getAsIntegral();
12521225
HasInt = true;
1253-
IntType = TA.getIntegralType();
1226+
IntType = Iter->getIntegralType();
12541227
return;
12551228
case TemplateArgument::Declaration: {
1256-
VD = TA.getAsDecl();
1257-
QualType ArgType = TA.getParamTypeForDecl();
1229+
VD = Iter->getAsDecl();
1230+
QualType ArgType = Iter->getParamTypeForDecl();
12581231
QualType VDType = VD->getType();
12591232
if (ArgType->isPointerType() &&
12601233
Context.hasSameType(ArgType->getPointeeType(), VDType))
@@ -1265,13 +1238,62 @@ class TemplateDiff {
12651238
IsNullPtr = true;
12661239
return;
12671240
case TemplateArgument::Expression:
1268-
// TODO: Sometimes, the desugared template argument Expr differs from
1269-
// the sugared template argument Expr. It may be useful in the future
1270-
// but for now, it is just discarded.
1271-
if (!E)
1272-
E = TA.getAsExpr();
1273-
return;
1241+
E = Iter->getAsExpr();
1242+
break;
1243+
case TemplateArgument::Null:
1244+
case TemplateArgument::Type:
1245+
case TemplateArgument::Template:
1246+
case TemplateArgument::TemplateExpansion:
1247+
llvm_unreachable("TemplateArgument kind is not expected for NTTP");
1248+
case TemplateArgument::Pack:
1249+
llvm_unreachable("TemplateArgument kind should be handled elsewhere");
1250+
}
1251+
} else if (!Default->isParameterPack()) {
1252+
E = Default->getDefaultArgument().getArgument().getAsExpr();
12741253
}
1254+
1255+
if (!Iter.hasDesugaredTA())
1256+
return;
1257+
1258+
const TemplateArgument &TA = Iter.getDesugaredTA();
1259+
switch (TA.getKind()) {
1260+
case TemplateArgument::StructuralValue:
1261+
// FIXME: Diffing of structural values is not implemented.
1262+
// Just fall back to the expression.
1263+
return;
1264+
case TemplateArgument::Integral:
1265+
Value = TA.getAsIntegral();
1266+
HasInt = true;
1267+
IntType = TA.getIntegralType();
1268+
return;
1269+
case TemplateArgument::Declaration: {
1270+
VD = TA.getAsDecl();
1271+
QualType ArgType = TA.getParamTypeForDecl();
1272+
QualType VDType = VD->getType();
1273+
if (ArgType->isPointerType() &&
1274+
Context.hasSameType(ArgType->getPointeeType(), VDType))
1275+
NeedAddressOf = true;
1276+
return;
1277+
}
1278+
case TemplateArgument::NullPtr:
1279+
IsNullPtr = true;
1280+
return;
1281+
case TemplateArgument::Expression:
1282+
// TODO: Sometimes, the desugared template argument Expr differs from
1283+
// the sugared template argument Expr. It may be useful in the future
1284+
// but for now, it is just discarded.
1285+
if (!E)
1286+
E = TA.getAsExpr();
1287+
return;
1288+
case TemplateArgument::Null:
1289+
case TemplateArgument::Type:
1290+
case TemplateArgument::Template:
1291+
case TemplateArgument::TemplateExpansion:
1292+
llvm_unreachable("TemplateArgument kind is not expected for NTTP");
1293+
case TemplateArgument::Pack:
1294+
llvm_unreachable("TemplateArgument kind should be handled elsewhere");
1295+
}
1296+
llvm_unreachable("Unexpected TemplateArgument kind");
12751297
}
12761298

12771299
/// DiffNonTypes - Handles any template parameters not handled by DiffTypes

‎clang/test/Misc/diag-template-diffing.cpp‎ renamed to ‎clang/test/Misc/diag-template-diffing-cxx11.cpp‎

File renamed without changes.

‎clang/test/Misc/diag-template-diffing-cxx26.cpp‎

Lines changed: 49 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,49 @@
1+
// RUN: %clang_cc1 -fsyntax-only %s -std=c++26 -verify=expected,notree
2+
// RUN: %clang_cc1 -fsyntax-only %s -std=c++26 -fno-elide-type -verify=expected,notree
3+
// RUN: %clang_cc1 -fsyntax-only %s -std=c++26 -fdiagnostics-show-template-tree -verify=expected,tree
4+
// RUN: %clang_cc1 -fsyntax-only %s -std=c++26 -fno-elide-type -fdiagnostics-show-template-tree -verify=expected,tree
5+
6+
namespace GH93068 {
7+
int n[2];
8+
9+
template <auto> struct A {}; // #A
10+
11+
namespace t1 {
12+
// notree-error@#1 {{no viable conversion from 'A<0>' to 'A<n + 1>'}}
13+
14+
/* tree-error@#1 {{no viable conversion
15+
A<
16+
[0 != n + 1]>}}*/
17+
18+
A<n + 1> v1 = A<0>(); // #1
19+
// expected-note@#A {{no known conversion from 'A<0>' to 'const A<&n[1]> &' for 1st argument}}
20+
// expected-note@#A {{no known conversion from 'A<0>' to 'A<&n[1]> &&' for 1st argument}}
21+
22+
// notree-error@#2 {{no viable conversion from 'A<n>' to 'A<(no argument)>'}}
23+
/* tree-error@#2 {{no viable conversion
24+
A<
25+
[n != (no argument)]>}}*/
26+
27+
A<n + 1> v2 = A<n>(); // #2
28+
// expected-note@#A {{no known conversion from 'A<n>' to 'const A<&n[1]> &' for 1st argument}}
29+
// expected-note@#A {{no known conversion from 'A<n>' to 'A<&n[1]> &&' for 1st argument}}
30+
} // namespace t1
31+
32+
namespace t2 {
33+
A<n> v1;
34+
A<n + 1> v2;
35+
36+
// notree-note@#A {{no known conversion from 'A<n>' to 'const A<(no argument)>' for 1st argument}}
37+
// notree-note@#A {{no known conversion from 'A<n>' to 'A<(no argument)>' for 1st argument}}
38+
39+
/* tree-note@#A {{no known conversion from argument type to parameter type for 1st argument
40+
[(no qualifiers) != const] A<
41+
[n != (no argument)]>}}*/
42+
43+
/* tree-note@#A {{no known conversion from argument type to parameter type for 1st argument
44+
A<
45+
[n != (no argument)]>}}*/
46+
47+
void f() { v2 = v1; } // expected-error {{no viable overloaded '='}}
48+
} // namespace t2
49+
} // namespace GH93068

0 commit comments

Comments
 (0)