Coverage Report

Created: 2018-07-19 20:53

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