Home | History | Annotate | Download | only in AST 
      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 
     25 namespace clang {
     26 
     27 class DependentDiagnostic;
     28 
     29 /// StoredDeclsList - This is an array of decls optimized a common case of only
     30 /// containing one entry.
     31 struct 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 
     40 public:
     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 
    214 class StoredDeclsMap
    215   : public llvm::SmallDenseMap<DeclarationName, StoredDeclsList, 4> {
    216 
    217 public:
    218   static void DestroyAll(StoredDeclsMap *Map, bool Dependent);
    219 
    220 private:
    221   friend class ASTContext; // walks the chain deleting these
    222   friend class DeclContext;
    223   llvm::PointerIntPair<StoredDeclsMap*, 1> Previous;
    224 };
    225 
    226 class DependentStoredDeclsMap : public StoredDeclsMap {
    227 public:
    228   DependentStoredDeclsMap() : FirstDiagnostic(0) {}
    229 
    230 private:
    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