test/SemaCXX/enum.cpp

   1 // RUN: %clang_cc1 -fsyntax-only -pedantic -std=c++98 -verify -triple x86_64-apple-darwin %s
   2 enum E { // expected-note{{previous definition is here}}
   3   Val1,
   4   Val2
   5 };
   6
   7 enum E; // expected-warning{{redeclaration of already-defined enum 'E' is a GNU extension}}
   8
   9 int& enumerator_type(int);
  10 float& enumerator_type(E);
  11
  12 void f() {
  13   E e = Val1;
  14   float& fr = enumerator_type(Val2);
  15 }
  16
  17 // <rdar://problem/6502934>
  18 typedef enum Foo {
  19   A = 0,
  20   B = 1
  21 } Foo;
  22
  23 void bar() {
  24   Foo myvar = A;
  25   myvar = B;
  26 }
  27
  28 /// PR3688
  29 struct s1 {
  30   enum e1 (*bar)(void); // expected-error{{ISO C++ forbids forward references to 'enum' types}}
  31 };
  32
  33 enum e1 { YES, NO };
  34
  35 static enum e1 badfunc(struct s1 *q) {
  36   return q->bar();
  37 }
  38
  39 enum e2; // expected-error{{ISO C++ forbids forward references to 'enum' types}}
  40
  41 namespace test1 {
  42   template <class A, class B> struct is_same { static const int value = -1; };
  43   template <class A> struct is_same<A,A> { static const int value = 1; };
  44
  45   enum enum0 { v0 };
  46   int test0[is_same<__typeof(+v0), int>::value];
  47
  48   enum enum1 { v1 = __INT_MAX__ };
  49   int test1[is_same<__typeof(+v1), int>::value];
  50
  51   enum enum2 { v2 = __INT_MAX__ * 2U };
  52   int test2[is_same<__typeof(+v2), unsigned int>::value];
  53
  54   enum enum3 { v3 = __LONG_MAX__ };
  55   int test3[is_same<__typeof(+v3), long>::value];
  56
  57   enum enum4 { v4 = __LONG_MAX__ * 2UL };
  58   int test4[is_same<__typeof(+v4), unsigned long>::value];
  59 }
  60
  61 // PR6061
  62 namespace PR6061 {
  63   struct A { enum { id }; };
  64   struct B { enum { id }; };
  65
  66   struct C : public A, public B
  67   {
  68     enum { id };
  69   };
  70 }
  71
  72 namespace Conditional {
  73   enum a { A }; a x(const enum a x) { return 1?x:A; }
  74 }
  75
  76 namespace PR7051 {
  77   enum E { e0 };
  78   void f() {
  79     E e;
  80     e = 1; // expected-error{{assigning to 'PR7051::E' from incompatible type 'int'}}
  81     e |= 1; // expected-error{{assigning to 'PR7051::E' from incompatible type 'int'}}
  82   }
  83 }
  84
  85 // PR7466
  86 enum { }; // expected-warning{{declaration does not declare anything}}
  87 typedef enum { }; // expected-warning{{typedef requires a name}}
  88
  89 // PR7921
  90 enum PR7921E {
  91     PR7921V = (PR7921E)(123) // expected-error {{expression is not an integer constant expression}}
  92 };
  93
  94 void PR8089() {
  95   enum E; // expected-error{{ISO C++ forbids forward references to 'enum' types}}
  96   int a = (E)3; // expected-error{{cannot initialize a variable of type 'int' with an rvalue of type 'E'}}
  97 }