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-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-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 // RUN: %clang_cc1 -x objective-c++ -fmodules -fno-modules-error-recovery -fmodules-cache-path=%t -I %S/Inputs %s -verify -std=c++11 -DEARLY_IMPORT 7 8 #ifdef EARLY_IMPORT 9 #include "cxx-templates-textual.h" 10 #endif 11 12 @import cxx_templates_a; 13 @import cxx_templates_b; 14 @import cxx_templates_c; 15 @import cxx_templates_d; 16 @import cxx_templates_common; 17 18 template<typename, char> struct Tmpl_T_C {}; 19 template<typename, int, int> struct Tmpl_T_I_I {}; 20 21 template<typename A, typename B, A> struct Tmpl_T_T_A {}; 22 template<typename A, typename B, B> struct Tmpl_T_T_B {}; 23 24 template<int> struct UseInt {}; 25 26 void g() { 27 f(0); 28 f<double>(1.0); 29 f<int>(); 30 f(); // expected-error {{no matching function}} 31 #ifdef EARLY_IMPORT 32 // FIXME: The textual inclusion above shouldn't affect this! 33 // expected-note@Inputs/cxx-templates-a.h:3 {{couldn't infer template argument}} 34 // expected-note@Inputs/cxx-templates-a.h:4 {{requires 1 argument}} 35 #else 36 // expected-note@Inputs/cxx-templates-b.h:3 {{couldn't infer template argument}} 37 // expected-note@Inputs/cxx-templates-b.h:4 {{requires single argument}} 38 #endif 39 40 N::f(0); 41 N::f<double>(1.0); 42 N::f<int>(); 43 N::f(); // expected-error {{no matching function}} 44 // expected-note@Inputs/cxx-templates-b.h:6 {{couldn't infer template argument}} 45 // expected-note@Inputs/cxx-templates-b.h:7 {{requires single argument}} 46 47 template_param_kinds_1<0>(); // ok, from cxx-templates-a.h 48 template_param_kinds_1<int>(); // ok, from cxx-templates-b.h 49 50 template_param_kinds_2<Tmpl_T_C>(); // expected-error {{no matching function}} 51 // expected-note@Inputs/cxx-templates-a.h:11 {{invalid explicitly-specified argument}} 52 // expected-note@Inputs/cxx-templates-b.h:11 {{invalid explicitly-specified argument}} 53 54 template_param_kinds_2<Tmpl_T_I_I>(); // expected-error {{ambiguous}} 55 // expected-note@Inputs/cxx-templates-a.h:11 {{candidate}} 56 // expected-note@Inputs/cxx-templates-b.h:11 {{candidate}} 57 58 // FIXME: This should be valid, but we incorrectly match the template template 59 // argument against both template template parameters. 60 template_param_kinds_3<Tmpl_T_T_A>(); // expected-error {{ambiguous}} 61 // expected-note@Inputs/cxx-templates-a.h:12 {{candidate}} 62 // expected-note@Inputs/cxx-templates-b.h:12 {{candidate}} 63 template_param_kinds_3<Tmpl_T_T_B>(); // expected-error {{ambiguous}} 64 // expected-note@Inputs/cxx-templates-a.h:12 {{candidate}} 65 // expected-note@Inputs/cxx-templates-b.h:12 {{candidate}} 66 67 // Trigger the instantiation of a template in 'a' that uses a type defined in 68 // 'common'. That type is not visible here. 69 PerformDelayedLookup(defined_in_common); 70 71 // Likewise, but via a default argument. 72 PerformDelayedLookupInDefaultArgument(defined_in_common); 73 74 // Trigger the instantiation of a template in 'b' that uses a type defined in 75 // 'b_impl'. That type is not visible here. 76 UseDefinedInBImpl<int>(); 77 78 // Trigger the instantiation of a template in 'a' that uses a type defined in 79 // 'b_impl', via a template defined in 'b'. Since the type is visible from 80 // within 'b', the instantiation succeeds. 81 UseDefinedInBImplIndirectly(defined_in_b_impl); 82 83 // Trigger the instantiation of a template in 'a' that uses a type defined in 84 // 'b_impl'. That type is not visible here, nor in 'a'. This fails; there is 85 // no reason why DefinedInBImpl should be visible here. 86 // 87 // We turn off error recovery for modules in this test (so we don't get an 88 // implicit import of cxx_templates_b_impl), and that results in us producing 89 // a big spew of errors here. 90 // 91 // expected-error@Inputs/cxx-templates-a.h:19 {{definition of 'DefinedInBImpl' must be imported}} 92 // expected-note@Inputs/cxx-templates-b-impl.h:1 +{{definition is here}} 93 // expected-error@Inputs/cxx-templates-a.h:19 +{{}} 94 // expected-error@Inputs/cxx-templates-a.h:20 +{{}} 95 PerformDelayedLookup(defined_in_b_impl); // expected-note {{in instantiation of}} 96 97 merge_templates_a = merge_templates_b; // ok, same type 98 99 using T = decltype(enum_a_from_a); 100 using T = decltype(enum_b_from_b); 101 T e = true ? enum_a_from_a : enum_b_from_b; 102 103 UseRedeclaredEnum<int>(UseInt<1>()); 104 // FIXME: Reintroduce this once we merge function template specializations. 105 //static_assert(UseRedeclaredEnumA == UseRedeclaredEnumB, ""); 106 //static_assert(UseRedeclaredEnumA == UseRedeclaredEnum<int>, ""); 107 //static_assert(UseRedeclaredEnumB == UseRedeclaredEnum<int>, ""); 108 static_assert(enum_c_from_a == enum_c_from_b, ""); 109 CommonTemplate<int> cti; 110 CommonTemplate<int>::E eee = CommonTemplate<int>::c; 111 112 TemplateInstantiationVisibility<char[1]> tiv1; 113 TemplateInstantiationVisibility<char[2]> tiv2; 114 TemplateInstantiationVisibility<char[3]> tiv3; // expected-error {{must be imported from module 'cxx_templates_b_impl'}} 115 // expected-note@cxx-templates-b-impl.h:10 {{previous definition is here}} 116 TemplateInstantiationVisibility<char[4]> tiv4; 117 118 int &p = WithPartialSpecializationUse().f(); 119 int &q = WithExplicitSpecializationUse().inner_template<int>(); 120 int *r = PartiallyInstantiatePartialSpec<int*>::bar(); 121 122 (void)&WithImplicitSpecialMembers<int>::n; 123 124 MergeClassTemplateSpecializations_string s; 125 126 extern TestInjectedClassName::A *use_a; 127 extern TestInjectedClassName::C *use_c; 128 TestInjectedClassName::UseD(); 129 } 130 131 static_assert(Outer<int>::Inner<int>::f() == 1, ""); 132 static_assert(Outer<int>::Inner<int>::g() == 2, ""); 133 134 #ifndef EARLY_IMPORT 135 // FIXME: The textual inclusion above shouldn't cause this to fail! 136 static_assert(MergeTemplateDefinitions<int>::f() == 1, ""); 137 static_assert(MergeTemplateDefinitions<int>::g() == 2, ""); 138 139 RedeclaredAsFriend<int> raf1; 140 RedeclareTemplateAsFriend<double> rtaf; 141 RedeclaredAsFriend<double> raf2; 142 143 MergeSpecializations<int*>::partially_specialized_in_a spec_in_a_1; 144 MergeSpecializations<int&>::partially_specialized_in_b spec_in_b_1; 145 MergeSpecializations<int[]>::partially_specialized_in_c spec_in_c_1; 146 MergeSpecializations<char>::explicitly_specialized_in_a spec_in_a_2; 147 MergeSpecializations<double>::explicitly_specialized_in_b spec_in_b_2; 148 MergeSpecializations<bool>::explicitly_specialized_in_c spec_in_c_2; 149 #endif 150 151 MergeAnonUnionMember<> maum_main; 152 typedef DontWalkPreviousDeclAfterMerging<int> dwpdam_typedef_2; 153 dwpdam_typedef::type dwpdam_typedef_use; 154 DontWalkPreviousDeclAfterMerging<int>::Inner::type dwpdam; 155 156 using AliasTemplateMergingTest = WithAliasTemplate<int>::X<char>; 157 158 int AnonymousDeclsMergingTest(WithAnonymousDecls<int> WAD, WithAnonymousDecls<char> WADC) { 159 return InstantiateWithAnonymousDeclsA(WAD) + 160 InstantiateWithAnonymousDeclsB(WAD) + 161 InstantiateWithAnonymousDeclsB2(WADC) + 162 InstantiateWithAnonymousDeclsD(WADC); 163 } 164 165 @import cxx_templates_common; 166 167 typedef SomeTemplate<int*> SomeTemplateIntPtr; 168 typedef SomeTemplate<int&> SomeTemplateIntRef; 169 SomeTemplate<char*> some_template_char_ptr; 170 SomeTemplate<char&> some_template_char_ref; 171 172 void testImplicitSpecialMembers(SomeTemplate<char[1]> &a, 173 const SomeTemplate<char[1]> &b, 174 SomeTemplate<char[2]> &c, 175 const SomeTemplate<char[2]> &d) { 176 a = b; 177 c = d; 178 } 179 180 bool testFriendInClassTemplate(Std::WithFriend<int> wfi) { 181 return wfi != wfi; 182 } 183 184 namespace Std { 185 void g(); // expected-error {{functions that differ only in their return type cannot be overloaded}} 186 // expected-note@cxx-templates-common.h:21 {{previous}} 187 } 188 189 // CHECK-GLOBAL: DeclarationName 'f' 190 // CHECK-GLOBAL-NEXT: |-FunctionTemplate {{.*}} 'f' 191 // CHECK-GLOBAL-NEXT: `-FunctionTemplate {{.*}} 'f' 192 193 // CHECK-NAMESPACE-N: DeclarationName 'f' 194 // CHECK-NAMESPACE-N-NEXT: |-FunctionTemplate {{.*}} 'f' 195 // CHECK-NAMESPACE-N-NEXT: `-FunctionTemplate {{.*}} 'f' 196 197 // CHECK-DUMP: ClassTemplateDecl {{.*}} <{{.*[/\\]}}cxx-templates-common.h:1:1, {{.*}}> col:{{.*}} in cxx_templates_common SomeTemplate 198 // CHECK-DUMP: ClassTemplateSpecializationDecl {{.*}} prev [[CHAR2:[^ ]*]] {{.*}} SomeTemplate 199 // CHECK-DUMP-NEXT: TemplateArgument type 'char [2]' 200 // CHECK-DUMP: ClassTemplateSpecializationDecl [[CHAR2]] {{.*}} SomeTemplate definition 201 // CHECK-DUMP-NEXT: TemplateArgument type 'char [2]' 202 // CHECK-DUMP: ClassTemplateSpecializationDecl {{.*}} prev [[CHAR1:[^ ]*]] {{.*}} SomeTemplate 203 // CHECK-DUMP-NEXT: TemplateArgument type 'char [1]' 204 // CHECK-DUMP: ClassTemplateSpecializationDecl [[CHAR1]] {{.*}} SomeTemplate definition 205 // CHECK-DUMP-NEXT: TemplateArgument type 'char [1]' 206