clang/test/SemaCXX/MicrosoftSuper.cpp

   1 // RUN: %clang_cc1 %s -fsyntax-only -fms-extensions -std=c++11 -verify
   2
   3 struct Errors {
   4   using __super::foo; // expected-error {{'__super' cannot be used with a using declaration}}
   5   __super::XXX x; // expected-error {{invalid use of '__super', Errors has no base classes}} expected-error {{expected}}
   6
   7   void foo() {
   8     // expected-note@+4 {{replace parentheses with an initializer to declare a variable}}
   9     // expected-warning@+3 {{empty parentheses interpreted as a function declaration}}
  10     // expected-error@+2 {{C++ requires a type specifier for all declarations}}
  11     // expected-error@+1 {{use of '__super' inside a lambda is unsupported}}
  12     auto lambda = []{ __super::foo(); };
  13   }
  14 };
  15
  16 struct Base1 {
  17   void foo(int) {}
  18
  19   static void static_foo() {}
  20
  21   typedef int XXX;
  22 };
  23
  24 struct Derived : Base1 {
  25   __super::XXX x;
  26   typedef __super::XXX Type;
  27
  28   enum E {
  29     X = sizeof(__super::XXX)
  30   };
  31
  32   void foo() {
  33     __super::foo(1);
  34
  35     if (true) {
  36       __super::foo(1);
  37     }
  38
  39     return __super::foo(1);
  40   }
  41
  42   static void bar() {
  43     __super::static_foo();
  44   }
  45 };
  46
  47 struct Outer {
  48   struct Inner : Base1 {
  49     static const int x = sizeof(__super::XXX);
  50   };
  51 };
  52
  53 struct Base2 {
  54   void foo(char) {}
  55 };
  56
  57 struct MemberFunctionInMultipleBases : Base1, Base2 {
  58   void foo() {
  59     __super::foo('x');
  60   }
  61 };
  62
  63 struct Base3 {
  64   void foo(int) {}
  65   void foo(char) {}
  66 };
  67
  68 struct OverloadedMemberFunction : Base3 {
  69   void foo() {
  70     __super::foo('x');
  71   }
  72 };
  73
  74 struct PointerToMember : Base1 {
  75   template <void (Base1::*MP)(int)>
  76   struct Wrapper {
  77     static void bar() {}
  78   };
  79
  80   void baz();
  81 };
  82
  83 void PointerToMember::baz() {
  84   Wrapper<&__super::foo>::bar();
  85 }
  86
  87 template <typename T>
  88 struct BaseTemplate {
  89   typedef int XXX;
  90
  91   int foo() { return 0; }
  92 };
  93
  94 struct DerivedFromKnownSpecialization : BaseTemplate<int> {
  95   __super::XXX a;
  96   typedef __super::XXX b;
  97
  98   void foo() {
  99     __super::XXX c;
 100     typedef __super::XXX d;
 101
 102     __super::foo();
 103   }
 104 };
 105
 106 template <typename T>
 107 struct DerivedFromDependentBase : BaseTemplate<T> {
 108   typename __super::XXX a;
 109   typedef typename __super::XXX b;
 110
 111   __super::XXX c;         // expected-error {{missing 'typename'}}
 112   typedef __super::XXX d; // expected-error {{missing 'typename'}}
 113
 114   void foo() {
 115     typename __super::XXX e;
 116     typedef typename __super::XXX f;
 117
 118     __super::XXX g;         // expected-error {{missing 'typename'}}
 119     typedef __super::XXX h; // expected-error {{missing 'typename'}}
 120
 121     int x = __super::foo();
 122   }
 123 };
 124
 125 template <typename T>
 126 struct DerivedFromTemplateParameter : T {
 127   typename __super::XXX a;
 128   typedef typename __super::XXX b;
 129
 130   __super::XXX c;         // expected-error {{missing 'typename'}}
 131   typedef __super::XXX d; // expected-error {{missing 'typename'}}
 132
 133   void foo() {
 134     typename __super::XXX e;
 135     typedef typename __super::XXX f;
 136
 137     __super::XXX g;         // expected-error {{missing 'typename'}}
 138     typedef __super::XXX h; // expected-error {{missing 'typename'}}
 139
 140     __super::foo(1);
 141   }
 142 };
 143
 144 void instantiate() {
 145   DerivedFromDependentBase<int> d;
 146   d.foo();
 147   DerivedFromTemplateParameter<Base1> t;
 148   t.foo();
 149 }
 150
 151 namespace {
 152 struct B { int a; };
 153 template <class C>
 154 struct A : B {
 155   // Don't crash on dependent_type_var '->' '__super'
 156   void f() { int a = this->__super::a; }
 157 };
 158 }