1 struct Base1 {
2   int member1;
3   float member2;
4 };
5 
6 struct Base2 {
7   int member1;
8   double member3;
9   void memfun1(int);
10 };
11 
12 struct Base3 : Base1, Base2 {
13   void memfun1(float);
14   void memfun1(double) const;
15   void memfun2(int);
16 };
17 
18 struct Derived : Base3 {
19   int member4;
20   int memfun3(int);
21 };
22 
23 class Proxy {
24 public:
25   Derived *operator->() const;
26 };
27 
28 void test(const Proxy &p) {
29   p->
30 }
31 
32 struct Test1 {
33   Base1 b;
34 
35   static void sfunc() {
36     b. // expected-error {{invalid use of member 'b' in static member function}}
37   }
38 };
39 
40 struct Foo {
41   void foo() const;
42   static void foo(bool);
43 };
44 
45 struct Bar {
46   void foo(bool param) {
47     Foo::foo(  );// unresolved member expression with an implicit base
48   }
49 };
50 
51   // RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:29:6 %s -o - | FileCheck -check-prefix=CHECK-CC1 %s
52   // CHECK-CC1: Base1 : Base1::
53   // CHECK-CC1: member1 : [#int#][#Base1::#]member1
54   // CHECK-CC1: member1 : [#int#][#Base2::#]member1
55   // CHECK-CC1: member2 : [#float#][#Base1::#]member2
56   // CHECK-CC1: member3
57   // CHECK-CC1: member4
58   // CHECK-CC1: memfun1 : [#void#][#Base3::#]memfun1(<#float#>)
59   // CHECK-CC1: memfun1 : [#void#][#Base3::#]memfun1(<#double#>)[# const#]
60   // CHECK-CC1: memfun1 (Hidden) : [#void#]Base2::memfun1(<#int#>)
61   // CHECK-CC1: memfun2 : [#void#][#Base3::#]memfun2(<#int#>)
62   // CHECK-CC1: memfun3 : [#int#]memfun3(<#int#>)
63 
64 // Make sure this doesn't crash
65 // RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:36:7 %s -verify
66 
67 // Make sure this also doesn't crash
68 // RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:47:14 %s
69 
70 
71 template<typename T>
72 class BaseTemplate {
73 public:
74   T baseTemplateFunction();
75 
76   T baseTemplateField;
77 };
78 
79 template<typename T, typename S>
80 class TemplateClass: public Base1 , public BaseTemplate<T> {
81 public:
82   T function() { }
83   T field;
84 
85   void overload1(const T &);
86   void overload1(const S &);
87 };
88 
89 template<typename T, typename S>
90 void completeDependentMembers(TemplateClass<T, S> &object,
91                               TemplateClass<int, S> *object2) {
92   object.field;
93   object2->field;
94 // CHECK-CC2: baseTemplateField : [#T#][#BaseTemplate<T>::#]baseTemplateField
95 // CHECK-CC2: baseTemplateFunction : [#T#][#BaseTemplate<T>::#]baseTemplateFunction()
96 // CHECK-CC2: field : [#T#]field
97 // CHECK-CC2: function : [#T#]function()
98 // CHECK-CC2: member1 : [#int#][#Base1::#]member1
99 // CHECK-CC2: member2 : [#float#][#Base1::#]member2
100 // CHECK-CC2: overload1 : [#void#]overload1(<#const T &#>)
101 // CHECK-CC2: overload1 : [#void#]overload1(<#const S &#>)
102 
103 // RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:92:10 %s -o - | FileCheck -check-prefix=CHECK-CC2 %s
104 // RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:93:12 %s -o - | FileCheck -check-prefix=CHECK-CC2 %s
105 }
106 
107 
108 void completeDependentSpecializedMembers(TemplateClass<int, double> &object,
109                                          TemplateClass<int, double> *object2) {
110   object.field;
111   object2->field;
112 // CHECK-CC3: baseTemplateField : [#int#][#BaseTemplate<int>::#]baseTemplateField
113 // CHECK-CC3: baseTemplateFunction : [#int#][#BaseTemplate<int>::#]baseTemplateFunction()
114 // CHECK-CC3: field : [#int#]field
115 // CHECK-CC3: function : [#int#]function()
116 // CHECK-CC3: member1 : [#int#][#Base1::#]member1
117 // CHECK-CC3: member2 : [#float#][#Base1::#]member2
118 // CHECK-CC3: overload1 : [#void#]overload1(<#const int &#>)
119 // CHECK-CC3: overload1 : [#void#]overload1(<#const double &#>)
120 
121 // RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:110:10 %s -o - | FileCheck -check-prefix=CHECK-CC3 %s
122 // RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:111:12 %s -o - | FileCheck -check-prefix=CHECK-CC3 %s
123 }
124 
125 template <typename T>
126 class Template {
127 public:
128   BaseTemplate<int> o1;
129   BaseTemplate<T> o2;
130 
131   void function() {
132     o1.baseTemplateField;
133 // CHECK-CC4: BaseTemplate : BaseTemplate::
134 // CHECK-CC4: baseTemplateField : [#int#]baseTemplateField
135 // CHECK-CC4: baseTemplateFunction : [#int#]baseTemplateFunction()
136 // RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:132:8 %s -o - | FileCheck -check-prefix=CHECK-CC4 %s
137     o2.baseTemplateField;
138 // CHECK-CC5: BaseTemplate : BaseTemplate::
139 // CHECK-CC5: baseTemplateField : [#T#]baseTemplateField
140 // CHECK-CC5: baseTemplateFunction : [#T#]baseTemplateFunction()
141 // RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:137:8 %s -o - | FileCheck -check-prefix=CHECK-CC5 %s
142     this->o1;
143 // CHECK-CC6: [#void#]function()
144 // CHECK-CC6: o1 : [#BaseTemplate<int>#]o1
145 // CHECK-CC6: o2 : [#BaseTemplate<T>#]o2
146 // RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:142:11 %s -o - | FileCheck -check-prefix=CHECK-CC6 %s
147   }
148 
149   static void staticFn(T &obj);
150 
151   struct Nested { };
152 };
153 
154 template<typename T>
155 void dependentColonColonCompletion() {
156   Template<T>::staticFn();
157 // CHECK-CC7: function : [#void#]function()
158 // CHECK-CC7: Nested : Nested
159 // CHECK-CC7: o1 : [#BaseTemplate<int>#]o1
160 // CHECK-CC7: o2 : [#BaseTemplate<T>#]o2
161 // CHECK-CC7: staticFn : [#void#]staticFn(<#T &obj#>)
162 // CHECK-CC7: Template : Template
163 // RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:156:16 %s -o - | FileCheck -check-prefix=CHECK-CC7 %s
164   typename Template<T>::Nested m;
165 // RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:164:25 %s -o - | FileCheck -check-prefix=CHECK-CC7 %s
166 }
167