1// RUN: %clang_cc1 -fsyntax-only -Woverloaded-virtual -verify %s
2
3struct B1 {
4  virtual void foo(int); // expected-note {{declared here}}
5  virtual void foo(); // expected-note {{declared here}}
6};
7
8struct S1 : public B1 {
9  void foo(float); // expected-warning {{hides overloaded virtual functions}}
10};
11
12struct S2 : public B1 {
13  void foo(); // expected-note {{declared here}}
14};
15
16struct B2 {
17  virtual void foo(void*); // expected-note {{declared here}}
18};
19
20struct MS1 : public S2, public B2 {
21   virtual void foo(int); // expected-warning {{hides overloaded virtual functions}}
22};
23
24struct B3 {
25  virtual void foo(int);
26  virtual void foo();
27};
28
29struct S3 : public B3 {
30  using B3::foo;
31  void foo(float);
32};
33
34struct B4 {
35  virtual void foo();
36};
37
38struct S4 : public B4 {
39  void foo(float);
40  void foo();
41};
42
43namespace PR9182 {
44struct Base {
45  virtual void foo(int);
46};
47
48void Base::foo(int) { }
49
50struct Derived : public Base {
51  virtual void foo(int);
52  void foo(int, int);
53};
54}
55
56namespace PR9396 {
57class A {
58public:
59  virtual void f(int) {}
60};
61
62class B : public A {
63public:
64  static void f() {}
65};
66}
67
68namespace ThreeLayer {
69struct A {
70  virtual void f();
71};
72
73struct B: A {
74  void f();
75  void f(int);
76};
77
78struct C: B {
79  void f(int);
80  using A::f;
81};
82}
83
84namespace UnbalancedVirtual {
85struct Base {
86  virtual void func();
87};
88
89struct Derived1: virtual Base {
90  virtual void func();
91};
92
93struct Derived2: virtual Base {
94};
95
96struct MostDerived: Derived1, Derived2 {
97  void func(int);
98  void func();
99};
100}
101
102namespace UnbalancedVirtual2 {
103struct Base {
104  virtual void func();
105};
106
107struct Derived1: virtual Base {
108  virtual void func();
109};
110
111struct Derived2: virtual Base {
112};
113
114struct Derived3: Derived1 {
115  virtual void func();
116};
117
118struct MostDerived: Derived3, Derived2 {
119  void func(int);
120  void func();
121};
122}
123
124namespace {
125  class A {
126    virtual int foo(bool) const;
127    // expected-note@-1{{type mismatch at 1st parameter ('bool' vs 'int')}}
128    virtual int foo(int, int) const;
129    // expected-note@-1{{different number of parameters (2 vs 1)}}
130    virtual int foo(int*) const;
131    // expected-note@-1{{type mismatch at 1st parameter ('int *' vs 'int')}}
132    virtual int foo(int) volatile;
133    // expected-note@-1{{different qualifiers (volatile vs const)}}
134  };
135
136  class B : public A {
137    virtual int foo(int) const;
138    // expected-warning@-1{{hides overloaded virtual functions}}
139  };
140}
141