1 //===-- Redeclarable.h - Base for Decls that can be redeclared -*- 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 Redeclarable interface. 11 // 12 //===----------------------------------------------------------------------===// 13 14 #ifndef LLVM_CLANG_AST_REDECLARABLE_H 15 #define LLVM_CLANG_AST_REDECLARABLE_H 16 17 #include "clang/AST/ExternalASTSource.h" 18 #include "llvm/ADT/PointerIntPair.h" 19 #include "llvm/Support/Casting.h" 20 #include <iterator> 21 22 namespace clang { 23 class ASTContext; 24 25 /// \brief Provides common interface for the Decls that can be redeclared. 26 template<typename decl_type> 27 class Redeclarable { 28 protected: 29 class DeclLink { 30 /// A pointer to a known latest declaration, either statically known or 31 /// generationally updated as decls are added by an external source. 32 typedef LazyGenerationalUpdatePtr<const Decl*, Decl*, 33 &ExternalASTSource::CompleteRedeclChain> 34 KnownLatest; 35 36 /// We store a pointer to the ASTContext in the UninitializedLatest 37 /// pointer, but to avoid circular type dependencies when we steal the low 38 /// bits of this pointer, we use a raw void* here. 39 typedef const void *UninitializedLatest; 40 41 typedef Decl *Previous; 42 43 /// A pointer to either an uninitialized latest declaration (where either 44 /// we've not yet set the previous decl or there isn't one), or to a known 45 /// previous declaration. 46 typedef llvm::PointerUnion<Previous, UninitializedLatest> NotKnownLatest; 47 48 mutable llvm::PointerUnion<NotKnownLatest, KnownLatest> Next; 49 50 public: 51 enum PreviousTag { PreviousLink }; 52 enum LatestTag { LatestLink }; 53 54 DeclLink(LatestTag, const ASTContext &Ctx) 55 : Next(NotKnownLatest(reinterpret_cast<UninitializedLatest>(&Ctx))) {} 56 DeclLink(PreviousTag, decl_type *D) 57 : Next(NotKnownLatest(Previous(D))) {} 58 59 bool NextIsPrevious() const { 60 return Next.is<NotKnownLatest>() && 61 // FIXME: 'template' is required on the next line due to an 62 // apparent clang bug. 63 Next.get<NotKnownLatest>().template is<Previous>(); 64 } 65 66 bool NextIsLatest() const { return !NextIsPrevious(); } 67 68 decl_type *getNext(const decl_type *D) const { 69 if (Next.is<NotKnownLatest>()) { 70 NotKnownLatest NKL = Next.get<NotKnownLatest>(); 71 if (NKL.is<Previous>()) 72 return static_cast<decl_type*>(NKL.get<Previous>()); 73 74 // Allocate the generational 'most recent' cache now, if needed. 75 Next = KnownLatest(*reinterpret_cast<const ASTContext *>( 76 NKL.get<UninitializedLatest>()), 77 const_cast<decl_type *>(D)); 78 } 79 80 return static_cast<decl_type*>(Next.get<KnownLatest>().get(D)); 81 } 82 83 void setPrevious(decl_type *D) { 84 assert(NextIsPrevious() && "decl became non-canonical unexpectedly"); 85 Next = Previous(D); 86 } 87 88 void setLatest(decl_type *D) { 89 assert(NextIsLatest() && "decl became canonical unexpectedly"); 90 if (Next.is<NotKnownLatest>()) { 91 NotKnownLatest NKL = Next.get<NotKnownLatest>(); 92 Next = KnownLatest(*reinterpret_cast<const ASTContext *>( 93 NKL.get<UninitializedLatest>()), 94 D); 95 } else { 96 auto Latest = Next.get<KnownLatest>(); 97 Latest.set(D); 98 Next = Latest; 99 } 100 } 101 102 void markIncomplete() { Next.get<KnownLatest>().markIncomplete(); } 103 104 Decl *getLatestNotUpdated() const { 105 assert(NextIsLatest() && "expected a canonical decl"); 106 if (Next.is<NotKnownLatest>()) 107 return nullptr; 108 return Next.get<KnownLatest>().getNotUpdated(); 109 } 110 }; 111 112 static DeclLink PreviousDeclLink(decl_type *D) { 113 return DeclLink(DeclLink::PreviousLink, D); 114 } 115 116 static DeclLink LatestDeclLink(const ASTContext &Ctx) { 117 return DeclLink(DeclLink::LatestLink, Ctx); 118 } 119 120 /// \brief Points to the next redeclaration in the chain. 121 /// 122 /// If NextIsPrevious() is true, this is a link to the previous declaration 123 /// of this same Decl. If NextIsLatest() is true, this is the first 124 /// declaration and Link points to the latest declaration. For example: 125 /// 126 /// #1 int f(int x, int y = 1); // <pointer to #3, true> 127 /// #2 int f(int x = 0, int y); // <pointer to #1, false> 128 /// #3 int f(int x, int y) { return x + y; } // <pointer to #2, false> 129 /// 130 /// If there is only one declaration, it is <pointer to self, true> 131 DeclLink RedeclLink; 132 decl_type *First; 133 134 decl_type *getNextRedeclaration() const { 135 return RedeclLink.getNext(static_cast<const decl_type *>(this)); 136 } 137 138 public: 139 Redeclarable(const ASTContext &Ctx) 140 : RedeclLink(LatestDeclLink(Ctx)), First(static_cast<decl_type *>(this)) {} 141 142 /// \brief Return the previous declaration of this declaration or NULL if this 143 /// is the first declaration. 144 decl_type *getPreviousDecl() { 145 if (RedeclLink.NextIsPrevious()) 146 return getNextRedeclaration(); 147 return nullptr; 148 } 149 const decl_type *getPreviousDecl() const { 150 return const_cast<decl_type *>( 151 static_cast<const decl_type*>(this))->getPreviousDecl(); 152 } 153 154 /// \brief Return the first declaration of this declaration or itself if this 155 /// is the only declaration. 156 decl_type *getFirstDecl() { return First; } 157 158 /// \brief Return the first declaration of this declaration or itself if this 159 /// is the only declaration. 160 const decl_type *getFirstDecl() const { return First; } 161 162 /// \brief True if this is the first declaration in its redeclaration chain. 163 bool isFirstDecl() const { return RedeclLink.NextIsLatest(); } 164 165 /// \brief Returns the most recent (re)declaration of this declaration. 166 decl_type *getMostRecentDecl() { 167 return getFirstDecl()->getNextRedeclaration(); 168 } 169 170 /// \brief Returns the most recent (re)declaration of this declaration. 171 const decl_type *getMostRecentDecl() const { 172 return getFirstDecl()->getNextRedeclaration(); 173 } 174 175 /// \brief Set the previous declaration. If PrevDecl is NULL, set this as the 176 /// first and only declaration. 177 void setPreviousDecl(decl_type *PrevDecl); 178 179 /// \brief Iterates through all the redeclarations of the same decl. 180 class redecl_iterator { 181 /// Current - The current declaration. 182 decl_type *Current; 183 decl_type *Starter; 184 bool PassedFirst; 185 186 public: 187 typedef decl_type* value_type; 188 typedef decl_type* reference; 189 typedef decl_type* pointer; 190 typedef std::forward_iterator_tag iterator_category; 191 typedef std::ptrdiff_t difference_type; 192 193 redecl_iterator() : Current(nullptr) { } 194 explicit redecl_iterator(decl_type *C) 195 : Current(C), Starter(C), PassedFirst(false) { } 196 197 reference operator*() const { return Current; } 198 pointer operator->() const { return Current; } 199 200 redecl_iterator& operator++() { 201 assert(Current && "Advancing while iterator has reached end"); 202 // Sanity check to avoid infinite loop on invalid redecl chain. 203 if (Current->isFirstDecl()) { 204 if (PassedFirst) { 205 assert(0 && "Passed first decl twice, invalid redecl chain!"); 206 Current = nullptr; 207 return *this; 208 } 209 PassedFirst = true; 210 } 211 212 // Get either previous decl or latest decl. 213 decl_type *Next = Current->getNextRedeclaration(); 214 Current = (Next != Starter) ? Next : nullptr; 215 return *this; 216 } 217 218 redecl_iterator operator++(int) { 219 redecl_iterator tmp(*this); 220 ++(*this); 221 return tmp; 222 } 223 224 friend bool operator==(redecl_iterator x, redecl_iterator y) { 225 return x.Current == y.Current; 226 } 227 friend bool operator!=(redecl_iterator x, redecl_iterator y) { 228 return x.Current != y.Current; 229 } 230 }; 231 232 typedef llvm::iterator_range<redecl_iterator> redecl_range; 233 234 /// \brief Returns an iterator range for all the redeclarations of the same 235 /// decl. It will iterate at least once (when this decl is the only one). 236 redecl_range redecls() const { 237 return redecl_range(redecl_iterator(const_cast<decl_type *>( 238 static_cast<const decl_type *>(this))), 239 redecl_iterator()); 240 } 241 242 redecl_iterator redecls_begin() const { return redecls().begin(); } 243 redecl_iterator redecls_end() const { return redecls().end(); } 244 245 friend class ASTDeclReader; 246 friend class ASTDeclWriter; 247 }; 248 249 /// \brief Get the primary declaration for a declaration from an AST file. That 250 /// will be the first-loaded declaration. 251 Decl *getPrimaryMergedDecl(Decl *D); 252 253 /// \brief Provides common interface for the Decls that cannot be redeclared, 254 /// but can be merged if the same declaration is brought in from multiple 255 /// modules. 256 template<typename decl_type> 257 class Mergeable { 258 public: 259 Mergeable() {} 260 261 /// \brief Return the first declaration of this declaration or itself if this 262 /// is the only declaration. 263 decl_type *getFirstDecl() { 264 decl_type *D = static_cast<decl_type*>(this); 265 if (!D->isFromASTFile()) 266 return D; 267 return cast<decl_type>(getPrimaryMergedDecl(const_cast<decl_type*>(D))); 268 } 269 270 /// \brief Return the first declaration of this declaration or itself if this 271 /// is the only declaration. 272 const decl_type *getFirstDecl() const { 273 const decl_type *D = static_cast<const decl_type*>(this); 274 if (!D->isFromASTFile()) 275 return D; 276 return cast<decl_type>(getPrimaryMergedDecl(const_cast<decl_type*>(D))); 277 } 278 279 /// \brief Returns true if this is the first declaration. 280 bool isFirstDecl() const { return getFirstDecl() == this; } 281 }; 282 283 } 284 285 #endif 286
