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 "llvm/ADT/PointerIntPair.h"
  18 #include "llvm/Support/Casting.h"
  19 #include <iterator>
  20
  21 namespace clang {
  22
  23 /// \brief Provides common interface for the Decls that can be redeclared.
  24 template<typename decl_type>
  25 class Redeclarable {
  26
  27 protected:
  28   class DeclLink {
  29     llvm::PointerIntPair<decl_type *, 1, bool> NextAndIsPrevious;
  30   public:
  31     DeclLink(decl_type *D, bool isLatest)
  32       : NextAndIsPrevious(D, isLatest) { }
  33
  34     bool NextIsPrevious() const { return !NextAndIsPrevious.getInt(); }
  35     bool NextIsLatest() const { return NextAndIsPrevious.getInt(); }
  36     decl_type *getNext() const { return NextAndIsPrevious.getPointer(); }
  37     void setNext(decl_type *D) { NextAndIsPrevious.setPointer(D); }
  38   };
  39
  40   static DeclLink PreviousDeclLink(decl_type *D) {
  41     return DeclLink(D, false);
  42   }
  43
  44   static DeclLink LatestDeclLink(decl_type *D) {
  45     return DeclLink(D, true);
  46   }
  47
  48   /// \brief Points to the next redeclaration in the chain.
  49   ///
  50   /// If NextIsPrevious() is true, this is a link to the previous declaration
  51   /// of this same Decl. If NextIsLatest() is true, this is the first
  52   /// declaration and Link points to the latest declaration. For example:
  53   ///
  54   ///  #1 int f(int x, int y = 1); // <pointer to #3, true>
  55   ///  #2 int f(int x = 0, int y); // <pointer to #1, false>
  56   ///  #3 int f(int x, int y) { return x + y; } // <pointer to #2, false>
  57   ///
  58   /// If there is only one declaration, it is <pointer to self, true>
  59   DeclLink RedeclLink;
  60
  61 public:
  62   Redeclarable() : RedeclLink(LatestDeclLink(static_cast<decl_type*>(this))) { }
  63
  64   /// \brief Return the previous declaration of this declaration or NULL if this
  65   /// is the first declaration.
  66   decl_type *getPreviousDecl() {
  67     if (RedeclLink.NextIsPrevious())
  68       return RedeclLink.getNext();
  69     return 0;
  70   }
  71   const decl_type *getPreviousDecl() const {
  72     return const_cast<decl_type *>(
  73                  static_cast<const decl_type*>(this))->getPreviousDecl();
  74   }
  75
  76   /// \brief Return the first declaration of this declaration or itself if this
  77   /// is the only declaration.
  78   decl_type *getFirstDeclaration() {
  79     decl_type *D = static_cast<decl_type*>(this);
  80     while (D->getPreviousDecl())
  81       D = D->getPreviousDecl();
  82     return D;
  83   }
  84
  85   /// \brief Return the first declaration of this declaration or itself if this
  86   /// is the only declaration.
  87   const decl_type *getFirstDeclaration() const {
  88     const decl_type *D = static_cast<const decl_type*>(this);
  89     while (D->getPreviousDecl())
  90       D = D->getPreviousDecl();
  91     return D;
  92   }
  93
  94   /// \brief Returns true if this is the first declaration.
  95   bool isFirstDeclaration() const {
  96     return RedeclLink.NextIsLatest();
  97   }
  98
  99   /// \brief Returns the most recent (re)declaration of this declaration.
 100   decl_type *getMostRecentDecl() {
 101     return getFirstDeclaration()->RedeclLink.getNext();
 102   }
 103
 104   /// \brief Returns the most recent (re)declaration of this declaration.
 105   const decl_type *getMostRecentDecl() const {
 106     return getFirstDeclaration()->RedeclLink.getNext();
 107   }
 108
 109   /// \brief Set the previous declaration. If PrevDecl is NULL, set this as the
 110   /// first and only declaration.
 111   void setPreviousDeclaration(decl_type *PrevDecl);
 112
 113   /// \brief Iterates through all the redeclarations of the same decl.
 114   class redecl_iterator {
 115     /// Current - The current declaration.
 116     decl_type *Current;
 117     decl_type *Starter;
 118     bool PassedFirst;
 119
 120   public:
 121     typedef decl_type*                value_type;
 122     typedef decl_type*                reference;
 123     typedef decl_type*                pointer;
 124     typedef std::forward_iterator_tag iterator_category;
 125     typedef std::ptrdiff_t            difference_type;
 126
 127     redecl_iterator() : Current(0) { }
 128     explicit redecl_iterator(decl_type *C)
 129       : Current(C), Starter(C), PassedFirst(false) { }
 130
 131     reference operator*() const { return Current; }
 132     pointer operator->() const { return Current; }
 133
 134     redecl_iterator& operator++() {
 135       assert(Current && "Advancing while iterator has reached end");
 136       // Sanity check to avoid infinite loop on invalid redecl chain.
 137       if (Current->isFirstDeclaration()) {
 138         if (PassedFirst) {
 139           assert(0 && "Passed first decl twice, invalid redecl chain!");
 140           Current = 0;
 141           return *this;
 142         }
 143         PassedFirst = true;
 144       }
 145
 146       // Get either previous decl or latest decl.
 147       decl_type *Next = Current->RedeclLink.getNext();
 148       Current = (Next != Starter ? Next : 0);
 149       return *this;
 150     }
 151
 152     redecl_iterator operator++(int) {
 153       redecl_iterator tmp(*this);
 154       ++(*this);
 155       return tmp;
 156     }
 157
 158     friend bool operator==(redecl_iterator x, redecl_iterator y) {
 159       return x.Current == y.Current;
 160     }
 161     friend bool operator!=(redecl_iterator x, redecl_iterator y) {
 162       return x.Current != y.Current;
 163     }
 164   };
 165
 166   /// \brief Returns iterator for all the redeclarations of the same decl.
 167   /// It will iterate at least once (when this decl is the only one).
 168   redecl_iterator redecls_begin() const {
 169     return redecl_iterator(const_cast<decl_type*>(
 170                                           static_cast<const decl_type*>(this)));
 171   }
 172   redecl_iterator redecls_end() const { return redecl_iterator(); }
 173
 174   friend class ASTDeclReader;
 175   friend class ASTDeclWriter;
 176 };
 177
 178 }
 179
 180 #endif