1 //===-- TypeNodes.def - Metadata about Type AST nodes -----------*- C++ -*-===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 // 10 // This file defines the AST type info database. Each type node is 11 // enumerated by providing its name (e.g., "Builtin" or "Enum") and 12 // base class (e.g., "Type" or "TagType"). Depending on where in the 13 // abstract syntax tree the type will show up, the enumeration uses 14 // one of five different macros: 15 // 16 // TYPE(Class, Base) - A type that can show up anywhere in the AST, 17 // and might be dependent, canonical, or non-canonical. All clients 18 // will need to understand these types. 19 // 20 // ABSTRACT_TYPE(Class, Base) - An abstract class that shows up in 21 // the type hierarchy but has no concrete instances. 22 // 23 // NON_CANONICAL_TYPE(Class, Base) - A type that can show up 24 // anywhere in the AST but will never be a part of a canonical 25 // type. Clients that only need to deal with canonical types 26 // (ignoring, e.g., typedefs and other type aliases used for 27 // pretty-printing) can ignore these types. 28 // 29 // DEPENDENT_TYPE(Class, Base) - A type that will only show up 30 // within a C++ template that has not been instantiated, e.g., a 31 // type that is always dependent. Clients that do not need to deal 32 // with uninstantiated C++ templates can ignore these types. 33 // 34 // NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class, Base) - A type that 35 // is non-canonical unless it is dependent. Defaults to TYPE because 36 // it is neither reliably dependent nor reliably non-canonical. 37 // 38 // There is a sixth macro, independent of the others. Most clients 39 // will not need to use it. 40 // 41 // LEAF_TYPE(Class) - A type that never has inner types. Clients 42 // which can operate on such types more efficiently may wish to do so. 43 // 44 //===----------------------------------------------------------------------===// 45 46 #ifndef ABSTRACT_TYPE 47 # define ABSTRACT_TYPE(Class, Base) TYPE(Class, Base) 48 #endif 49 50 #ifndef NON_CANONICAL_TYPE 51 # define NON_CANONICAL_TYPE(Class, Base) TYPE(Class, Base) 52 #endif 53 54 #ifndef DEPENDENT_TYPE 55 # define DEPENDENT_TYPE(Class, Base) TYPE(Class, Base) 56 #endif 57 58 #ifndef NON_CANONICAL_UNLESS_DEPENDENT_TYPE 59 # define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class, Base) TYPE(Class, Base) 60 #endif 61 62 TYPE(Builtin, Type) 63 TYPE(Complex, Type) 64 TYPE(Pointer, Type) 65 TYPE(BlockPointer, Type) 66 ABSTRACT_TYPE(Reference, Type) 67 TYPE(LValueReference, ReferenceType) 68 TYPE(RValueReference, ReferenceType) 69 TYPE(MemberPointer, Type) 70 ABSTRACT_TYPE(Array, Type) 71 TYPE(ConstantArray, ArrayType) 72 TYPE(IncompleteArray, ArrayType) 73 TYPE(VariableArray, ArrayType) 74 DEPENDENT_TYPE(DependentSizedArray, ArrayType) 75 DEPENDENT_TYPE(DependentSizedExtVector, Type) 76 DEPENDENT_TYPE(DependentAddressSpace, Type) 77 TYPE(Vector, Type) 78 TYPE(ExtVector, VectorType) 79 ABSTRACT_TYPE(Function, Type) 80 TYPE(FunctionProto, FunctionType) 81 TYPE(FunctionNoProto, FunctionType) 82 DEPENDENT_TYPE(UnresolvedUsing, Type) 83 NON_CANONICAL_TYPE(Paren, Type) 84 NON_CANONICAL_TYPE(Typedef, Type) 85 NON_CANONICAL_TYPE(Adjusted, Type) 86 NON_CANONICAL_TYPE(Decayed, AdjustedType) 87 NON_CANONICAL_UNLESS_DEPENDENT_TYPE(TypeOfExpr, Type) 88 NON_CANONICAL_UNLESS_DEPENDENT_TYPE(TypeOf, Type) 89 NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Decltype, Type) 90 NON_CANONICAL_UNLESS_DEPENDENT_TYPE(UnaryTransform, Type) 91 ABSTRACT_TYPE(Tag, Type) 92 TYPE(Record, TagType) 93 TYPE(Enum, TagType) 94 NON_CANONICAL_TYPE(Elaborated, Type) 95 NON_CANONICAL_TYPE(Attributed, Type) 96 DEPENDENT_TYPE(TemplateTypeParm, Type) 97 NON_CANONICAL_TYPE(SubstTemplateTypeParm, Type) 98 DEPENDENT_TYPE(SubstTemplateTypeParmPack, Type) 99 NON_CANONICAL_UNLESS_DEPENDENT_TYPE(TemplateSpecialization, Type) 100 ABSTRACT_TYPE(Deduced, Type) 101 TYPE(Auto, DeducedType) 102 TYPE(DeducedTemplateSpecialization, DeducedType) 103 DEPENDENT_TYPE(InjectedClassName, Type) 104 DEPENDENT_TYPE(DependentName, Type) 105 DEPENDENT_TYPE(DependentTemplateSpecialization, Type) 106 NON_CANONICAL_UNLESS_DEPENDENT_TYPE(PackExpansion, Type) 107 NON_CANONICAL_TYPE(ObjCTypeParam, Type) 108 TYPE(ObjCObject, Type) 109 TYPE(ObjCInterface, ObjCObjectType) 110 TYPE(ObjCObjectPointer, Type) 111 TYPE(Pipe, Type) 112 TYPE(Atomic, Type) 113 114 #ifdef LAST_TYPE 115 LAST_TYPE(Atomic) 116 #undef LAST_TYPE 117 #endif 118 119 // These types are always leaves in the type hierarchy. 120 #ifdef LEAF_TYPE 121 LEAF_TYPE(Enum) 122 LEAF_TYPE(Builtin) 123 LEAF_TYPE(Record) 124 LEAF_TYPE(InjectedClassName) 125 LEAF_TYPE(ObjCInterface) 126 LEAF_TYPE(TemplateTypeParm) 127 #undef LEAF_TYPE 128 #endif 129 130 #undef NON_CANONICAL_UNLESS_DEPENDENT_TYPE 131 #undef DEPENDENT_TYPE 132 #undef NON_CANONICAL_TYPE 133 #undef ABSTRACT_TYPE 134 #undef TYPE 135
