DeclBase.h revision 226e04a9b7790a7311aff2aa9df340c1841e20e3
1//===-- DeclBase.h - Base Classes for representing declarations *- 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 Decl and DeclContext interfaces. 11// 12//===----------------------------------------------------------------------===// 13 14#ifndef LLVM_CLANG_AST_DECLBASE_H 15#define LLVM_CLANG_AST_DECLBASE_H 16 17#include "clang/AST/Attr.h" 18#include "clang/AST/Type.h" 19#include "clang/Basic/SourceLocation.h" 20 21namespace clang { 22class TranslationUnitDecl; 23class NamespaceDecl; 24class ScopedDecl; 25class FunctionDecl; 26class CXXRecordDecl; 27class EnumDecl; 28class ObjCMethodDecl; 29class ObjCInterfaceDecl; 30 31/// Decl - This represents one declaration (or definition), e.g. a variable, 32/// typedef, function, struct, etc. 33/// 34class Decl { 35public: 36 enum Kind { 37 // This lists the concrete classes of Decl in order of the inheritance 38 // hierarchy. This allows us to do efficient classof tests based on the 39 // enums below. The commented out names are abstract class names. 40 // [DeclContext] indicates that the class also inherits from DeclContext. 41 42 // Decl 43 TranslationUnit, // [DeclContext] 44 // NamedDecl 45 Field, 46 CXXField, 47 ObjCIvar, 48 ObjCCategory, 49 ObjCCategoryImpl, 50 ObjCImplementation, 51 ObjCProtocol, 52 ObjCProperty, 53 // ScopedDecl 54 Namespace, // [DeclContext] 55 // TypeDecl 56 Typedef, 57 // TagDecl 58 Enum, // [DeclContext] 59 // RecordDecl 60 Struct, 61 Union, 62 Class, 63 // CXXRecordDecl [DeclContext] 64 CXXStruct, 65 CXXUnion, 66 CXXClass, 67 // ValueDecl 68 EnumConstant, 69 Function, // [DeclContext] 70 CXXMethod, 71 Var, 72 ImplicitParam, 73 CXXClassVar, 74 ParmVar, 75 ObjCInterface, // [DeclContext] 76 ObjCCompatibleAlias, 77 ObjCMethod, // [DeclContext] 78 ObjCClass, 79 ObjCForwardProtocol, 80 ObjCPropertyImpl, 81 LinkageSpec, 82 FileScopeAsm, 83 84 // For each non-leaf class, we now define a mapping to the first/last member 85 // of the class, to allow efficient classof. 86 NamedFirst = Field , NamedLast = ParmVar, 87 FieldFirst = Field , FieldLast = ObjCIvar, 88 ScopedFirst = Namespace , ScopedLast = ParmVar, 89 TypeFirst = Typedef , TypeLast = CXXClass, 90 TagFirst = Enum , TagLast = CXXClass, 91 RecordFirst = Struct , RecordLast = CXXClass, 92 CXXRecordFirst = CXXStruct , CXXRecordLast = CXXClass, 93 ValueFirst = EnumConstant , ValueLast = ParmVar, 94 FunctionFirst = Function , FunctionLast = CXXMethod, 95 VarFirst = Var , VarLast = ParmVar 96 }; 97 98 /// IdentifierNamespace - According to C99 6.2.3, there are four namespaces, 99 /// labels, tags, members and ordinary identifiers. These are meant 100 /// as bitmasks, so that searches in C++ can look into the "tag" namespace 101 /// during ordinary lookup. 102 enum IdentifierNamespace { 103 IDNS_Label = 0x1, 104 IDNS_Tag = 0x2, 105 IDNS_Member = 0x4, 106 IDNS_Ordinary = 0x8 107 }; 108 109 /// ObjCDeclQualifier - Qualifier used on types in method declarations 110 /// for remote messaging. They are meant for the arguments though and 111 /// applied to the Decls (ObjCMethodDecl and ParmVarDecl). 112 enum ObjCDeclQualifier { 113 OBJC_TQ_None = 0x0, 114 OBJC_TQ_In = 0x1, 115 OBJC_TQ_Inout = 0x2, 116 OBJC_TQ_Out = 0x4, 117 OBJC_TQ_Bycopy = 0x8, 118 OBJC_TQ_Byref = 0x10, 119 OBJC_TQ_Oneway = 0x20 120 }; 121 122private: 123 /// Loc - The location that this decl. 124 SourceLocation Loc; 125 126 /// DeclKind - This indicates which class this is. 127 Kind DeclKind : 8; 128 129 /// InvalidDecl - This indicates a semantic error occurred. 130 unsigned int InvalidDecl : 1; 131 132 /// HasAttrs - This indicates whether the decl has attributes or not. 133 unsigned int HasAttrs : 1; 134 135 protected: 136 /// Access - Used by C++ decls for the access specifier. 137 // NOTE: VC++ treats enums as signed, avoid using the AccessSpecifier enum 138 unsigned Access : 2; 139 friend class CXXClassMemberWrapper; 140 141 Decl(Kind DK, SourceLocation L) : Loc(L), DeclKind(DK), InvalidDecl(0), 142 HasAttrs(false) { 143 if (Decl::CollectingStats()) addDeclKind(DK); 144 } 145 146 virtual ~Decl(); 147 148public: 149 SourceLocation getLocation() const { return Loc; } 150 void setLocation(SourceLocation L) { Loc = L; } 151 152 Kind getKind() const { return DeclKind; } 153 const char *getDeclKindName() const; 154 155 void addAttr(Attr *attr); 156 const Attr *getAttrs() const; 157 void swapAttrs(Decl *D); 158 void invalidateAttrs(); 159 160 template<typename T> const T *getAttr() const { 161 for (const Attr *attr = getAttrs(); attr; attr = attr->getNext()) 162 if (const T *V = dyn_cast<T>(attr)) 163 return V; 164 165 return 0; 166 } 167 168 /// setInvalidDecl - Indicates the Decl had a semantic error. This 169 /// allows for graceful error recovery. 170 void setInvalidDecl() { InvalidDecl = 1; } 171 bool isInvalidDecl() const { return (bool) InvalidDecl; } 172 173 IdentifierNamespace getIdentifierNamespace() const { 174 switch (DeclKind) { 175 default: assert(0 && "Unknown decl kind!"); 176 case ImplicitParam: 177 case Typedef: 178 case Function: 179 case Var: 180 case ParmVar: 181 case EnumConstant: 182 case ObjCInterface: 183 case ObjCCompatibleAlias: 184 case CXXField: 185 case CXXMethod: 186 case CXXClassVar: 187 return IDNS_Ordinary; 188 case Struct: 189 case Union: 190 case Class: 191 case CXXStruct: 192 case CXXUnion: 193 case CXXClass: 194 case Enum: 195 return IDNS_Tag; 196 case Namespace: 197 return IdentifierNamespace(IDNS_Tag | IDNS_Ordinary); 198 } 199 } 200 201 // getBody - If this Decl represents a declaration for a body of code, 202 // such as a function or method definition, this method returns the top-level 203 // Stmt* of that body. Otherwise this method returns null. 204 virtual Stmt* getBody() const { return 0; } 205 206 // global temp stats (until we have a per-module visitor) 207 static void addDeclKind(Kind k); 208 static bool CollectingStats(bool Enable = false); 209 static void PrintStats(); 210 211 // Implement isa/cast/dyncast/etc. 212 static bool classof(const Decl *) { return true; } 213 214 /// Emit - Serialize this Decl to Bitcode. 215 void Emit(llvm::Serializer& S) const; 216 217 /// Create - Deserialize a Decl from Bitcode. 218 static Decl* Create(llvm::Deserializer& D, ASTContext& C); 219 220 /// Destroy - Call destructors and release memory. 221 virtual void Destroy(ASTContext& C); 222 223protected: 224 /// EmitImpl - Provides the subclass-specific serialization logic for 225 /// serializing out a decl. 226 virtual void EmitImpl(llvm::Serializer& S) const { 227 // FIXME: This will eventually be a pure virtual function. 228 assert (false && "Not implemented."); 229 } 230 231 void EmitInRec(llvm::Serializer& S) const; 232 void ReadInRec(llvm::Deserializer& D, ASTContext& C); 233}; 234 235/// DeclContext - This is used only as base class of specific decl types that 236/// can act as declaration contexts. These decls are: 237/// 238/// TranslationUnitDecl 239/// NamespaceDecl 240/// FunctionDecl 241/// CXXRecordDecl 242/// EnumDecl 243/// ObjCMethodDecl 244/// ObjCInterfaceDecl 245/// 246class DeclContext { 247 /// DeclKind - This indicates which class this is. 248 Decl::Kind DeclKind : 8; 249 250 /// DeclChain - Linked list of declarations that are defined inside this 251 /// declaration context. 252 ScopedDecl *DeclChain; 253 254 // Used in the CastTo template to get the DeclKind 255 // from a Decl or a DeclContext. DeclContext doesn't have a getKind() method 256 // to avoid 'ambiguous access' compiler errors. 257 template<typename T> struct KindTrait { 258 static Decl::Kind getKind(const T *D) { return D->getKind(); } 259 }; 260 261 // Used only by the ToDecl and FromDecl methods 262 template<typename To, typename From> 263 static To *CastTo(const From *D) { 264 Decl::Kind DK = KindTrait<From>::getKind(D); 265 switch(DK) { 266 case Decl::TranslationUnit: 267 return static_cast<TranslationUnitDecl*>(const_cast<From*>(D)); 268 case Decl::Namespace: 269 return static_cast<NamespaceDecl*>(const_cast<From*>(D)); 270 case Decl::Enum: 271 return static_cast<EnumDecl*>(const_cast<From*>(D)); 272 case Decl::ObjCMethod: 273 return static_cast<ObjCMethodDecl*>(const_cast<From*>(D)); 274 case Decl::ObjCInterface: 275 return static_cast<ObjCInterfaceDecl*>(const_cast<From*>(D)); 276 default: 277 if (DK >= Decl::FunctionFirst && DK <= Decl::FunctionLast) 278 return static_cast<FunctionDecl*>(const_cast<From*>(D)); 279 if (DK >= Decl::CXXRecordFirst && DK <= Decl::CXXRecordLast) 280 return static_cast<CXXRecordDecl*>(const_cast<From*>(D)); 281 282 assert(false && "a decl that inherits DeclContext isn't handled"); 283 return 0; 284 } 285 } 286 287protected: 288 DeclContext(Decl::Kind K) : DeclKind(K), DeclChain(0) {} 289 290public: 291 /// getParent - Returns the containing DeclContext if this is a ScopedDecl, 292 /// else returns NULL. 293 DeclContext *getParent() const; 294 295 bool isFunctionOrMethod() const { 296 switch (DeclKind) { 297 case Decl::Function: 298 case Decl::CXXMethod: 299 case Decl::ObjCMethod: 300 return true; 301 default: 302 return false; 303 } 304 } 305 306 ScopedDecl *getDeclChain() const { return DeclChain; } 307 void setDeclChain(ScopedDecl *D) { DeclChain = D; } 308 309 /// ToDecl and FromDecl make Decl <-> DeclContext castings. 310 /// They are intended to be used by the simplify_type and cast_convert_val 311 /// templates. 312 static Decl *ToDecl (const DeclContext *D); 313 static DeclContext *FromDecl (const Decl *D); 314 315 static bool classof(const Decl *D) { 316 switch (D->getKind()) { 317 case Decl::TranslationUnit: 318 case Decl::Namespace: 319 case Decl::Enum: 320 case Decl::ObjCMethod: 321 case Decl::ObjCInterface: 322 return true; 323 default: 324 if (D->getKind() >= Decl::FunctionFirst && 325 D->getKind() <= Decl::FunctionLast) 326 return true; 327 if (D->getKind() >= Decl::CXXRecordFirst && 328 D->getKind() <= Decl::CXXRecordLast) 329 return true; 330 return false; 331 } 332 } 333 static bool classof(const DeclContext *D) { return true; } 334 static bool classof(const TranslationUnitDecl *D) { return true; } 335 static bool classof(const NamespaceDecl *D) { return true; } 336 static bool classof(const FunctionDecl *D) { return true; } 337 static bool classof(const CXXRecordDecl *D) { return true; } 338 static bool classof(const EnumDecl *D) { return true; } 339 static bool classof(const ObjCMethodDecl *D) { return true; } 340 static bool classof(const ObjCInterfaceDecl *D) { return true; } 341 342private: 343 void EmitOutRec(llvm::Serializer& S) const; 344 void ReadOutRec(llvm::Deserializer& D, ASTContext& C); 345 346 friend class Decl; 347}; 348 349template<> struct DeclContext::KindTrait<DeclContext> { 350 static Decl::Kind getKind(const DeclContext *D) { return D->DeclKind; } 351}; 352 353} // end clang. 354 355namespace llvm { 356/// Implement simplify_type for DeclContext, so that we can dyn_cast from 357/// DeclContext to a specific Decl class. 358 template<> struct simplify_type<const ::clang::DeclContext*> { 359 typedef ::clang::Decl* SimpleType; 360 static SimpleType getSimplifiedValue(const ::clang::DeclContext *Val) { 361 return ::clang::DeclContext::ToDecl(Val); 362 } 363}; 364template<> struct simplify_type< ::clang::DeclContext*> 365 : public simplify_type<const ::clang::DeclContext*> {}; 366 367template<> struct simplify_type<const ::clang::DeclContext> { 368 typedef ::clang::Decl SimpleType; 369 static SimpleType &getSimplifiedValue(const ::clang::DeclContext &Val) { 370 return *::clang::DeclContext::ToDecl(&Val); 371 } 372}; 373template<> struct simplify_type< ::clang::DeclContext> 374 : public simplify_type<const ::clang::DeclContext> {}; 375 376/// Implement cast_convert_val for DeclContext, so that we can dyn_cast from 377/// a Decl class to DeclContext. 378template<class FromTy> 379struct cast_convert_val< ::clang::DeclContext,const FromTy,const FromTy> { 380 static ::clang::DeclContext &doit(const FromTy &Val) { 381 return *::clang::DeclContext::FromDecl(&Val); 382 } 383}; 384template<class FromTy> 385struct cast_convert_val< ::clang::DeclContext,FromTy,FromTy> 386 : public cast_convert_val< ::clang::DeclContext,const FromTy,const FromTy> 387 {}; 388 389template<class FromTy> 390struct cast_convert_val< ::clang::DeclContext,const FromTy*,const FromTy*> { 391 static ::clang::DeclContext *doit(const FromTy *Val) { 392 return ::clang::DeclContext::FromDecl(Val); 393 } 394}; 395template<class FromTy> 396struct cast_convert_val< ::clang::DeclContext,FromTy*,FromTy*> 397 : public cast_convert_val< ::clang::DeclContext,const FromTy*,const FromTy*> 398 {}; 399 400} // end namespace llvm 401 402#endif 403