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
12template<typename, char> struct Tmpl_T_C {};
13template<typename, int, int> struct Tmpl_T_I_I {};
14
15template<typename A, typename B, A> struct Tmpl_T_T_A {};
16template<typename A, typename B, B> struct Tmpl_T_T_B {};
17
18template<int> struct UseInt {};
19
20void 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@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
110RedeclaredAsFriend<int> raf1;
111RedeclareTemplateAsFriend<double> rtaf;
112RedeclaredAsFriend<double> raf2;
113
114MergeSpecializations<int*>::partially_specialized_in_a spec_in_a_1;
115MergeSpecializations<int&>::partially_specialized_in_b spec_in_b_1;
116MergeSpecializations<int[]>::partially_specialized_in_c spec_in_c_1;
117MergeSpecializations<char>::explicitly_specialized_in_a spec_in_a_2;
118MergeSpecializations<double>::explicitly_specialized_in_b spec_in_b_2;
119MergeSpecializations<bool>::explicitly_specialized_in_c spec_in_c_2;
120
121@import cxx_templates_common;
122
123typedef SomeTemplate<int*> SomeTemplateIntPtr;
124typedef SomeTemplate<int&> SomeTemplateIntRef;
125SomeTemplate<char*> some_template_char_ptr;
126SomeTemplate<char&> some_template_char_ref;
127
128void 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
136bool testFriendInClassTemplate(Std::WithFriend<int> wfi) {
137  return wfi != wfi;
138}
139
140namespace Std {
141  void g(); // expected-error {{functions that differ only in their return type cannot be overloaded}}
142  // expected-note@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