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