1 /* -*- C++ -*- */ 2 3 #include "dummy.h" 4 5 namespace DebugCXX { 6 // Records. 7 struct Struct { 8 int i; 9 static int static_member; 10 }; 11 12 // Enums. 13 enum Enum { 14 Enumerator 15 }; 16 enum { 17 e1 = '1' 18 }; 19 enum { 20 e2 = '2' 21 }; 22 23 // Templates (instantiations). 24 template<typename T> struct traits {}; 25 template<typename T, 26 typename Traits = traits<T> 27 > class Template { 28 T member; 29 }; 30 // Explicit template instantiation. 31 extern template class Template<int>; 32 33 extern template struct traits<float>; 34 typedef class Template<float> FloatInstantiation; 35 36 inline void fn() { 37 Template<long> invisible; 38 } 39 40 // Non-template inside a template. 41 template <class> struct Outer { 42 Outer(); 43 struct Inner { 44 Inner(Outer) {} 45 }; 46 }; 47 template <class T> Outer<T>::Outer() { 48 Inner a(*this); 49 }; 50 51 // Partial template specialization. 52 template <typename...> class A; 53 template <typename T> class A<T> {}; 54 typedef A<void> B; 55 // Anchored by a function parameter. 56 void foo(B) {} 57 } 58 59 // Virtual class with a forward declaration. 60 struct Virtual; 61 struct Virtual { 62 virtual ~Virtual() {} 63 }; 64 65 struct PureForwardDecl; 66 67 typedef union { int i; } TypedefUnion; 68 typedef enum { e0 = 0 } TypedefEnum; 69 typedef struct { int i; } TypedefStruct; 70 71 union { int i; } GlobalUnion; 72 struct { int i; } GlobalStruct; 73 enum { e5 = 5 } GlobalEnum; 74 75 namespace { 76 namespace { 77 struct InAnonymousNamespace { int i; }; 78 } 79 } 80 81 class Base; 82 class A { 83 virtual Base *getParent() const; 84 }; 85 class Base {}; 86 class Derived : Base { 87 class B : A { 88 Derived *getParent() const override; 89 }; 90 }; 91 92 template <class T> 93 class Template1 { 94 T t; 95 }; 96 typedef Template1<void *> TypedefTemplate; 97 extern template class Template1<int>; 98 99 template <class T> class FwdDeclTemplate; 100 typedef FwdDeclTemplate<int> TypedefFwdDeclTemplate; 101 102 // Member classes of class template specializations. 103 template <typename T> struct Specialized {}; 104 105 template <> struct Specialized<int> { 106 struct Member; 107 }; 108 109 template <class T> struct FwdDeclTemplateMember { struct Member; }; 110 typedef FwdDeclTemplateMember<int>::Member TypedefFwdDeclTemplateMember; 111 112 // Base class specialized on the class itself. 113 template <typename Derived> class BaseTemplate {}; 114 template <typename T> 115 class WithSpecializedBase : public BaseTemplate<WithSpecializedBase<T>> {}; 116 typedef WithSpecializedBase<float> SpecializedBase; 117