1 // RUN: rm -rf %t 2 // RUN: not %clang_cc1 -x objective-c++ -fmodules -fno-modules-error-recovery -fmodules-cache-path=%t -I %S/Inputs %s -std=c++11 -ast-dump -ast-dump-lookups | FileCheck %s --check-prefix=CHECK-GLOBAL 3 // RUN: not %clang_cc1 -x objective-c++ -fmodules -fno-modules-error-recovery -fmodules-cache-path=%t -I %S/Inputs %s -std=c++11 -ast-dump -ast-dump-lookups -ast-dump-filter N | FileCheck %s --check-prefix=CHECK-NAMESPACE-N 4 // RUN: not %clang_cc1 -x objective-c++ -fmodules -fno-modules-error-recovery -fmodules-cache-path=%t -I %S/Inputs %s -std=c++11 -ast-dump | FileCheck %s --check-prefix=CHECK-DUMP 5 // RUN: %clang_cc1 -x objective-c++ -fmodules -fno-modules-error-recovery -fmodules-cache-path=%t -I %S/Inputs %s -verify -std=c++11 6 7 @import cxx_templates_a; 8 @import cxx_templates_b; 9 @import cxx_templates_c; 10 @import cxx_templates_common; 11 12 template<typename, char> struct Tmpl_T_C {}; 13 template<typename, int, int> struct Tmpl_T_I_I {}; 14 15 template<typename A, typename B, A> struct Tmpl_T_T_A {}; 16 template<typename A, typename B, B> struct Tmpl_T_T_B {}; 17 18 template<int> struct UseInt {}; 19 20 void g() { 21 f(0); 22 f<double>(1.0); 23 f<int>(); 24 f(); // expected-error {{no matching function}} 25 // expected-note@Inputs/cxx-templates-b.h:3 {{couldn't infer template argument}} 26 // expected-note@Inputs/cxx-templates-b.h:4 {{requires single argument}} 27 28 N::f(0); 29 N::f<double>(1.0); 30 N::f<int>(); 31 N::f(); // expected-error {{no matching function}} 32 // expected-note@Inputs/cxx-templates-a.h:6 {{couldn't infer template argument}} 33 // expected-note@Inputs/cxx-templates-a.h:7 {{requires 1 argument}} 34 35 template_param_kinds_1<0>(); // ok, from cxx-templates-a.h 36 template_param_kinds_1<int>(); // ok, from cxx-templates-b.h 37 38 template_param_kinds_2<Tmpl_T_C>(); // expected-error {{no matching function}} 39 // expected-note@Inputs/cxx-templates-a.h:11 {{invalid explicitly-specified argument}} 40 // expected-note@Inputs/cxx-templates-b.h:11 {{invalid explicitly-specified argument}} 41 42 template_param_kinds_2<Tmpl_T_I_I>(); // expected-error {{ambiguous}} 43 // expected-note@Inputs/cxx-templates-a.h:11 {{candidate}} 44 // expected-note@Inputs/cxx-templates-b.h:11 {{candidate}} 45 46 // FIXME: This should be valid, but we incorrectly match the template template 47 // argument against both template template parameters. 48 template_param_kinds_3<Tmpl_T_T_A>(); // expected-error {{ambiguous}} 49 // expected-note@Inputs/cxx-templates-a.h:12 {{candidate}} 50 // expected-note@Inputs/cxx-templates-b.h:12 {{candidate}} 51 template_param_kinds_3<Tmpl_T_T_B>(); // expected-error {{ambiguous}} 52 // expected-note@Inputs/cxx-templates-a.h:12 {{candidate}} 53 // expected-note@Inputs/cxx-templates-b.h:12 {{candidate}} 54 55 // Trigger the instantiation of a template in 'a' that uses a type defined in 56 // 'common'. That type is not visible here. 57 PerformDelayedLookup(defined_in_common); 58 59 // Likewise, but via a default argument. 60 PerformDelayedLookupInDefaultArgument(defined_in_common); 61 62 // Trigger the instantiation of a template in 'b' that uses a type defined in 63 // 'b_impl'. That type is not visible here. 64 UseDefinedInBImpl<int>(); 65 66 // Trigger the instantiation of a template in 'a' that uses a type defined in 67 // 'b_impl', via a template defined in 'b'. Since the type is visible from 68 // within 'b', the instantiation succeeds. 69 UseDefinedInBImplIndirectly(defined_in_b_impl); 70 71 // Trigger the instantiation of a template in 'a' that uses a type defined in 72 // 'b_impl'. That type is not visible here, nor in 'a'. This fails; there is 73 // no reason why DefinedInBImpl should be visible here. 74 // 75 // We turn off error recovery for modules in this test (so we don't get an 76 // implicit import of cxx_templates_b_impl), and that results in us producing 77 // a big spew of errors here. 78 // 79 // expected-error@Inputs/cxx-templates-a.h:19 {{definition of 'DefinedInBImpl' must be imported}} 80 // expected-note@Inputs/cxx-templates-b-impl.h:1 +{{definition is here}} 81 // expected-error@Inputs/cxx-templates-a.h:19 +{{}} 82 // expected-error@Inputs/cxx-templates-a.h:20 +{{}} 83 PerformDelayedLookup(defined_in_b_impl); // expected-note {{in instantiation of}} 84 85 merge_templates_a = merge_templates_b; // ok, same type 86 87 using T = decltype(enum_a_from_a); 88 using T = decltype(enum_b_from_b); 89 T e = true ? enum_a_from_a : enum_b_from_b; 90 91 UseRedeclaredEnum<int>(UseInt<1>()); 92 // FIXME: Reintroduce this once we merge function template specializations. 93 //static_assert(UseRedeclaredEnumA == UseRedeclaredEnumB, ""); 94 //static_assert(UseRedeclaredEnumA == UseRedeclaredEnum<int>, ""); 95 //static_assert(UseRedeclaredEnumB == UseRedeclaredEnum<int>, ""); 96 static_assert(enum_c_from_a == enum_c_from_b, ""); 97 CommonTemplate<int> cti; 98 CommonTemplate<int>::E eee = CommonTemplate<int>::c; 99 100 TemplateInstantiationVisibility<char[1]> tiv1; 101 TemplateInstantiationVisibility<char[2]> tiv2; 102 TemplateInstantiationVisibility<char[3]> tiv3; // expected-error {{must be imported from module 'cxx_templates_b_impl'}} 103 // expected-note (at) cxx-templates-b-impl.h:10 {{previous definition is here}} 104 TemplateInstantiationVisibility<char[4]> tiv4; 105 106 int &p = WithPartialSpecializationUse().f(); 107 int &q = WithExplicitSpecializationUse().inner_template<int>(); 108 } 109 110 RedeclaredAsFriend<int> raf1; 111 RedeclareTemplateAsFriend<double> rtaf; 112 RedeclaredAsFriend<double> raf2; 113 114 MergeSpecializations<int*>::partially_specialized_in_a spec_in_a_1; 115 MergeSpecializations<int&>::partially_specialized_in_b spec_in_b_1; 116 MergeSpecializations<int[]>::partially_specialized_in_c spec_in_c_1; 117 MergeSpecializations<char>::explicitly_specialized_in_a spec_in_a_2; 118 MergeSpecializations<double>::explicitly_specialized_in_b spec_in_b_2; 119 MergeSpecializations<bool>::explicitly_specialized_in_c spec_in_c_2; 120 121 @import cxx_templates_common; 122 123 typedef SomeTemplate<int*> SomeTemplateIntPtr; 124 typedef SomeTemplate<int&> SomeTemplateIntRef; 125 SomeTemplate<char*> some_template_char_ptr; 126 SomeTemplate<char&> some_template_char_ref; 127 128 void testImplicitSpecialMembers(SomeTemplate<char[1]> &a, 129 const SomeTemplate<char[1]> &b, 130 SomeTemplate<char[2]> &c, 131 const SomeTemplate<char[2]> &d) { 132 a = b; 133 c = d; 134 } 135 136 bool testFriendInClassTemplate(Std::WithFriend<int> wfi) { 137 return wfi != wfi; 138 } 139 140 namespace Std { 141 void g(); // expected-error {{functions that differ only in their return type cannot be overloaded}} 142 // expected-note (at) cxx-templates-common.h:21 {{previous}} 143 } 144 145 // CHECK-GLOBAL: DeclarationName 'f' 146 // CHECK-GLOBAL-NEXT: |-FunctionTemplate {{.*}} 'f' 147 // CHECK-GLOBAL-NEXT: `-FunctionTemplate {{.*}} 'f' 148 149 // CHECK-NAMESPACE-N: DeclarationName 'f' 150 // CHECK-NAMESPACE-N-NEXT: |-FunctionTemplate {{.*}} 'f' 151 // CHECK-NAMESPACE-N-NEXT: `-FunctionTemplate {{.*}} 'f' 152 153 // CHECK-DUMP: ClassTemplateDecl {{.*}} <{{.*[/\\]}}cxx-templates-common.h:1:1, {{.*}}> col:{{.*}} in cxx_templates_common SomeTemplate 154 // CHECK-DUMP: ClassTemplateSpecializationDecl {{.*}} prev [[CHAR2:[^ ]*]] {{.*}} SomeTemplate 155 // CHECK-DUMP-NEXT: TemplateArgument type 'char [2]' 156 // CHECK-DUMP: ClassTemplateSpecializationDecl [[CHAR2]] {{.*}} SomeTemplate definition 157 // CHECK-DUMP-NEXT: TemplateArgument type 'char [2]' 158 // CHECK-DUMP: ClassTemplateSpecializationDecl {{.*}} prev [[CHAR1:[^ ]*]] {{.*}} SomeTemplate 159 // CHECK-DUMP-NEXT: TemplateArgument type 'char [1]' 160 // CHECK-DUMP: ClassTemplateSpecializationDecl [[CHAR1]] {{.*}} SomeTemplate definition 161 // CHECK-DUMP-NEXT: TemplateArgument type 'char [1]' 162
