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 fooErrors7 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 { fooBase117 void foo(int) {} 18 static_fooBase119 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 fooDerived32 void foo() { 33 __super::foo(1); 34 35 if (true) { 36 __super::foo(1); 37 } 38 39 return __super::foo(1); 40 } 41 barDerived42 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 { fooBase254 void foo(char) {} 55 }; 56 57 struct MemberFunctionInMultipleBases : Base1, Base2 { fooMemberFunctionInMultipleBases58 void foo() { 59 __super::foo('x'); 60 } 61 }; 62 63 struct Base3 { fooBase364 void foo(int) {} fooBase365 void foo(char) {} 66 }; 67 68 struct OverloadedMemberFunction : Base3 { fooOverloadedMemberFunction69 void foo() { 70 __super::foo('x'); 71 } 72 }; 73 74 struct PointerToMember : Base1 { 75 template <void (Base1::*MP)(int)> 76 struct Wrapper { barPointerToMember::Wrapper77 static void bar() {} 78 }; 79 80 void baz(); 81 }; 82 baz()83void PointerToMember::baz() { 84 Wrapper<&__super::foo>::bar(); 85 } 86 87 template <typename T> 88 struct BaseTemplate { 89 typedef int XXX; 90 fooBaseTemplate91 int foo() { return 0; } 92 }; 93 94 struct DerivedFromKnownSpecialization : BaseTemplate<int> { 95 __super::XXX a; 96 typedef __super::XXX b; 97 fooDerivedFromKnownSpecialization98 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 fooDerivedFromDependentBase114 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 fooDerivedFromTemplateParameter133 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 instantiate()144void 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' f__anon40f8a41d0211::A156 void f() { int a = this->__super::a; } 157 }; 158 } 159