Redeclarable.h revision 4ed0122c1b795379cc4e11dfd62312358dcbf506 
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
21namespace clang {
22
23/// \brief Provides common interface for the Decls that can be redeclared.
24template<typename decl_type>
25class Redeclarable {
26
27protected:
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
61public:
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/// \brief Get the primary declaration for a declaration from an AST file. That
179/// will be the first-loaded declaration.
180Decl *getPrimaryMergedDecl(Decl *D);
181
182/// \brief Provides common interface for the Decls that cannot be redeclared,
183/// but can be merged if the same declaration is brought in from multiple
184/// modules.
185template<typename decl_type>
186class Mergeable {
187public:
188  Mergeable() {}
189
190  /// \brief Return the first declaration of this declaration or itself if this
191  /// is the only declaration.
192  decl_type *getFirstDeclaration() {
193    decl_type *D = static_cast<decl_type*>(this);
194    if (!D->isFromASTFile())
195      return D;
196    return cast<decl_type>(getPrimaryMergedDecl(const_cast<decl_type*>(D)));
197  }
198
199  /// \brief Return the first declaration of this declaration or itself if this
200  /// is the only declaration.
201  const decl_type *getFirstDeclaration() const {
202    const decl_type *D = static_cast<const decl_type*>(this);
203    if (!D->isFromASTFile())
204      return D;
205    return cast<decl_type>(getPrimaryMergedDecl(const_cast<decl_type*>(D)));
206  }
207
208  /// \brief Returns true if this is the first declaration.
209  bool isFirstDeclaration() const {
210    return getFirstDeclaration() == this;
211  }
212};
213
214}
215
216#endif
217