1 // RUN: %check_clang_tidy %s bugprone-virtual-near-miss %t 2 3 class NoDefinedClass1; 4 class NoDefinedClass2; 5 6 struct Base { 7 virtual void func(); 8 virtual void gunk(); 9 virtual ~Base(); 10 virtual Base &operator=(const Base &); 11 virtual NoDefinedClass1 *f(); 12 }; 13 14 struct Derived : Base { 15 // Should not warn "do you want to override 'gunk'?", because gunk is already 16 // overriden by this class. 17 virtual void funk(); 18 // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: method 'Derived::funk' has a similar name and the same signature as virtual method 'Base::func'; did you mean to override it? [bugprone-virtual-near-miss] 19 // CHECK-FIXES: virtual void func(); 20 21 void func2(); 22 // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: method 'Derived::func2' has {{.*}} 'Base::func' 23 // CHECK-FIXES: void func(); 24 25 void func22(); // Should not warn. 26 27 void gunk(); // Should not warn: gunk is override. 28 29 void fun(); 30 // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: method 'Derived::fun' has {{.*}} 'Base::func' 31 // CHECK-FIXES: void func(); 32 33 Derived &operator==(const Base &); // Should not warn: operators are ignored. 34 35 virtual NoDefinedClass2 *f1(); // Should not crash: non-defined class return type is ignored. 36 }; 37 38 template <typename T> 39 struct TBase { 40 virtual void tfunc(T t); 41 }; 42 43 template <typename T> 44 struct TDerived : TBase<T> { 45 virtual void tfunk(T t); 46 // Should not apply fix for template. 47 // CHECK-MESSAGES: :[[@LINE-2]]:3: warning: method 'TDerived<double>::tfunk' has {{.*}} 'TBase<double>::tfunc' 48 // CHECK-MESSAGES: :[[@LINE-3]]:3: warning: method 'TDerived<int>::tfunk' has {{.*}} 'TBase<int>::tfunc' 49 // CHECK-FIXES: virtual void tfunk(T t); 50 }; 51 52 TDerived<int> T1; 53 TDerived<double> T2; 54 55 // Should not fix macro definition 56 #define MACRO1 void funcM() 57 // CHECK-FIXES: #define MACRO1 void funcM() 58 #define MACRO2(m) void m() 59 // CHECK-FIXES: #define MACRO2(m) void m() 60 61 struct DerivedMacro : Base { 62 MACRO1; 63 // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: method 'DerivedMacro::funcM' has {{.*}} 'Base::func' 64 // CHECK-FIXES: MACRO1; 65 66 MACRO2(func3); 67 // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: method 'DerivedMacro::func3' has {{.*}} 'Base::func' 68 // CHECK-FIXES: MACRO2(func); 69 }; 70 71 typedef Derived derived_type; 72 73 class Father { 74 public: 75 Father(); 76 virtual void func(); 77 virtual Father *create(int i); 78 virtual Base &&generate(); 79 virtual Base *canonical(Derived D); 80 }; 81 82 class Mother { 83 public: 84 Mother(); 85 static void method(); 86 virtual int method(int argc, const char **argv); 87 virtual int method(int argc) const; 88 virtual int decay(const char *str); 89 }; 90 91 class Child : private Father, private Mother { 92 public: 93 Child(); 94 95 virtual void func2(); 96 // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: method 'Child::func2' has {{.*}} 'Father::func' 97 // CHECK-FIXES: virtual void func(); 98 99 int methoe(int x, char **strs); // Should not warn: parameter types don't match. 100 101 int methoe(int x); 102 // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: method 'Child::methoe' has {{.*}} 'Mother::method' 103 // CHECK-FIXES: int method(int x); 104 105 void methof(int x, const char **strs); // Should not warn: return types don't match. 106 107 int methoh(int x, const char **strs); 108 // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: method 'Child::methoh' has {{.*}} 'Mother::method' 109 // CHECK-FIXES: int method(int x, const char **strs); 110 111 virtual Child *creat(int i); 112 // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: method 'Child::creat' has {{.*}} 'Father::create' 113 // CHECK-FIXES: virtual Child *create(int i); 114 115 virtual Derived &&generat(); 116 // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: method 'Child::generat' has {{.*}} 'Father::generate' 117 // CHECK-FIXES: virtual Derived &&generate(); 118 119 int decaz(const char str[]); 120 // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: method 'Child::decaz' has {{.*}} 'Mother::decay' 121 // CHECK-FIXES: int decay(const char str[]); 122 123 operator bool(); 124 125 derived_type *canonica(derived_type D); 126 // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: method 'Child::canonica' has {{.*}} 'Father::canonical' 127 // CHECK-FIXES: derived_type *canonical(derived_type D); 128 129 private: 130 void funk(); 131 // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: method 'Child::funk' has {{.*}} 'Father::func' 132 // CHECK-FIXES: void func(); 133 }; 134