IdentifierResolver.h revision 355a1660d6a3c66546dfd2476b60fa7a19b70ee3 
1//===- IdentifierResolver.h - Lexical Scope Name lookup ---------*- 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 IdentifierResolver class, which is used for lexical
11// scoped lookup, based on declaration names.
12//
13//===----------------------------------------------------------------------===//
14
15#ifndef LLVM_CLANG_AST_SEMA_IDENTIFIERRESOLVER_H
16#define LLVM_CLANG_AST_SEMA_IDENTIFIERRESOLVER_H
17
18#include "clang/Basic/IdentifierTable.h"
19#include "llvm/ADT/SmallVector.h"
20
21namespace clang {
22
23class ASTContext;
24class Decl;
25class DeclContext;
26class DeclarationName;
27class ExternalPreprocessorSource;
28class NamedDecl;
29class Preprocessor;
30class Scope;
31
32/// IdentifierResolver - Keeps track of shadowed decls on enclosing
33/// scopes.  It manages the shadowing chains of declaration names and
34/// implements efficient decl lookup based on a declaration name.
35class IdentifierResolver {
36
37  /// IdDeclInfo - Keeps track of information about decls associated
38  /// to a particular declaration name. IdDeclInfos are lazily
39  /// constructed and assigned to a declaration name the first time a
40  /// decl with that declaration name is shadowed in some scope.
41  class IdDeclInfo {
42  public:
43    typedef SmallVector<NamedDecl*, 2> DeclsTy;
44
45    inline DeclsTy::iterator decls_begin() { return Decls.begin(); }
46    inline DeclsTy::iterator decls_end() { return Decls.end(); }
47
48    void AddDecl(NamedDecl *D) { Decls.push_back(D); }
49
50    /// RemoveDecl - Remove the decl from the scope chain.
51    /// The decl must already be part of the decl chain.
52    void RemoveDecl(NamedDecl *D);
53
54    /// Replaces the Old declaration with the New declaration. If the
55    /// replacement is successful, returns true. If the old
56    /// declaration was not found, returns false.
57    bool ReplaceDecl(NamedDecl *Old, NamedDecl *New);
58
59    /// \brief Insert the given declaration at the given position in the list.
60    void InsertDecl(DeclsTy::iterator Pos, NamedDecl *D) {
61      Decls.insert(Pos, D);
62    }
63
64  private:
65    DeclsTy Decls;
66  };
67
68public:
69
70  /// iterator - Iterate over the decls of a specified declaration name.
71  /// It will walk or not the parent declaration contexts depending on how
72  /// it was instantiated.
73  class iterator {
74  public:
75    typedef NamedDecl *             value_type;
76    typedef NamedDecl *             reference;
77    typedef NamedDecl *             pointer;
78    typedef std::input_iterator_tag iterator_category;
79    typedef std::ptrdiff_t          difference_type;
80
81    /// Ptr - There are 3 forms that 'Ptr' represents:
82    /// 1) A single NamedDecl. (Ptr & 0x1 == 0)
83    /// 2) A IdDeclInfo::DeclsTy::iterator that traverses only the decls of the
84    ///    same declaration context. (Ptr & 0x3 == 0x1)
85    /// 3) A IdDeclInfo::DeclsTy::iterator that traverses the decls of parent
86    ///    declaration contexts too. (Ptr & 0x3 == 0x3)
87    uintptr_t Ptr;
88    typedef IdDeclInfo::DeclsTy::iterator BaseIter;
89
90    /// A single NamedDecl. (Ptr & 0x1 == 0)
91    iterator(NamedDecl *D) {
92      Ptr = reinterpret_cast<uintptr_t>(D);
93      assert((Ptr & 0x1) == 0 && "Invalid Ptr!");
94    }
95    /// A IdDeclInfo::DeclsTy::iterator that walks or not the parent declaration
96    /// contexts depending on 'LookInParentCtx'.
97    iterator(BaseIter I) {
98      Ptr = reinterpret_cast<uintptr_t>(I) | 0x1;
99    }
100
101    bool isIterator() const { return (Ptr & 0x1); }
102
103    BaseIter getIterator() const {
104      assert(isIterator() && "Ptr not an iterator!");
105      return reinterpret_cast<BaseIter>(Ptr & ~0x3);
106    }
107
108    friend class IdentifierResolver;
109
110    void incrementSlowCase();
111  public:
112    iterator() : Ptr(0) {}
113
114    NamedDecl *operator*() const {
115      if (isIterator())
116        return *getIterator();
117      else
118        return reinterpret_cast<NamedDecl*>(Ptr);
119    }
120
121    bool operator==(const iterator &RHS) const {
122      return Ptr == RHS.Ptr;
123    }
124    bool operator!=(const iterator &RHS) const {
125      return Ptr != RHS.Ptr;
126    }
127
128    // Preincrement.
129    iterator& operator++() {
130      if (!isIterator()) // common case.
131        Ptr = 0;
132      else
133        incrementSlowCase();
134      return *this;
135    }
136
137    uintptr_t getAsOpaqueValue() const { return Ptr; }
138
139    static iterator getFromOpaqueValue(uintptr_t P) {
140      iterator Result;
141      Result.Ptr = P;
142      return Result;
143    }
144  };
145
146  /// begin - Returns an iterator for decls with the name 'Name'.
147  iterator begin(DeclarationName Name);
148
149  /// end - Returns an iterator that has 'finished'.
150  iterator end() {
151    return iterator();
152  }
153
154  /// isDeclInScope - If 'Ctx' is a function/method, isDeclInScope returns true
155  /// if 'D' is in Scope 'S', otherwise 'S' is ignored and isDeclInScope returns
156  /// true if 'D' belongs to the given declaration context.
157  ///
158  /// \param ExplicitInstantiationOrSpecialization When true, we are checking
159  /// whether the declaration is in scope for the purposes of explicit template
160  /// instantiation or specialization. The default is false.
161  bool isDeclInScope(Decl *D, DeclContext *Ctx, Scope *S = 0,
162                     bool ExplicitInstantiationOrSpecialization = false) const;
163
164  /// AddDecl - Link the decl to its shadowed decl chain.
165  void AddDecl(NamedDecl *D);
166
167  /// RemoveDecl - Unlink the decl from its shadowed decl chain.
168  /// The decl must already be part of the decl chain.
169  void RemoveDecl(NamedDecl *D);
170
171  /// Replace the decl Old with the new declaration New on its
172  /// identifier chain. Returns true if the old declaration was found
173  /// (and, therefore, replaced).
174  bool ReplaceDecl(NamedDecl *Old, NamedDecl *New);
175
176  /// \brief Insert the given declaration after the given iterator
177  /// position.
178  void InsertDeclAfter(iterator Pos, NamedDecl *D);
179
180  /// \brief Try to add the given declaration to the top level scope, if it
181  /// (or a redeclaration of it) hasn't already been added.
182  ///
183  /// \param D The externally-produced declaration to add.
184  ///
185  /// \param Name The name of the externally-produced declaration.
186  ///
187  /// \returns true if the declaration was added, false otherwise.
188  bool tryAddTopLevelDecl(NamedDecl *D, DeclarationName Name);
189
190  explicit IdentifierResolver(Preprocessor &PP);
191  ~IdentifierResolver();
192
193private:
194  const LangOptions &LangOpt;
195  Preprocessor &PP;
196
197  class IdDeclInfoMap;
198  IdDeclInfoMap *IdDeclInfos;
199
200  void updatingIdentifier(IdentifierInfo &II);
201  void readingIdentifier(IdentifierInfo &II);
202
203  /// FETokenInfo contains a Decl pointer if lower bit == 0.
204  static inline bool isDeclPtr(void *Ptr) {
205    return (reinterpret_cast<uintptr_t>(Ptr) & 0x1) == 0;
206  }
207
208  /// FETokenInfo contains a IdDeclInfo pointer if lower bit == 1.
209  static inline IdDeclInfo *toIdDeclInfo(void *Ptr) {
210    assert((reinterpret_cast<uintptr_t>(Ptr) & 0x1) == 1
211          && "Ptr not a IdDeclInfo* !");
212    return reinterpret_cast<IdDeclInfo*>(
213                    reinterpret_cast<uintptr_t>(Ptr) & ~0x1
214                                                            );
215  }
216};
217
218} // end namespace clang
219
220#endif
221