[cfe-commits] r128394 - /cfe/trunk/test/SemaCXX/uninitialized.cpp

[Chandler Carruth]

Author: chandlerc
Date: Sun Mar 27 15:35:59 2011
New Revision: 128394

URL: http://llvm.org/viewvc/llvm-project?rev=128394&view=rev
Log:
Add tests for the uninitialized checks added in r128376. Also clean up
and flesh out the existing uninitialized testing for field initializers.

The tests come from Richard's original patch, but I've cleaned them up
a bit and ordered them more naturally.

Also, I added a test for the most simple base case:
int x = x;

And it turns out we miss this one! =[ That and another bad FIXME on the
field initializer checking are left in the test.

Modified:
    cfe/trunk/test/SemaCXX/uninitialized.cpp

Modified: cfe/trunk/test/SemaCXX/uninitialized.cpp
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/test/SemaCXX/uninitialized.cpp?rev=128394&r1=128393&r2=128394&view=diff
==============================================================================
--- cfe/trunk/test/SemaCXX/uninitialized.cpp (original)
+++ cfe/trunk/test/SemaCXX/uninitialized.cpp Sun Mar 27 15:35:59 2011
@@ -1,14 +1,45 @@
 // RUN: %clang_cc1 -fsyntax-only -Wall -Wuninitialized -verify %s
 
-// Previously this triggered a warning on the sizeof(fieldB), indicating
-// a use of an uninitialized value.
-class Rdar8610363_A {
-  int fieldA;
-public:
-  Rdar8610363_A(int a); 
-};
-class Rdar8610363_B {
-  Rdar8610363_A fieldB;
-public:
-  Rdar8610363_B(int b) : fieldB(sizeof(fieldB)) {} // no-warning
+int foo(int x);
+int bar(int* x);
+int boo(int& x);
+int far(const int& x);
+
+// Test self-references within initializers which are guaranteed to be
+// uninitialized.
+int a = a; // FIXME: This doesn't warn!? Seems it doesn't cast 'a' to an RValue.
+int b = b + 1; // expected-warning {{variable 'b' is uninitialized when used within its own initialization}}
+int c = (c + c); // expected-warning 2 {{variable 'c' is uninitialized when used within its own initialization}}
+void test() {
+  int d = ({ d + d ;}); // expected-warning 2 {{variable 'd' is uninitialized when used within its own initialization}}
+}
+int e = static_cast<long>(e) + 1; // expected-warning {{variable 'e' is uninitialized when used within its own initialization}}
+int f = foo(f); // expected-warning {{variable 'f' is uninitialized when used within its own initialization}}
+
+// Thes don't warn as they don't require the value.
+int g = sizeof(g);
+void* ptr = &ptr;
+int h = bar(&h);
+int i = boo(i);
+int j = far(j);
+int k = __alignof__(k);
+
+// Also test similar constructs in a field's initializer.
+struct S {
+  int x;
+  void *ptr;
+
+  S(bool (*)[1]) : x(x) {} // expected-warning {{field is uninitialized when used here}}
+  S(bool (*)[2]) : x(x + 1) {} // expected-warning {{field is uninitialized when used here}}
+  S(bool (*)[3]) : x(x + x) {} // expected-warning {{field is uninitialized when used here}}
+  S(bool (*)[4]) : x(static_cast<long>(x) + 1) {} // expected-warning {{field is uninitialized when used here}}
+  S(bool (*)[5]) : x(foo(x)) {} // FIXME: This should warn!
+
+  // These don't actually require the value of x and so shouldn't warn.
+  S(char (*)[1]) : x(sizeof(x)) {} // rdar://8610363
+  S(char (*)[2]) : ptr(&ptr) {}
+  S(char (*)[3]) : x(__alignof__(x)) {}
+  S(char (*)[4]) : x(bar(&x)) {}
+  S(char (*)[5]) : x(boo(x)) {}
+  S(char (*)[6]) : x(far(x)) {}
 };