mirror of
https://github.com/Gericom/teak-llvm.git
synced 2025-06-19 19:45:40 -04:00
5159bbad8b
destructors. We previously tried to patch up the exception specification after completing the class, which went wrong when the exception specification was needed within the class body (in particular, by a friend redeclaration of the destructor in a nested class). We now mark the destructor as having a not-yet-computed exception specification immediately after creating it. This requires delaying various checks against the exception specification (where we'd previously have just got the wrong exception specification, and now find we have an exception specification that we can't compute yet) when those checks fire while the class is being defined. This also exposed an issue that we were missing a CodeSynthesisContext for computation of exception specifications (otherwise we'd fail to make the module containing the definition of the class visible when computing its members' exception specs). Adding that incidentally also gives us a diagnostic quality improvement. This has also exposed an pre-existing problem: making the exception specification evaluation context a non-SFINAE context (as it should be) results in a bootstrap failure; PR38850 filed for this. llvm-svn: 341499
275 lines
14 KiB
C++
275 lines
14 KiB
C++
// RUN: rm -rf %t
|
|
// RUN: not %clang_cc1 -x objective-c++ -fmodules -fimplicit-module-maps -fno-modules-error-recovery -fmodules-cache-path=%t -I %S/Inputs %s -std=c++14 -ast-dump-lookups 2>/dev/null | FileCheck %s --check-prefix=CHECK-GLOBAL
|
|
// RUN: not %clang_cc1 -x objective-c++ -fmodules -fimplicit-module-maps -fno-modules-error-recovery -fmodules-cache-path=%t -I %S/Inputs %s -std=c++14 -ast-dump-lookups -ast-dump-filter N 2>/dev/null | FileCheck %s --check-prefix=CHECK-NAMESPACE-N
|
|
// RUN: not %clang_cc1 -x objective-c++ -fmodules -fimplicit-module-maps -fno-modules-error-recovery -fmodules-cache-path=%t -I %S/Inputs %s -std=c++14 -ast-dump -ast-dump-filter SomeTemplate 2>/dev/null | FileCheck %s --check-prefix=CHECK-DUMP
|
|
// RUN: %clang_cc1 -x objective-c++ -fmodules -fimplicit-module-maps -fno-modules-error-recovery -fmodules-cache-path=%t -I %S/Inputs %s -verify -std=c++14
|
|
// RUN: %clang_cc1 -x objective-c++ -fmodules -fimplicit-module-maps -fno-modules-error-recovery -fmodules-cache-path=%t -I %S/Inputs %s -verify -std=c++14 -DEARLY_IMPORT
|
|
|
|
#ifdef EARLY_IMPORT
|
|
#include "cxx-templates-textual.h"
|
|
#endif
|
|
|
|
@import cxx_templates_a;
|
|
@import cxx_templates_b;
|
|
@import cxx_templates_c;
|
|
@import cxx_templates_d;
|
|
@import cxx_templates_common;
|
|
|
|
template<typename, char> struct Tmpl_T_C {};
|
|
template<typename, int, int> struct Tmpl_T_I_I {};
|
|
|
|
template<typename A, typename B, A> struct Tmpl_T_T_A {};
|
|
template<typename A, typename B, B> struct Tmpl_T_T_B {};
|
|
|
|
template<int> struct UseInt {};
|
|
|
|
void g() {
|
|
f(0);
|
|
f<double>(1.0);
|
|
f<int>();
|
|
f(); // expected-error {{no matching function}}
|
|
// expected-note@Inputs/cxx-templates-a.h:3 {{couldn't infer template argument}}
|
|
// expected-note@Inputs/cxx-templates-a.h:4 {{requires 1 argument}}
|
|
|
|
N::f(0);
|
|
N::f<double>(1.0);
|
|
N::f<int>();
|
|
N::f(); // expected-error {{no matching function}}
|
|
// expected-note@Inputs/cxx-templates-b.h:6 {{couldn't infer template argument}}
|
|
// expected-note@Inputs/cxx-templates-b.h:7 {{requires single argument}}
|
|
|
|
template_param_kinds_1<0>(); // ok, from cxx-templates-a.h
|
|
template_param_kinds_1<int>(); // ok, from cxx-templates-b.h
|
|
|
|
template_param_kinds_2<Tmpl_T_C>(); // expected-error {{no matching function}}
|
|
// expected-note@Inputs/cxx-templates-a.h:11 {{invalid explicitly-specified argument}}
|
|
// expected-note@Inputs/cxx-templates-b.h:11 {{invalid explicitly-specified argument}}
|
|
|
|
template_param_kinds_2<Tmpl_T_I_I>(); // expected-error {{ambiguous}}
|
|
// expected-note@Inputs/cxx-templates-a.h:11 {{candidate}}
|
|
// expected-note@Inputs/cxx-templates-b.h:11 {{candidate}}
|
|
|
|
// FIXME: This should be valid, but we incorrectly match the template template
|
|
// argument against both template template parameters.
|
|
template_param_kinds_3<Tmpl_T_T_A>(); // expected-error {{ambiguous}}
|
|
// expected-note@Inputs/cxx-templates-a.h:12 {{candidate}}
|
|
// expected-note@Inputs/cxx-templates-b.h:12 {{candidate}}
|
|
template_param_kinds_3<Tmpl_T_T_B>(); // expected-error {{ambiguous}}
|
|
// expected-note@Inputs/cxx-templates-a.h:12 {{candidate}}
|
|
// expected-note@Inputs/cxx-templates-b.h:12 {{candidate}}
|
|
|
|
// Trigger the instantiation of a template in 'a' that uses a type defined in
|
|
// 'common'. That type is not visible here.
|
|
PerformDelayedLookup(defined_in_common);
|
|
|
|
// Likewise, but via a default argument.
|
|
PerformDelayedLookupInDefaultArgument(defined_in_common);
|
|
|
|
// Trigger the instantiation of a template in 'b' that uses a type defined in
|
|
// 'b_impl'. That type is not visible here.
|
|
UseDefinedInBImpl<int>();
|
|
|
|
// Trigger the instantiation of a template in 'a' that uses a type defined in
|
|
// 'b_impl', via a template defined in 'b'. Since the type is visible from
|
|
// within 'b', the instantiation succeeds.
|
|
UseDefinedInBImplIndirectly(defined_in_b_impl);
|
|
|
|
// Trigger the instantiation of a template in 'a' that uses a type defined in
|
|
// 'b_impl'. That type is not visible here, nor in 'a'. This fails; there is
|
|
// no reason why DefinedInBImpl should be visible here.
|
|
//
|
|
// We turn off error recovery for modules in this test (so we don't get an
|
|
// implicit import of cxx_templates_b_impl), and that results in us producing
|
|
// a big spew of errors here.
|
|
//
|
|
// expected-error@Inputs/cxx-templates-a.h:19 {{definition of 'DefinedInBImpl' must be imported}}
|
|
// expected-note@Inputs/cxx-templates-b-impl.h:1 +{{definition is here}}
|
|
// expected-error@Inputs/cxx-templates-a.h:19 +{{}}
|
|
// expected-error@Inputs/cxx-templates-a.h:20 +{{}}
|
|
PerformDelayedLookup(defined_in_b_impl); // expected-note {{in instantiation of}}
|
|
|
|
merge_templates_a = merge_templates_b; // ok, same type
|
|
|
|
using T = decltype(enum_a_from_a);
|
|
using T = decltype(enum_b_from_b);
|
|
T e = true ? enum_a_from_a : enum_b_from_b;
|
|
|
|
UseRedeclaredEnum<int>(UseInt<1>());
|
|
// FIXME: Reintroduce this once we merge function template specializations.
|
|
//static_assert(UseRedeclaredEnumA == UseRedeclaredEnumB, "");
|
|
//static_assert(UseRedeclaredEnumA == UseRedeclaredEnum<int>, "");
|
|
//static_assert(UseRedeclaredEnumB == UseRedeclaredEnum<int>, "");
|
|
static_assert(enum_c_from_a == enum_c_from_b, "");
|
|
CommonTemplate<int> cti;
|
|
CommonTemplate<int>::E eee = CommonTemplate<int>::c;
|
|
|
|
TemplateInstantiationVisibility<char[1]> tiv1;
|
|
TemplateInstantiationVisibility<char[2]> tiv2;
|
|
TemplateInstantiationVisibility<char[3]> tiv3; // expected-error 5{{must be imported from module 'cxx_templates_b_impl'}}
|
|
// expected-note@cxx-templates-b-impl.h:10 3{{explicit specialization declared here}}
|
|
// expected-note@cxx-templates-b-impl.h:10 2{{previous definition is here}}
|
|
TemplateInstantiationVisibility<char[4]> tiv4;
|
|
|
|
int &p = WithPartialSpecializationUse().f();
|
|
int &q = WithExplicitSpecializationUse().inner_template<int>();
|
|
int *r = PartiallyInstantiatePartialSpec<int*>::bar();
|
|
|
|
(void)&WithImplicitSpecialMembers<int>::n;
|
|
|
|
MergeClassTemplateSpecializations_string s;
|
|
|
|
extern TestInjectedClassName::A *use_a;
|
|
extern TestInjectedClassName::C *use_c;
|
|
TestInjectedClassName::UseD();
|
|
}
|
|
|
|
static_assert(Outer<int>::Inner<int>::f() == 1, "");
|
|
static_assert(Outer<int>::Inner<int>::g() == 2, "");
|
|
|
|
static_assert(MergeTemplateDefinitions<int>::f() == 1, "");
|
|
static_assert(MergeTemplateDefinitions<int>::g() == 2, "");
|
|
|
|
RedeclaredAsFriend<int> raf1;
|
|
RedeclareTemplateAsFriend<double> rtaf;
|
|
RedeclaredAsFriend<double> raf2;
|
|
|
|
MergeSpecializations<int*>::partially_specialized_in_a spec_in_a_1;
|
|
MergeSpecializations<int&>::partially_specialized_in_b spec_in_b_1;
|
|
MergeSpecializations<int[]>::partially_specialized_in_c spec_in_c_1;
|
|
MergeSpecializations<char>::explicitly_specialized_in_a spec_in_a_2;
|
|
MergeSpecializations<double>::explicitly_specialized_in_b spec_in_b_2;
|
|
MergeSpecializations<bool>::explicitly_specialized_in_c spec_in_c_2;
|
|
|
|
MergeAnonUnionMember<> maum_main;
|
|
typedef DontWalkPreviousDeclAfterMerging<int> dwpdam_typedef_2;
|
|
dwpdam_typedef::type dwpdam_typedef_use;
|
|
DontWalkPreviousDeclAfterMerging<int>::Inner::type dwpdam;
|
|
|
|
using AliasTemplateMergingTest = WithAliasTemplate<int>::X<char>;
|
|
|
|
int AnonymousDeclsMergingTest(WithAnonymousDecls<int> WAD, WithAnonymousDecls<char> WADC) {
|
|
return InstantiateWithAnonymousDeclsA(WAD) +
|
|
InstantiateWithAnonymousDeclsB(WAD) +
|
|
InstantiateWithAnonymousDeclsB2(WADC) +
|
|
InstantiateWithAnonymousDeclsD(WADC);
|
|
}
|
|
|
|
@import cxx_templates_common;
|
|
|
|
typedef SomeTemplate<int*> SomeTemplateIntPtr;
|
|
typedef SomeTemplate<int&> SomeTemplateIntRef;
|
|
SomeTemplate<char*> some_template_char_ptr;
|
|
SomeTemplate<char&> some_template_char_ref;
|
|
|
|
void testImplicitSpecialMembers(SomeTemplate<char[1]> &a,
|
|
const SomeTemplate<char[1]> &b,
|
|
SomeTemplate<char[2]> &c,
|
|
const SomeTemplate<char[2]> &d) {
|
|
a = b;
|
|
c = d;
|
|
}
|
|
|
|
bool testFriendInClassTemplate(Std::WithFriend<int> wfi) {
|
|
return wfi != wfi;
|
|
}
|
|
|
|
namespace hidden_specializations {
|
|
// expected-note@cxx-templates-unimported.h:* 1+{{here}}
|
|
void test() {
|
|
// For functions, uses that would trigger instantiations of definitions are
|
|
// not allowed.
|
|
fn<void>(); // ok
|
|
fn<char>(); // ok
|
|
fn<int>(); // expected-error 1+{{explicit specialization of 'fn<int>' must be imported}}
|
|
cls<void>::nested_fn(); // expected-error 1+{{explicit specialization of 'nested_fn' must be imported}}
|
|
cls<void>::nested_fn_t<int>(); // expected-error 1+{{explicit specialization of 'nested_fn_t' must be imported}}
|
|
cls<void>::nested_fn_t<char>(); // expected-error 1+{{explicit specialization of 'nested_fn_t' must be imported}}
|
|
|
|
// For classes, uses that would trigger instantiations of definitions are
|
|
// not allowed.
|
|
cls<void> *k0; // ok
|
|
cls<char> *k1; // ok
|
|
cls<int> *k2; // ok
|
|
cls<int*> *k3; // ok
|
|
cls<void>::nested_cls *nk1; // ok
|
|
cls<void>::nested_cls_t<int> *nk2; // ok
|
|
cls<void>::nested_cls_t<char> *nk3; // ok
|
|
cls<int> uk1; // expected-error 1+{{explicit specialization of 'cls<int>' must be imported}} expected-error 1+{{definition of}}
|
|
cls<int*> uk3; // expected-error 1+{{partial specialization of 'cls<T *>' must be imported}} expected-error 1+{{definition of}}
|
|
cls<char*> uk4; // expected-error 1+{{partial specialization of 'cls<T *>' must be imported}} expected-error 1+{{definition of}}
|
|
cls<void>::nested_cls unk1; // expected-error 1+{{explicit specialization of 'nested_cls' must be imported}} expected-error 1+{{definition of}}
|
|
cls<void>::nested_cls_t<int> unk2; // expected-error 1+{{explicit specialization of 'nested_cls_t' must be imported}} expected-error 1+{{definition of}}
|
|
// expected-error@cxx-templates-unimported.h:29 {{explicit specialization of 'nested_cls_t' must be imported}}
|
|
// expected-note@-2 {{in evaluation of exception specification}}
|
|
cls<void>::nested_cls_t<char> unk3; // expected-error 1+{{explicit specialization of 'nested_cls_t' must be imported}}
|
|
|
|
// For enums, uses that would trigger instantiations of definitions are not
|
|
// allowed.
|
|
cls<void>::nested_enum e; // ok
|
|
(void)cls<void>::nested_enum::e; // expected-error 1+{{definition of 'nested_enum' must be imported}} expected-error 1+{{declaration of 'e'}}
|
|
|
|
// For variable template specializations, no uses are allowed because
|
|
// specializations can change the type.
|
|
(void)sizeof(var<void>); // ok
|
|
(void)sizeof(var<char>); // ok
|
|
(void)sizeof(var<int>); // expected-error 1+{{explicit specialization of 'var<int>' must be imported}}
|
|
(void)sizeof(var<int*>); // expected-error 1+{{partial specialization of 'var<T *>' must be imported}}
|
|
(void)sizeof(var<char*>); // expected-error 1+{{partial specialization of 'var<T *>' must be imported}}
|
|
(void)sizeof(cls<void>::nested_var); // ok
|
|
(void)cls<void>::nested_var; // expected-error 1+{{explicit specialization of 'nested_var' must be imported}}
|
|
(void)sizeof(cls<void>::nested_var_t<int>); // expected-error 1+{{explicit specialization of 'nested_var_t' must be imported}}
|
|
(void)sizeof(cls<void>::nested_var_t<char>); // expected-error 1+{{explicit specialization of 'nested_var_t' must be imported}}
|
|
}
|
|
|
|
void cls<int>::nested_fn() {} // expected-error 1+{{explicit specialization of 'cls<int>' must be imported}} expected-error 1+{{definition of}}
|
|
struct cls<int>::nested_cls {}; // expected-error 1+{{explicit specialization of 'cls<int>' must be imported}} expected-error 1+{{definition of}}
|
|
int cls<int>::nested_var; // expected-error 1+{{explicit specialization of 'cls<int>' must be imported}} expected-error 1+{{definition of}}
|
|
enum cls<int>::nested_enum : int {}; // expected-error 1+{{explicit specialization of 'cls<int>' must be imported}} expected-error 1+{{definition of}}
|
|
|
|
template<typename T> void cls<T*>::nested_fn() {} // expected-error 1+{{partial specialization of 'cls<T *>' must be imported}}
|
|
template<typename T> struct cls<T*>::nested_cls {}; // expected-error 1+{{partial specialization of 'cls<T *>' must be imported}}
|
|
template<typename T> int cls<T*>::nested_var; // expected-error 1+{{partial specialization of 'cls<T *>' must be imported}}
|
|
template<typename T> enum cls<T*>::nested_enum : int {}; // expected-error 1+{{partial specialization of 'cls<T *>' must be imported}}
|
|
}
|
|
|
|
namespace Std {
|
|
void g(); // expected-error {{functions that differ only in their return type cannot be overloaded}}
|
|
// expected-note@cxx-templates-common.h:21 {{previous}}
|
|
}
|
|
|
|
// CHECK-GLOBAL: DeclarationName 'f'
|
|
// CHECK-GLOBAL-NEXT: |-FunctionTemplate {{.*}} 'f'
|
|
// CHECK-GLOBAL-NEXT: |-FunctionTemplate {{.*}} 'f'
|
|
// CHECK-GLOBAL-NEXT: |-FunctionTemplate {{.*}} 'f'
|
|
// CHECK-GLOBAL-NEXT: `-FunctionTemplate {{.*}} 'f'
|
|
|
|
// CHECK-NAMESPACE-N: DeclarationName 'f'
|
|
// CHECK-NAMESPACE-N-NEXT: |-FunctionTemplate {{.*}} 'f'
|
|
// CHECK-NAMESPACE-N-NEXT: |-FunctionTemplate {{.*}} 'f'
|
|
// CHECK-NAMESPACE-N-NEXT: |-FunctionTemplate {{.*}} 'f'
|
|
// CHECK-NAMESPACE-N-NEXT: `-FunctionTemplate {{.*}} 'f'
|
|
|
|
// CHECK-DUMP: ClassTemplateDecl {{.*}} <{{.*[/\\]}}cxx-templates-common.h:1:1, {{.*}}> col:{{.*}} in cxx_templates_common SomeTemplate
|
|
// CHECK-DUMP: ClassTemplateSpecializationDecl {{.*}} prev {{.*}} SomeTemplate
|
|
// CHECK-DUMP-NEXT: TemplateArgument type 'char [2]'
|
|
// CHECK-DUMP: ClassTemplateSpecializationDecl {{.*}} SomeTemplate definition
|
|
// CHECK-DUMP-NEXT: DefinitionData
|
|
// CHECK-DUMP-NEXT: DefaultConstructor
|
|
// CHECK-DUMP-NEXT: CopyConstructor
|
|
// CHECK-DUMP-NEXT: MoveConstructor
|
|
// CHECK-DUMP-NEXT: CopyAssignment
|
|
// CHECK-DUMP-NEXT: MoveAssignment
|
|
// CHECK-DUMP-NEXT: Destructor
|
|
// CHECK-DUMP-NEXT: TemplateArgument type 'char [2]'
|
|
// CHECK-DUMP: ClassTemplateSpecializationDecl {{.*}} prev {{.*}} SomeTemplate
|
|
// CHECK-DUMP-NEXT: TemplateArgument type 'char [1]'
|
|
// CHECK-DUMP: ClassTemplateSpecializationDecl {{.*}} SomeTemplate definition
|
|
// CHECK-DUMP-NEXT: DefinitionData
|
|
// CHECK-DUMP-NEXT: DefaultConstructor
|
|
// CHECK-DUMP-NEXT: CopyConstructor
|
|
// CHECK-DUMP-NEXT: MoveConstructor
|
|
// CHECK-DUMP-NEXT: CopyAssignment
|
|
// CHECK-DUMP-NEXT: MoveAssignment
|
|
// CHECK-DUMP-NEXT: Destructor
|
|
// CHECK-DUMP-NEXT: TemplateArgument type 'char [1]'
|