1// RUN: %clang_cc1 -fsyntax-only -verify %s
2namespace Ns {
3  int f(); // expected-note{{previous declaration is here}}
4
5  enum E {
6    Enumerator
7  };
8}
9namespace Ns {
10  double f(); // expected-error{{functions that differ only in their return type cannot be overloaded}}
11
12  int x = Enumerator;
13}
14
15namespace Ns2 {
16  float f();
17}
18
19int y = Ns::Enumerator;
20
21namespace Ns2 {
22  float f(int); // expected-note{{previous declaration is here}}
23}
24
25namespace Ns2 {
26  double f(int); // expected-error{{functions that differ only in their return type cannot be overloaded}}
27}
28
29namespace N {
30  int& f1();
31}
32
33namespace N {
34  struct f1 {
35    static int member;
36
37    typedef int type;
38
39    void foo(type);
40  };
41
42  void test_f1() {
43    int &i1 = f1();
44  }
45}
46
47void N::f1::foo(int i) {
48  f1::member = i;
49  f1::type &ir = i;
50}
51
52namespace N {
53  float& f1(int x) {
54    N::f1::type& i1 = x;
55    f1::type& i2 = x;
56  }
57
58  struct f2 {
59    static int member;
60  };
61  void f2();
62}
63
64int i1 = N::f1::member;
65typedef struct N::f1 type1;
66int i2 = N::f2::member;
67typedef struct N::f2 type2;
68
69void test_f1(int i) {
70  int &v1 = N::f1();
71  float &v2 = N::f1(i);
72  int v3 = ::i1;
73  int v4 = N::f1::member;
74}
75
76typedef int f2_type;
77namespace a {
78  typedef int f2_type(int, int);
79
80  void test_f2() {
81    ::f2_type(1, 2); // expected-error {{excess elements in scalar initializer}}
82  }
83}
84
85// PR clang/3291
86namespace a {
87  namespace a {   // A1
88    namespace a { // A2
89      int i;
90    }
91  }
92}
93
94void test_a() {
95  a::a::i = 3; // expected-error{{no member named 'i'}}
96  a::a::a::i = 4;
97}
98
99struct Undef { // expected-note{{definition of 'Undef' is not complete until the closing '}'}}
100  typedef int type;
101
102  Undef::type member;
103
104  static int size = sizeof(Undef); // expected-error{{invalid application of 'sizeof' to an incomplete type 'Undef'}}
105
106  int f();
107};
108
109int Undef::f() {
110  return sizeof(Undef);
111}
112
113// PR clang/5667
114namespace test1 {
115  template <typename T> struct is_class {
116    enum { value = 0 };
117  };
118
119  template <typename T> class ClassChecker {
120    bool isClass() {
121      return is_class<T>::value;
122    }
123  };
124
125  template class ClassChecker<int>;
126}
127
128namespace PR6830 {
129  namespace foo {
130
131    class X {
132    public:
133      X() {}
134    };
135
136  }  // namespace foo
137
138  class Z {
139  public:
140    explicit Z(const foo::X& x) {}
141
142    void Work() {}
143  };
144
145  void Test() {
146    Z(foo::X()).Work();
147  }
148}
149
150namespace pr12339 {
151  extern "C" void i;
152  pr12339::FOO  // expected-error{{no type named 'FOO' in namespace 'pr12339'}}
153}  // expected-error{{expected unqualified-id}}
154