1//===-- DeclContextInternals.h - DeclContext Representation -----*- 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 data structures used in the implementation
11//  of DeclContext.
12//
13//===----------------------------------------------------------------------===//
14#ifndef LLVM_CLANG_AST_DECLCONTEXTINTERNALS_H
15#define LLVM_CLANG_AST_DECLCONTEXTINTERNALS_H
16
17#include "clang/AST/Decl.h"
18#include "clang/AST/DeclCXX.h"
19#include "clang/AST/DeclarationName.h"
20#include "llvm/ADT/DenseMap.h"
21#include "llvm/ADT/PointerUnion.h"
22#include "llvm/ADT/SmallVector.h"
23#include <algorithm>
24
25namespace clang {
26
27class DependentDiagnostic;
28
29/// StoredDeclsList - This is an array of decls optimized a common case of only
30/// containing one entry.
31struct StoredDeclsList {
32
33  /// DeclsTy - When in vector form, this is what the Data pointer points to.
34  typedef SmallVector<NamedDecl *, 4> DeclsTy;
35
36  /// \brief The stored data, which will be either a pointer to a NamedDecl,
37  /// or a pointer to a vector.
38  llvm::PointerUnion<NamedDecl *, DeclsTy *> Data;
39
40public:
41  StoredDeclsList() {}
42
43  StoredDeclsList(const StoredDeclsList &RHS) : Data(RHS.Data) {
44    if (DeclsTy *RHSVec = RHS.getAsVector())
45      Data = new DeclsTy(*RHSVec);
46  }
47
48  ~StoredDeclsList() {
49    // If this is a vector-form, free the vector.
50    if (DeclsTy *Vector = getAsVector())
51      delete Vector;
52  }
53
54  StoredDeclsList &operator=(const StoredDeclsList &RHS) {
55    if (DeclsTy *Vector = getAsVector())
56      delete Vector;
57    Data = RHS.Data;
58    if (DeclsTy *RHSVec = RHS.getAsVector())
59      Data = new DeclsTy(*RHSVec);
60    return *this;
61  }
62
63  bool isNull() const { return Data.isNull(); }
64
65  NamedDecl *getAsDecl() const {
66    return Data.dyn_cast<NamedDecl *>();
67  }
68
69  DeclsTy *getAsVector() const {
70    return Data.dyn_cast<DeclsTy *>();
71  }
72
73  void setOnlyValue(NamedDecl *ND) {
74    assert(!getAsVector() && "Not inline");
75    Data = ND;
76    // Make sure that Data is a plain NamedDecl* so we can use its address
77    // at getLookupResult.
78    assert(*(NamedDecl **)&Data == ND &&
79           "PointerUnion mangles the NamedDecl pointer!");
80  }
81
82  void remove(NamedDecl *D) {
83    assert(!isNull() && "removing from empty list");
84    if (NamedDecl *Singleton = getAsDecl()) {
85      assert(Singleton == D && "list is different singleton");
86      (void)Singleton;
87      Data = (NamedDecl *)0;
88      return;
89    }
90
91    DeclsTy &Vec = *getAsVector();
92    DeclsTy::iterator I = std::find(Vec.begin(), Vec.end(), D);
93    assert(I != Vec.end() && "list does not contain decl");
94    Vec.erase(I);
95
96    assert(std::find(Vec.begin(), Vec.end(), D)
97             == Vec.end() && "list still contains decl");
98  }
99
100  /// \brief Remove any declarations which were imported from an external
101  /// AST source.
102  void removeExternalDecls() {
103    if (isNull()) {
104      // Nothing to do.
105    } else if (NamedDecl *Singleton = getAsDecl()) {
106      if (Singleton->isFromASTFile())
107        *this = StoredDeclsList();
108    } else {
109      DeclsTy &Vec = *getAsVector();
110      Vec.erase(std::remove_if(Vec.begin(), Vec.end(),
111                               std::mem_fun(&Decl::isFromASTFile)),
112                Vec.end());
113    }
114  }
115
116  /// getLookupResult - Return an array of all the decls that this list
117  /// represents.
118  DeclContext::lookup_result getLookupResult() {
119    if (isNull())
120      return DeclContext::lookup_result(DeclContext::lookup_iterator(0),
121                                        DeclContext::lookup_iterator(0));
122
123    // If we have a single NamedDecl, return it.
124    if (getAsDecl()) {
125      assert(!isNull() && "Empty list isn't allowed");
126
127      // Data is a raw pointer to a NamedDecl*, return it.
128      void *Ptr = &Data;
129      return DeclContext::lookup_result((NamedDecl**)Ptr, (NamedDecl**)Ptr+1);
130    }
131
132    assert(getAsVector() && "Must have a vector at this point");
133    DeclsTy &Vector = *getAsVector();
134
135    // Otherwise, we have a range result.
136    return DeclContext::lookup_result(Vector.begin(), Vector.end());
137  }
138
139  /// HandleRedeclaration - If this is a redeclaration of an existing decl,
140  /// replace the old one with D and return true.  Otherwise return false.
141  bool HandleRedeclaration(NamedDecl *D) {
142    // Most decls only have one entry in their list, special case it.
143    if (NamedDecl *OldD = getAsDecl()) {
144      if (!D->declarationReplaces(OldD))
145        return false;
146      setOnlyValue(D);
147      return true;
148    }
149
150    // Determine if this declaration is actually a redeclaration.
151    DeclsTy &Vec = *getAsVector();
152    for (DeclsTy::iterator OD = Vec.begin(), ODEnd = Vec.end();
153         OD != ODEnd; ++OD) {
154      NamedDecl *OldD = *OD;
155      if (D->declarationReplaces(OldD)) {
156        *OD = D;
157        return true;
158      }
159    }
160
161    return false;
162  }
163
164  /// AddSubsequentDecl - This is called on the second and later decl when it is
165  /// not a redeclaration to merge it into the appropriate place in our list.
166  ///
167  void AddSubsequentDecl(NamedDecl *D) {
168    // If this is the second decl added to the list, convert this to vector
169    // form.
170    if (NamedDecl *OldD = getAsDecl()) {
171      DeclsTy *VT = new DeclsTy();
172      VT->push_back(OldD);
173      Data = VT;
174    }
175
176    DeclsTy &Vec = *getAsVector();
177
178    // Using directives end up in a special entry which contains only
179    // other using directives, so all this logic is wasted for them.
180    // But avoiding the logic wastes time in the far-more-common case
181    // that we're *not* adding a new using directive.
182
183    // Tag declarations always go at the end of the list so that an
184    // iterator which points at the first tag will start a span of
185    // decls that only contains tags.
186    if (D->hasTagIdentifierNamespace())
187      Vec.push_back(D);
188
189    // Resolved using declarations go at the front of the list so that
190    // they won't show up in other lookup results.  Unresolved using
191    // declarations (which are always in IDNS_Using | IDNS_Ordinary)
192    // follow that so that the using declarations will be contiguous.
193    else if (D->getIdentifierNamespace() & Decl::IDNS_Using) {
194      DeclsTy::iterator I = Vec.begin();
195      if (D->getIdentifierNamespace() != Decl::IDNS_Using) {
196        while (I != Vec.end() &&
197               (*I)->getIdentifierNamespace() == Decl::IDNS_Using)
198          ++I;
199      }
200      Vec.insert(I, D);
201
202    // All other declarations go at the end of the list, but before any
203    // tag declarations.  But we can be clever about tag declarations
204    // because there can only ever be one in a scope.
205    } else if (!Vec.empty() && Vec.back()->hasTagIdentifierNamespace()) {
206      NamedDecl *TagD = Vec.back();
207      Vec.back() = D;
208      Vec.push_back(TagD);
209    } else
210      Vec.push_back(D);
211  }
212};
213
214class StoredDeclsMap
215  : public llvm::SmallDenseMap<DeclarationName, StoredDeclsList, 4> {
216
217public:
218  static void DestroyAll(StoredDeclsMap *Map, bool Dependent);
219
220private:
221  friend class ASTContext; // walks the chain deleting these
222  friend class DeclContext;
223  llvm::PointerIntPair<StoredDeclsMap*, 1> Previous;
224};
225
226class DependentStoredDeclsMap : public StoredDeclsMap {
227public:
228  DependentStoredDeclsMap() : FirstDiagnostic(0) {}
229
230private:
231  friend class DependentDiagnostic;
232  friend class DeclContext; // iterates over diagnostics
233
234  DependentDiagnostic *FirstDiagnostic;
235};
236
237} // end namespace clang
238
239#endif
240