contrib/llvm/tools/clang/include/clang/AST/Redeclarable.h

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