1// RUN: %clang_cc1 -fsyntax-only -verify %s
2
3char *const_cast_test(const char *var)
4{
5  return const_cast<char*>(var);
6}
7
8struct A {
9  virtual ~A() {}
10};
11
12struct B : public A {
13};
14
15struct B *dynamic_cast_test(struct A *a)
16{
17  return dynamic_cast<struct B*>(a);
18}
19
20char *reinterpret_cast_test()
21{
22  return reinterpret_cast<char*>(0xdeadbeef);
23}
24
25double static_cast_test(int i)
26{
27  return static_cast<double>(i);
28}
29
30char postfix_expr_test()
31{
32  return reinterpret_cast<char*>(0xdeadbeef)[0];
33}
34
35// This was being incorrectly tentatively parsed.
36namespace test1 {
37  template <class T> class A {}; // expected-note 2{{here}}
38  void foo() { A<int>(*(A<int>*)0); }
39}
40
41typedef char* c;
42typedef A* a;
43void 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;"
72template <class T> class D {}; // expected-note{{template is declared here}}
73template <class T> void E() {};
74class F {};
75
76void 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.
94void 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
104void 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.
111int n = reinterpret_cast // expected-error {{expected '<'}} expected-error {{expected ';'}}
112