================
@@ -0,0 +1,316 @@
+// RUN: %clang_cc1 -fsyntax-only -std=c++23 -verify %s
+
+namespace test1 {
+ template<typename T> struct Base {
+ template<typename V = T> requires true
+ Base(T);
+ };
+
+ template<typename T> struct InheritsCtors : public Base<T> {
+ using Base<T>::Base;
+ };
+
+ InheritsCtors inheritsCtors(1);
+ static_assert(__is_same(InheritsCtors<int>, decltype(inheritsCtors)));
+
+ template<typename T> struct DoesNotInheritCtors : public Base<T> {}; //
expected-note {{candidate template ignored: could not match
'DoesNotInheritCtors<T>' against 'int'}} \
+ //
expected-note 3{{implicit deduction guide declared as}} \
+ //
expected-note {{candidate function template not viable: requires 0 arguments,
but 1 was provided}} \
+ //
expected-note {{candidate template ignored: could not match 'Base<T>' against
'int'}}
+ DoesNotInheritCtors doesNotInheritCtors(100); // expected-error {{no viable
constructor or deduction guide for deduction of template arguments}}
+
+ template<typename T> struct InheritsSecond : public Base<T> {
+ using Base<T>::Base;
+ };
+
+ InheritsSecond inheritsSecond('a');
+ static_assert(__is_same(InheritsSecond<char>, decltype(inheritsSecond)));
+
+ template<typename T> struct NonTemplateDGuideBase {
+ NonTemplateDGuideBase(T); // expected-note {{generated from
'NonTemplateDGuideBase<T>' constructor}}
+ };
+ NonTemplateDGuideBase(int) -> NonTemplateDGuideBase<char>;
+ NonTemplateDGuideBase(const char *) -> NonTemplateDGuideBase<const char *>;
+
+ template<typename T>
+ concept NoPointers = !requires (T t) { *t; };
+
+ template<NoPointers T>
+ struct NonTemplateDGuideDerived : public NonTemplateDGuideBase<T> { //
expected-note {{candidate template ignored: could not match
'NonTemplateDGuideDerived<T>' against 'const char *'}} \
+ //
expected-note {{candidate function template not viable: requires 0 arguments,
but 1 was provided}} \
+ //
expected-note 2{{implicit deduction guide declared as }}
+ using NonTemplateDGuideBase<T>::NonTemplateDGuideBase; // expected-note
{{candidate function not viable: no known conversion from 'const char[1]' to
'int' for 1st argument}} \
+ // expected-note
{{candidate template ignored: could not deduce template arguments for
'NonTemplateDGuideDerived<T>' from 'NonTemplateDGuideBase<T>' [with T = const
char *]}} \
+ // expected-note
{{implicit deduction guide declared as 'template <NoPointers<> T>
NonTemplateDGuideDerived(T) -> typename
__ctad_CC_NonTemplateDGuideBase_to_NonTemplateDGuideDerived_0<NonTemplateDGuideBase<T>>::type'}}
\
+ // expected-note
{{candidate template ignored: could not match 'NonTemplateDGuideBase<T>'
against 'const char *'}} \
+ // expected-note
{{implicit deduction guide declared as 'template <NoPointers<> T>
NonTemplateDGuideDerived(NonTemplateDGuideBase<T>) -> typename
__ctad_CC_NonTemplateDGuideBase_to_NonTemplateDGuideDerived_0<NonTemplateDGuideBase<T>>::type'}}
+ };
+
+ NonTemplateDGuideDerived ntdg(1);
+ static_assert(__is_same(NonTemplateDGuideDerived<char>, decltype(ntdg)));
+
+ NonTemplateDGuideDerived ntdg_char(""); // expected-error {{no viable
constructor or deduction guide for deduction of template arguments}}
+
+ template<typename T>
+ struct ExplicitBase {
+ template<typename V>
+ ExplicitBase(V);
+ };
+
+ template<typename T>
+ ExplicitBase(T) -> ExplicitBase<T>;
+
+ template<NoPointers T>
+ struct ExplicitDerived : public ExplicitBase<T> { // expected-note
{{candidate template ignored: could not match 'ExplicitDerived<T>' against
'const char *'}} \
+ // expected-note
{{candidate function template not viable: requires 0 arguments, but 1 was
provided}} \
+ // expected-note
2{{implicit deduction guide declared as }}
+
+ using ExplicitBase<T>::ExplicitBase; // expected-note {{candidate template
ignored: couldn't infer template argument 'T'}} \
+ // expected-note {{implicit deduction
guide declared as 'template <NoPointers<> T, typename V> ExplicitDerived(V) ->
typename __ctad_CC_ExplicitBase_to_ExplicitDerived_0<ExplicitBase<T>>::type'}} \
+ // expected-note {{candidate template
ignored: could not match 'ExplicitBase<T>' against 'const char *'}} \
+ // expected-note {{candidate template
ignored: could not deduce template arguments for 'ExplicitDerived<T>' from
'ExplicitBase<T>' [with T = const char *]}} \
+ // expected-note {{implicit deduction
guide declared as 'template <NoPointers<> T> ExplicitDerived(ExplicitBase<T>)
-> typename
__ctad_CC_ExplicitBase_to_ExplicitDerived_0<ExplicitBase<T>>::type'}}
----------------
antangelo wrote:
By `<implicit deduction guide for X inherited from Y>` do you mean to show the
declaration for the original deduction guide on the base instead of the
transformed guide on the derived class?
https://github.com/llvm/llvm-project/pull/98788
_______________________________________________
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
