mirror of
https://github.com/llvm/llvm-project.git
synced 2025-04-17 06:46:36 +00:00
342e64979a
Fixes #54629. The crash is is caused by the double template instantiation. See the added test. Here is what happens: - Template arguments for the partial specialization get instantiated. - This causes instantitation into the corrensponding requires expression. - `TemplateInsantiator` correctly handles instantiation of parameters inside `RequiresExprBody` and instantiates the constraint expression inside the `NestedRequirement`. - To build the substituted `NestedRequirement`, `TemplateInsantiator` calls `Sema::BuildNestedRequirement` calls `CheckConstraintSatisfaction`, which results in another template instantiation (with empty template arguments). This seem to be an implementation detail to handle constraint satisfaction and is not required by the standard. - The recursive template instantiation tries to find the parameter inside `RequiresExprBody` and fails with the corresponding assertion. Note that this only happens as both instantiations happen with the class partial template specialization set as `Sema.CurContext`, which is considered a dependent `DeclContext`. To fix the assertion, avoid doing the recursive template instantiation and instead evaluate resulting expressions in-place. Reviewed By: erichkeane Differential Revision: https://reviews.llvm.org/D127487
59 lines
1.7 KiB
C++
59 lines
1.7 KiB
C++
// RUN: %clang_cc1 -std=c++20 -verify %s
|
|
|
|
template <class T>
|
|
struct A {
|
|
void primary();
|
|
};
|
|
|
|
template <class T>
|
|
requires requires(T &t) { requires sizeof(t) > 4; }
|
|
struct A<T> {
|
|
void specialization1();
|
|
};
|
|
|
|
template <class T>
|
|
requires requires(T &t) { requires sizeof(t) > 8; }
|
|
struct A<T> {
|
|
void specialization2();
|
|
};
|
|
|
|
int main() {
|
|
A<char>().primary();
|
|
A<char[5]>().specialization1();
|
|
A<char[16]>(); // expected-error {{ambiguous partial specialization}}
|
|
// expected-note@10 {{partial specialization matches [with T = char[16]}}
|
|
// expected-note@16 {{partial specialization matches [with T = char[16]}}
|
|
}
|
|
|
|
// Check error messages when no overload with constraints matches.
|
|
template <class T>
|
|
void foo()
|
|
requires requires(T &t) { requires sizeof(t) < 4; }
|
|
{}
|
|
|
|
template <class T>
|
|
void foo()
|
|
requires requires(T &t) { requires sizeof(t) > 4; }
|
|
{}
|
|
|
|
template <class T>
|
|
void foo()
|
|
requires requires(T &t) { requires sizeof(t) > 8; }
|
|
{}
|
|
|
|
void test() {
|
|
foo<char[4]>();
|
|
// expected-error@-1 {{no matching function for call to 'foo'}}
|
|
// expected-note@30 {{candidate template ignored: constraints not satisfied}}
|
|
// expected-note@31 {{because 'sizeof (t) < 4' (4 < 4) evaluated to false}}
|
|
// expected-note@35 {{candidate template ignored: constraints not satisfied}}
|
|
// expected-note@36 {{because 'sizeof (t) > 4' (4 > 4) evaluated to false}}
|
|
// expected-note@40 {{candidate template ignored: constraints not satisfied}}
|
|
// expected-note@41 {{because 'sizeof (t) > 8' (4 > 8) evaluated to false}}
|
|
|
|
foo<char[16]>();
|
|
// expected-error@-1 {{call to 'foo' is ambiguous}}
|
|
// expected-note@35 {{candidate function}}
|
|
// expected-note@40 {{candidate function}}
|
|
}
|