xref: /llvm-project/clang/test/SemaCXX/self-comparison.cpp (revision 79e43eb3e20484bdb6f32eecc336742dd721fcc9)
1 // RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++2a
2 // RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++2a -fexperimental-new-constant-interpreter
3 
foo(int x)4 int foo(int x) {
5   return x == x; // expected-warning {{self-comparison always evaluates to true}}
6 }
7 
8 struct X {
9   bool operator==(const X &x) const;
10 };
11 
12 struct A {
13   int x;
14   X x2;
15   int a[3];
16   int b[3];
fA17   bool f() { return x == x; } // expected-warning {{self-comparison always evaluates to true}}
gA18   bool g() { return x2 == x2; } // no-warning
hA19   bool h() { return a == b; } // expected-warning {{array comparison always evaluates to false}} expected-warning {{deprecated}}
iA20   bool i() {
21     int c[3];
22     return a == c; // expected-warning {{array comparison always evaluates to false}} expected-warning {{deprecated}}
23   }
24 };
25 
26 namespace NA { extern "C" int x[3]; }
27 namespace NB { extern "C" int x[3]; }
28 bool k = NA::x == NB::x; // expected-warning {{self-comparison always evaluates to true}} expected-warning {{deprecated}}
29 
30 template<typename T> struct Y { static inline int n; };
f()31 bool f() {
32   return
33     Y<int>::n == Y<int>::n || // expected-warning {{self-comparison always evaluates to true}}
34     Y<void>::n == Y<int>::n;
35 }
36 template<typename T, typename U>
g()37 bool g() {
38   // FIXME: Ideally we'd produce a self-comparison warning on the first of these.
39   return
40     Y<T>::n == Y<T>::n ||
41     Y<T>::n == Y<U>::n;
42 }
43 template bool g<int, int>(); // should not produce any warnings
44 
45 namespace member_tests {
46 struct B {
47   int field;
48   static int static_field;
testmember_tests::B49   int test(B b) {
50     return field == field;  // expected-warning {{self-comparison always evaluates to true}}
51     return static_field == static_field;  // expected-warning {{self-comparison always evaluates to true}}
52     return static_field == b.static_field;  // expected-warning {{self-comparison always evaluates to true}}
53     return B::static_field == this->static_field;  // expected-warning {{self-comparison always evaluates to true}}
54     return this == this;  // expected-warning {{self-comparison always evaluates to true}}
55 
56     return field == b.field;
57     return this->field == b.field;
58   }
59 };
60 
61 enum {
62   I0,
63   I1,
64   I2,
65 };
66 
67 struct S {
68   int field;
69   static int static_field;
70   int array[4];
71 };
72 
73 struct T {
74   int field;
75   static int static_field;
76   int array[4];
77   S s;
78 };
79 
struct_test(S s1,S s2,S * s3,T t)80 int struct_test(S s1, S s2, S *s3, T t) {
81   return s1.field == s1.field;  // expected-warning {{self-comparison always evaluates to true}}
82   return s2.field == s2.field;  // expected-warning {{self-comparison always evaluates to true}}
83   return s1.static_field == s2.static_field;  // expected-warning {{self-comparison always evaluates to true}}
84   return S::static_field == s1.static_field;  // expected-warning {{self-comparison always evaluates to true}}
85   return s1.array == s1.array;  // expected-warning {{self-comparison always evaluates to true}} expected-warning {{deprecated}}
86   return t.s.static_field == S::static_field;  // expected-warning {{self-comparison always evaluates to true}}
87   return s3->field == s3->field;  // expected-warning {{self-comparison always evaluates to true}}
88   return s3->static_field == S::static_field;  // expected-warning {{self-comparison always evaluates to true}}
89   return s1.array[0] == s1.array[0];  // expected-warning {{self-comparison always evaluates to true}}
90   return s1.array[0] == s1.array[0ull];  // expected-warning {{self-comparison always evaluates to true}}
91   return s1.array[I1] == s1.array[I1];  // expected-warning {{self-comparison always evaluates to true}}
92   return s1.array[s2.array[0]] == s1.array[s2.array[0]];  // expected-warning {{self-comparison always evaluates to true}}
93   return s3->array[t.field] == s3->array[t.field];  // expected-warning {{self-comparison always evaluates to true}}
94 
95   // Try all operators
96   return t.field == t.field;  // expected-warning {{self-comparison always evaluates to true}}
97   return t.field <= t.field;  // expected-warning {{self-comparison always evaluates to true}}
98   return t.field >= t.field;  // expected-warning {{self-comparison always evaluates to true}}
99 
100   return t.field != t.field;  // expected-warning {{self-comparison always evaluates to false}}
101   return t.field < t.field;  // expected-warning {{self-comparison always evaluates to false}}
102   return t.field > t.field;  // expected-warning {{self-comparison always evaluates to false}}
103 
104   // no warning
105   return s1.field == s2.field;
106   return s2.array == s1.array; // FIXME: This always evaluates to false. expected-warning {{deprecated}}
107   return s2.array[0] == s1.array[0];
108   return s1.array[I1] == s1.array[I2];
109 
110   return s1.static_field == t.static_field;
111 };
112 
113 struct U {
114   bool operator!=(const U&);
115 };
116 
117 bool operator==(const U&, const U&);
118 
119 // May want to warn on this in the future.
user_defined(U u)120 int user_defined(U u) {
121   return u == u;
122   return u != u;
123 }
124 
125 } // namespace member_tests
126