1 // RUN: %clang_cc1 -fsyntax-only -verify %s
2
const_cast_test(const char * var)3 char *const_cast_test(const char *var)
4 {
5 return const_cast<char*>(var);
6 }
7
8 struct A {
~AA9 virtual ~A() {}
10 };
11
12 struct B : public A {
13 };
14
dynamic_cast_test(struct A * a)15 struct B *dynamic_cast_test(struct A *a)
16 {
17 return dynamic_cast<struct B*>(a);
18 }
19
reinterpret_cast_test()20 char *reinterpret_cast_test()
21 {
22 return reinterpret_cast<char*>(0xdeadbeef);
23 }
24
static_cast_test(int i)25 double static_cast_test(int i)
26 {
27 return static_cast<double>(i);
28 }
29
postfix_expr_test()30 char postfix_expr_test()
31 {
32 return reinterpret_cast<char*>(0xdeadbeef)[0];
33 }
34
35 // This was being incorrectly tentatively parsed.
36 namespace test1 {
37 template <class T> class A {}; // expected-note 2{{here}}
foo()38 void foo() { A<int>(*(A<int>*)0); }
39 }
40
41 typedef char* c;
42 typedef A* a;
test2(char x,struct B * b)43 void test2(char x, struct B * b) {
44 (void)const_cast<::c>(&x); // expected-error{{found '<::' after a const_cast which forms the digraph '<:' (aka '[') and a ':', did you mean '< ::'?}}
45 (void)dynamic_cast<::a>(b); // expected-error{{found '<::' after a dynamic_cast which forms the digraph '<:' (aka '[') and a ':', did you mean '< ::'?}}
46 (void)reinterpret_cast<::c>(x); // expected-error{{found '<::' after a reinterpret_cast which forms the digraph '<:' (aka '[') and a ':', did you mean '< ::'?}}
47 (void)static_cast<::c>(&x); // expected-error{{found '<::' after a static_cast which forms the digraph '<:' (aka '[') and a ':', did you mean '< ::'?}}
48
49 // Do not do digraph correction.
50 (void)static_cast<: :c>(&x); //\
51 expected-error {{expected '<' after 'static_cast'}} \
52 expected-error {{expected expression}}\
53 expected-error {{expected ']'}}\
54 expected-note {{to match this '['}}
55 (void)static_cast<: // expected-error {{expected '<' after 'static_cast'}} \
56 expected-note {{to match this '['}}
57 :c>(&x); // expected-error {{expected expression}} \
58 expected-error {{expected ']'}}
59 #define LC <:
60 #define C :
61 test1::A LC:B> c; // expected-error {{class template 'test1::A' requires template arguments}} expected-error 2{{}}
62 (void)static_cast LC:c>(&x); // expected-error {{expected '<' after 'static_cast'}} expected-error 2{{}} expected-note{{}}
63 test1::A<:C B> d; // expected-error {{class template 'test1::A' requires template arguments}} expected-error 2{{}}
64 (void)static_cast<:C c>(&x); // expected-error {{expected '<' after 'static_cast'}} expected-error 2{{}} expected-note{{}}
65
66 #define LCC <::
67 test1::A LCC B> e; // expected-error{{found '<::' after a template name which forms the digraph '<:' (aka '[') and a ':', did you mean '< ::'?}}
68 (void)static_cast LCC c>(&x); // expected-error{{found '<::' after a static_cast which forms the digraph '<:' (aka '[') and a ':', did you mean '< ::'?}}
69 }
70
71 // This note comes from "::D[:F> A5;"
72 template <class T> class D {}; // expected-note{{template is declared here}}
73 template <class T> void E() {};
74 class F {};
75
76 void test3() {
77 ::D<::F> A1; // expected-error{{found '<::' after a template name which forms the digraph '<:' (aka '[') and a ':', did you mean '< ::'?}}
78 D<::F> A2; // expected-error{{found '<::' after a template name which forms the digraph '<:' (aka '[') and a ':', did you mean '< ::'?}}
79 ::E<::F>(); // expected-error{{found '<::' after a template name which forms the digraph '<:' (aka '[') and a ':', did you mean '< ::'?}}
80 E<::F>(); // expected-error{{found '<::' after a template name which forms the digraph '<:' (aka '[') and a ':', did you mean '< ::'?}}
81
82 ::D< ::F> A3;
83 D< ::F> A4;
84 ::E< ::F>();
85 E< ::F>();
86
87 // Make sure that parser doesn't expand '[:' to '< ::'
88 ::D[:F> A5; // expected-error {{class template '::D' requires template arguments}} \
89 // expected-error {{expected expression}} \
90 // expected-error {{expected unqualified-id}}
91 }
92
93 // Ensure that a C-style cast doesn't turn off colon protection.
94 void PR19748() {
95 struct A {};
96 int A = 0, b;
97 int test1 = true ? (int)A : b;
98
99 struct f {};
100 extern B f(), (*p)();
101 (true ? (B(*)())f : p)();
102 }
103
104 void PR19751(int n) {
105 struct T { void operator++(int); };
106 (T())++; // ok, not an ill-formed cast to function type
107 (T())++n; // expected-error {{C-style cast from 'int' to 'T ()' is not allowed}}
108 }
109
110 // PR13619. Must be at end of file.
111 int n = reinterpret_cast // expected-error {{expected '<'}} expected-error {{expected ';'}}
112