llvm-project/clang/test/SemaCXX/scope-check.cpp
Richard Smith ef6c43dc0c Refactor checking of switch conditions and case values.
Check each case value in turn while parsing it, performing the
conversion to the switch type within the context of the expression
itself. This will become necessary in order to properly handle cleanups
for temporaries created as part of the case label (in an upcoming
patch). For now it's just good hygiene.

This necessitates moving the checking for the switch condition itself to
earlier, so that the destination type is available when checking the
case labels.

As a nice side-effect, we get slightly improved diagnostic quality and
error recovery by separating the case expression checking from the case
statement checking and from tracking whether there are discarded case
labels.

llvm-svn: 338056
2018-07-26 18:41:30 +00:00

632 lines
14 KiB
C++

// RUN: %clang_cc1 -triple x86_64-windows -fsyntax-only -verify -fblocks -fcxx-exceptions -fms-extensions %s -Wno-unreachable-code
// RUN: %clang_cc1 -triple x86_64-windows -fsyntax-only -verify -fblocks -fcxx-exceptions -fms-extensions -std=gnu++11 %s -Wno-unreachable-code
namespace testInvalid {
Invalid inv; // expected-error {{unknown type name}}
// Make sure this doesn't assert.
void fn()
{
int c = 0;
if (inv)
Here: ;
goto Here;
}
}
namespace test0 {
struct D { ~D(); };
int f(bool b) {
if (b) {
D d;
goto end;
}
end:
return 1;
}
}
namespace test1 {
struct C { C(); };
int f(bool b) {
if (b)
goto foo; // expected-error {{cannot jump}}
C c; // expected-note {{jump bypasses variable initialization}}
foo:
return 1;
}
}
namespace test2 {
struct C { C(); };
int f(void **ip) {
static void *ips[] = { &&lbl1, &&lbl2 };
C c;
goto *ip;
lbl1:
return 0;
lbl2:
return 1;
}
}
namespace test3 {
struct C { C(); };
int f(void **ip) {
static void *ips[] = { &&lbl1, &&lbl2 };
goto *ip;
lbl1: {
C c;
return 0;
}
lbl2:
return 1;
}
}
namespace test4 {
struct C { C(); };
struct D { ~D(); };
int f(void **ip) {
static void *ips[] = { &&lbl1, &&lbl2 };
C c0;
goto *ip; // expected-error {{cannot jump}}
C c1; // expected-note {{jump bypasses variable initialization}}
lbl1: // expected-note {{possible target of indirect goto}}
return 0;
lbl2:
return 1;
}
}
namespace test5 {
struct C { C(); };
struct D { ~D(); };
int f(void **ip) {
static void *ips[] = { &&lbl1, &&lbl2 };
C c0;
goto *ip;
lbl1: // expected-note {{possible target of indirect goto}}
return 0;
lbl2:
if (ip[1]) {
D d; // expected-note {{jump exits scope of variable with non-trivial destructor}}
ip += 2;
goto *ip; // expected-error {{cannot jump}}
}
return 1;
}
}
namespace test6 {
struct C { C(); };
unsigned f(unsigned s0, unsigned s1, void **ip) {
static void *ips[] = { &&lbl1, &&lbl2, &&lbl3, &&lbl4 };
C c0;
goto *ip;
lbl1:
s0++;
goto *++ip;
lbl2:
s0 -= s1;
goto *++ip;
lbl3: {
unsigned tmp = s0;
s0 = s1;
s1 = tmp;
goto *++ip;
}
lbl4:
return s0;
}
}
// C++0x says it's okay to skip non-trivial initializers on static
// locals, and we implement that in '03 as well.
namespace test7 {
struct C { C(); };
void test() {
goto foo;
static C c;
foo:
return;
}
}
// PR7789
namespace test8 {
void test1(int c) {
switch (c) {
case 0:
int x = 56; // expected-note {{jump bypasses variable initialization}}
case 1: // expected-error {{cannot jump}}
x = 10;
}
}
void test2() {
goto l2; // expected-error {{cannot jump}}
l1: int x = 5; // expected-note {{jump bypasses variable initialization}}
l2: x++;
}
}
namespace test9 {
struct S { int i; };
void test1() {
goto foo;
S s;
foo:
return;
}
unsigned test2(unsigned x, unsigned y) {
switch (x) {
case 2:
S s;
if (y > 42) return x + y;
default:
return x - 2;
}
}
}
// http://llvm.org/PR10462
namespace PR10462 {
enum MyEnum {
something_valid,
something_invalid
};
bool recurse() {
MyEnum K;
switch (K) { // do not warn that 'something_invalid' is not listed;
// 'what_am_i_thinking' might have been intended to be that case.
case something_valid:
case what_am_i_thinking: // expected-error {{use of undeclared identifier}}
int *X = 0;
if (recurse()) {
}
break;
}
}
}
namespace test10 {
int test() {
static void *ps[] = { &&a0 };
goto *&&a0; // expected-error {{cannot jump}}
int a = 3; // expected-note {{jump bypasses variable initialization}}
a0:
return 0;
}
}
// pr13812
namespace test11 {
struct C {
C(int x);
~C();
};
void f(void **ip) {
static void *ips[] = { &&l0 };
l0: // expected-note {{possible target of indirect goto}}
C c0 = 42; // expected-note {{jump exits scope of variable with non-trivial destructor}}
goto *ip; // expected-error {{cannot jump}}
}
}
namespace test12 {
struct C {
C(int x);
~C();
};
void f(void **ip) {
static void *ips[] = { &&l0 };
const C c0 = 17;
l0: // expected-note {{possible target of indirect goto}}
const C &c1 = 42; // expected-note {{jump exits scope of lifetime-extended temporary with non-trivial destructor}}
const C &c2 = c0;
goto *ip; // expected-error {{cannot jump}}
}
}
namespace test13 {
struct C {
C(int x);
~C();
int i;
};
void f(void **ip) {
static void *ips[] = { &&l0 };
l0: // expected-note {{possible target of indirect goto}}
const int &c1 = C(1).i; // expected-note {{jump exits scope of lifetime-extended temporary with non-trivial destructor}}
goto *ip; // expected-error {{cannot jump}}
}
}
namespace test14 {
struct C {
C(int x);
~C();
operator int&() const;
};
void f(void **ip) {
static void *ips[] = { &&l0 };
l0:
// no warning since the C temporary is destructed before the goto.
const int &c1 = C(1);
goto *ip;
}
}
// PR14225
namespace test15 {
void f1() try {
goto x; // expected-error {{cannot jump}}
} catch(...) { // expected-note {{jump bypasses initialization of catch block}}
x: ;
}
void f2() try { // expected-note {{jump bypasses initialization of try block}}
x: ;
} catch(...) {
goto x; // expected-error {{cannot jump}}
}
}
namespace test16 {
struct S { int n; };
int f() {
goto x; // expected-error {{cannot jump}}
const S &s = S(); // expected-note {{jump bypasses variable initialization}}
x: return s.n;
}
}
#if __cplusplus >= 201103L
namespace test17 {
struct S { int get(); private: int n; };
int f() {
goto x; // expected-error {{cannot jump}}
S s = {}; // expected-note {{jump bypasses variable initialization}}
x: return s.get();
}
}
#endif
namespace test18 {
struct A { ~A(); };
struct B { const int &r; const A &a; };
int f() {
void *p = &&x;
const A a = A();
x:
B b = { 0, a }; // ok
goto *p;
}
int g() {
void *p = &&x;
x: // expected-note {{possible target of indirect goto}}
B b = { 0, A() }; // expected-note {{jump exits scope of lifetime-extended temporary with non-trivial destructor}}
goto *p; // expected-error {{cannot jump}}
}
}
#if __cplusplus >= 201103L
namespace std {
typedef decltype(sizeof(int)) size_t;
template<typename T> struct initializer_list {
const T *begin;
size_t size;
initializer_list(const T *, size_t);
};
}
namespace test19 {
struct A { ~A(); };
int f() {
void *p = &&x;
A a;
x: // expected-note {{possible target of indirect goto}}
std::initializer_list<A> il = { a }; // expected-note {{jump exits scope of lifetime-extended temporary with non-trivial destructor}}
goto *p; // expected-error {{cannot jump}}
}
}
namespace test20 {
struct A { ~A(); };
struct B {
const A &a;
};
int f() {
void *p = &&x;
A a;
x:
std::initializer_list<B> il = {
a,
a
};
goto *p;
}
int g() {
void *p = &&x;
A a;
x: // expected-note {{possible target of indirect goto}}
std::initializer_list<B> il = {
a,
{ A() } // expected-note {{jump exits scope of lifetime-extended temporary with non-trivial destructor}}
};
goto *p; // expected-error {{cannot jump}}
}
}
#endif
namespace test21 {
template<typename T> void f() {
goto x; // expected-error {{cannot jump}}
T t; // expected-note {{bypasses}}
x: return;
}
template void f<int>();
struct X { ~X(); };
template void f<X>(); // expected-note {{instantiation of}}
}
namespace PR18217 {
typedef int *X;
template <typename T>
class MyCl {
T mem;
};
class Source {
MyCl<X> m;
public:
int getKind() const;
};
bool b;
template<typename TT>
static void foo(const Source &SF, MyCl<TT *> Source::*m) {
switch (SF.getKind()) {
case 1: return;
case 2: break;
case 3:
case 4: return;
};
if (b) {
auto &y = const_cast<MyCl<TT *> &>(SF.*m); // expected-warning 0-1{{extension}}
}
}
int Source::getKind() const {
foo(*this, &Source::m);
return 0;
}
}
namespace test_recovery {
// Test that jump scope checking recovers when there are unspecified errors
// in the function declaration or body.
void test(nexist, int c) { // expected-error {{}}
nexist_fn(); // expected-error {{}}
goto nexist_label; // expected-error {{use of undeclared label}}
goto a0; // expected-error {{cannot jump}}
int a = 0; // expected-note {{jump bypasses variable initialization}}
a0:;
switch (c) {
case $: // expected-error {{}}
case 0:
int x = 56; // expected-note {{jump bypasses variable initialization}}
case 1: // expected-error {{cannot jump}}
x = 10;
}
}
}
namespace seh {
// Jumping into SEH try blocks is not permitted.
void jump_into_except() {
goto into_try_except_try; // expected-error {{cannot jump from this goto statement to its label}}
__try { // expected-note {{jump bypasses initialization of __try block}}
into_try_except_try:
;
} __except(0) {
}
goto into_try_except_except; // expected-error {{cannot jump from this goto statement to its label}}
__try {
} __except(0) { // expected-note {{jump bypasses initialization of __except block}}
into_try_except_except:
;
}
}
void jump_into_finally() {
goto into_try_except_try; // expected-error {{cannot jump from this goto statement to its label}}
__try { // expected-note {{jump bypasses initialization of __try block}}
into_try_except_try:
;
} __finally {
}
goto into_try_except_finally; // expected-error {{cannot jump from this goto statement to its label}}
__try {
} __finally { // expected-note {{jump bypasses initialization of __finally block}}
into_try_except_finally:
;
}
}
// Jumping out of SEH try blocks ok in general. (Jumping out of a __finally
// has undefined behavior.)
void jump_out_of_except() {
__try {
goto out_of_except_try;
} __except(0) {
}
out_of_except_try:
;
__try {
} __except(0) {
goto out_of_except_except;
}
out_of_except_except:
;
}
void jump_out_of_finally() {
__try {
goto out_of_finally_try;
} __finally {
}
out_of_finally_try:
;
__try {
} __finally {
goto out_of_finally_finally; // expected-warning {{jump out of __finally block has undefined behavior}}
}
__try {
} __finally {
goto *&&out_of_finally_finally; // expected-warning {{jump out of __finally block has undefined behavior}}
}
out_of_finally_finally:
;
}
// Jumping between protected scope and handler is not permitted.
void jump_try_except() {
__try {
goto from_try_to_except; // expected-error {{cannot jump from this goto statement to its label}}
} __except(0) { // expected-note {{jump bypasses initialization of __except block}}
from_try_to_except:
;
}
__try { // expected-note {{jump bypasses initialization of __try block}}
from_except_to_try:
;
} __except(0) {
goto from_except_to_try; // expected-error {{cannot jump from this goto statement to its label}}
}
}
void jump_try_finally() {
__try {
goto from_try_to_finally; // expected-error {{cannot jump from this goto statement to its label}}
} __finally { // expected-note {{jump bypasses initialization of __finally block}}
from_try_to_finally:
;
}
__try { // expected-note {{jump bypasses initialization of __try block}}
from_finally_to_try:
;
} __finally {
goto from_finally_to_try; // expected-error {{cannot jump from this goto statement to its label}} expected-warning {{jump out of __finally block has undefined behavior}}
}
}
void nested() {
// These are not permitted.
__try {
__try {
} __finally {
goto outer_except; // expected-error {{cannot jump from this goto statement to its label}}
}
} __except(0) { // expected-note {{jump bypasses initialization of __except bloc}}
outer_except:
;
}
__try {
__try{
} __except(0) {
goto outer_finally; // expected-error {{cannot jump from this goto statement to its label}}
}
} __finally { // expected-note {{jump bypasses initialization of __finally bloc}}
outer_finally:
;
}
// These are permitted.
__try {
__try {
} __finally {
goto after_outer_except; // expected-warning {{jump out of __finally block has undefined behavior}}
}
} __except(0) {
}
after_outer_except:
;
__try {
__try{
} __except(0) {
goto after_outer_finally;
}
} __finally {
}
after_outer_finally:
;
}
// This section is academic, as MSVC doesn't support indirect gotos.
void indirect_jumps(void **ip) {
static void *ips[] = { &&l };
__try { // expected-note {{jump exits __try block}}
// FIXME: Should this be allowed? Jumping out of the guarded section of a
// __try/__except doesn't require unwinding.
goto *ip; // expected-error {{cannot jump from this indirect goto statement to one of its possible targets}}
} __except(0) {
}
__try {
} __except(0) { // expected-note {{jump exits __except block}}
// FIXME: What about here?
goto *ip; // expected-error {{cannot jump from this indirect goto statement to one of its possible targets}}
}
__try { // expected-note {{jump exits __try block}}
goto *ip; // expected-error {{cannot jump from this indirect goto statement to one of its possible targets}}
} __finally {
}
__try {
} __finally { // expected-note {{jump exits __finally block}}
goto *ip; // expected-error {{cannot jump from this indirect goto statement to one of its possible targets}}
}
l: // expected-note 4 {{possible target of indirect goto statement}}
;
}
} // namespace seh