Home | History | Annotate | Line # | Download | only in AST 
      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"
     18 #include "clang/AST/DeclAccessPair.h"
     19 #include "clang/AST/UnresolvedSet.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.
     29 class ASTUnresolvedSet {
     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 
     46   using iterator = UnresolvedSetIterator;
     47   using const_iterator = UnresolvedSetIterator;
     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 
     55   void addDecl(ASTContext &C, NamedDecl *D, AccessSpecifier AS) {
     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 
     83   void append(ASTContext &C, iterator I, iterator E) {
     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.
     93 class LazyASTUnresolvedSet {
     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 
    107   void addLazyDecl(ASTContext &C, uintptr_t ID, AccessSpecifier AS) {
    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
    117