Home | History | Annotate | Download | only in SemaCXX 
      1 // RUN: %clang_cc1 %s -triple i686-pc-win32 -fsyntax-only -Wmicrosoft -verify -fms-compatibility -fexceptions -fcxx-exceptions
      2 
      3 
      4 
      5 namespace ms_conversion_rules {
      6 
      7 void f(float a);
      8 void f(int a);
      9 
     10 void test()
     11 {
     12     long a = 0;
     13     f((long)0);
     14 	f(a);
     15 }
     16 
     17 }
     18 
     19 
     20 
     21 namespace ms_protected_scope {
     22   struct C { C(); };
     23 
     24   int jump_over_variable_init(bool b) {
     25     if (b)
     26       goto foo; // expected-warning {{illegal goto into protected scope}}
     27     C c; // expected-note {{jump bypasses variable initialization}}
     28   foo:
     29     return 1;
     30   }
     31 
     32 struct Y {
     33   ~Y();
     34 };
     35 
     36 void jump_over_var_with_dtor() {
     37   goto end; // expected-warning{{goto into protected scope}}
     38   Y y; // expected-note {{jump bypasses variable initialization}}
     39  end:
     40     ;
     41 }
     42 
     43   void jump_over_variable_case(int c) {
     44     switch (c) {
     45     case 0:
     46       int x = 56; // expected-note {{jump bypasses variable initialization}}
     47     case 1:       // expected-error {{switch case is in protected scope}}
     48       x = 10;
     49     }
     50   }
     51 
     52 
     53 void exception_jump() {
     54   goto l2; // expected-error {{illegal goto into protected scope}}
     55   try { // expected-note {{jump bypasses initialization of try block}}
     56      l2: ;
     57   } catch(int) {
     58   }
     59 }
     60 
     61 int jump_over_indirect_goto() {
     62   static void *ps[] = { &&a0 };
     63   goto *&&a0; // expected-warning {{goto into protected scope}}
     64   int a = 3; // expected-note {{jump bypasses variable initialization}}
     65  a0:
     66   return 0;
     67 }
     68 
     69 }
     70 
     71 
     72 
     73 namespace ms_using_declaration_bug {
     74 
     75 class A {
     76 public:
     77   int f();
     78 };
     79 
     80 class B : public A {
     81 private:
     82   using A::f;
     83 };
     84 
     85 class C : public B {
     86 private:
     87   using B::f; // expected-warning {{using declaration refers to inaccessible member 'ms_using_declaration_bug::B::f', which refers to accessible member 'ms_using_declaration_bug::A::f', accepted for Microsoft compatibility}}
     88 };
     89 
     90 }
     91 
     92 
     93 namespace MissingTypename {
     94 
     95 template<class T> class A {
     96 public:
     97 	 typedef int TYPE;
     98 };
     99 
    100 template<class T> class B {
    101 public:
    102 	 typedef int TYPE;
    103 };
    104 
    105 
    106 template<class T, class U>
    107 class C : private A<T>, public B<U> {
    108 public:
    109    typedef A<T> Base1;
    110    typedef B<U> Base2;
    111    typedef A<U> Base3;
    112 
    113    A<T>::TYPE a1; // expected-warning {{missing 'typename' prior to dependent type name}}
    114    Base1::TYPE a2; // expected-warning {{missing 'typename' prior to dependent type name}}
    115 
    116    B<U>::TYPE a3; // expected-warning {{missing 'typename' prior to dependent type name}}
    117    Base2::TYPE a4; // expected-warning {{missing 'typename' prior to dependent type name}}
    118 
    119    A<U>::TYPE a5; // expected-error {{missing 'typename' prior to dependent type name}}
    120    Base3::TYPE a6; // expected-error {{missing 'typename' prior to dependent type name}}
    121  };
    122 
    123 class D {
    124 public:
    125     typedef int Type;
    126 };
    127 
    128 template <class T>
    129 void function_missing_typename(const T::Type param)// expected-warning {{missing 'typename' prior to dependent type name}}
    130 {
    131     const T::Type var = 2; // expected-warning {{missing 'typename' prior to dependent type name}}
    132 }
    133 
    134 template void function_missing_typename<D>(const D::Type param);
    135 
    136 }
    137 
    138 
    139 
    140 namespace lookup_dependent_bases_id_expr {
    141 
    142 template<class T> class A {
    143 public:
    144   int var;
    145 };
    146 
    147 
    148 template<class T>
    149 class B : public A<T> {
    150 public:
    151   void f() {
    152     var = 3;
    153   }
    154 };
    155 
    156 template class B<int>;
    157 
    158 }