clang  9.0.0svn
ASTUnresolvedSet.h
Go to the documentation of this file.
1 //===- ASTUnresolvedSet.h - Unresolved sets of declarations -----*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file provides an UnresolvedSet-like class, whose contents are
10 // allocated using the allocator associated with an ASTContext.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #ifndef LLVM_CLANG_AST_ASTUNRESOLVEDSET_H
15 #define LLVM_CLANG_AST_ASTUNRESOLVEDSET_H
16 
17 #include "clang/AST/ASTVector.h"
20 #include "clang/Basic/Specifiers.h"
21 #include <cassert>
22 #include <cstdint>
23 
24 namespace clang {
25 
26 class NamedDecl;
27 
28 /// An UnresolvedSet-like class which uses the ASTContext's allocator.
30  friend class LazyASTUnresolvedSet;
31 
32  struct DeclsTy : ASTVector<DeclAccessPair> {
33  DeclsTy() = default;
34  DeclsTy(ASTContext &C, unsigned N) : ASTVector<DeclAccessPair>(C, N) {}
35 
36  bool isLazy() const { return getTag(); }
37  void setLazy(bool Lazy) { setTag(Lazy); }
38  };
39 
40  DeclsTy Decls;
41 
42 public:
43  ASTUnresolvedSet() = default;
44  ASTUnresolvedSet(ASTContext &C, unsigned N) : Decls(C, N) {}
45 
48 
49  iterator begin() { return iterator(Decls.begin()); }
50  iterator end() { return iterator(Decls.end()); }
51 
52  const_iterator begin() const { return const_iterator(Decls.begin()); }
53  const_iterator end() const { return const_iterator(Decls.end()); }
54 
56  Decls.push_back(DeclAccessPair::make(D, AS), C);
57  }
58 
59  /// Replaces the given declaration with the new one, once.
60  ///
61  /// \return true if the set changed
62  bool replace(const NamedDecl *Old, NamedDecl *New, AccessSpecifier AS) {
63  for (DeclsTy::iterator I = Decls.begin(), E = Decls.end(); I != E; ++I) {
64  if (I->getDecl() == Old) {
65  I->set(New, AS);
66  return true;
67  }
68  }
69  return false;
70  }
71 
72  void erase(unsigned I) { Decls[I] = Decls.pop_back_val(); }
73 
74  void clear() { Decls.clear(); }
75 
76  bool empty() const { return Decls.empty(); }
77  unsigned size() const { return Decls.size(); }
78 
79  void reserve(ASTContext &C, unsigned N) {
80  Decls.reserve(C, N);
81  }
82 
84  Decls.append(C, I.I, E.I);
85  }
86 
87  DeclAccessPair &operator[](unsigned I) { return Decls[I]; }
88  const DeclAccessPair &operator[](unsigned I) const { return Decls[I]; }
89 };
90 
91 /// An UnresolvedSet-like class that might not have been loaded from the
92 /// external AST source yet.
94  mutable ASTUnresolvedSet Impl;
95 
96  void getFromExternalSource(ASTContext &C) const;
97 
98 public:
99  ASTUnresolvedSet &get(ASTContext &C) const {
100  if (Impl.Decls.isLazy())
101  getFromExternalSource(C);
102  return Impl;
103  }
104 
105  void reserve(ASTContext &C, unsigned N) { Impl.reserve(C, N); }
106 
108  assert(Impl.empty() || Impl.Decls.isLazy());
109  Impl.Decls.setLazy(true);
110  Impl.addDecl(C, reinterpret_cast<NamedDecl *>(ID << 2), AS);
111  }
112 };
113 
114 } // namespace clang
115 
116 #endif // LLVM_CLANG_AST_ASTUNRESOLVEDSET_H
bool replace(const NamedDecl *Old, NamedDecl *New, AccessSpecifier AS)
Replaces the given declaration with the new one, once.
void erase(unsigned I)
void append(ASTContext &C, iterator I, iterator E)
UnresolvedSetIterator iterator
AccessSpecifier
A C++ access specifier (public, private, protected), plus the special value "none" which means differ...
Definition: Specifiers.h:97
An UnresolvedSet-like class that might not have been loaded from the external AST source yet...
void addLazyDecl(ASTContext &C, uintptr_t ID, AccessSpecifier AS)
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:154
const_iterator begin() const
The iterator over UnresolvedSets.
Definition: UnresolvedSet.h:31
void addDecl(ASTContext &C, NamedDecl *D, AccessSpecifier AS)
static DeclAccessPair make(NamedDecl *D, AccessSpecifier AS)
void reserve(ASTContext &C, unsigned N)
__UINTPTR_TYPE__ uintptr_t
An unsigned integer type with the property that any valid pointer to void can be converted to this ty...
Definition: opencl-c.h:89
const_iterator end() const
ASTUnresolvedSet(ASTContext &C, unsigned N)
Defines various enumerations that describe declaration and type specifiers.
A POD class for pairing a NamedDecl* with an access specifier.
Dataflow Directional Tag Classes.
void reserve(ASTContext &C, unsigned N)
An UnresolvedSet-like class which uses the ASTContext&#39;s allocator.
DeclAccessPair & operator[](unsigned I)
UnresolvedSetIterator const_iterator
const DeclAccessPair & operator[](unsigned I) const
This represents a decl that may have a name.
Definition: Decl.h:248