text: //===-- DeclContextInternals.h - DeclContext Representation -----*- C++ -*-===//
  //
  //                     The LLVM Compiler Infrastructure
  //
  // This file is distributed under the University of Illinois Open Source
  // License. See LICENSE.TXT for details.
  //
  //===----------------------------------------------------------------------===//
  //
  //  This file defines the data structures used in the implementation
  //  of DeclContext.
  //
  //===----------------------------------------------------------------------===//
  #ifndef LLVM_CLANG_AST_DECLCONTEXTINTERNALS_H
  #define LLVM_CLANG_AST_DECLCONTEXTINTERNALS_H
  
  #include "clang/AST/Decl.h"
  #include "clang/AST/DeclCXX.h"
  #include "clang/AST/DeclarationName.h"
  #include "llvm/ADT/DenseMap.h"
  #include "llvm/ADT/PointerIntPair.h"
  #include "llvm/ADT/PointerUnion.h"
  #include "llvm/ADT/SmallVector.h"
  #include <algorithm>
  
  namespace clang {
  
  class DependentDiagnostic;
  
  /// \brief An array of decls optimized for the common case of only containing
  /// one entry.
  struct StoredDeclsList {
  
    /// \brief When in vector form, this is what the Data pointer points to.
    typedef SmallVector<NamedDecl *, 4> DeclsTy;
  
    /// \brief A collection of declarations, with a flag to indicate if we have
    /// further external declarations.
    typedef llvm::PointerIntPair<DeclsTy *, 1, bool> DeclsAndHasExternalTy;
  
    /// \brief The stored data, which will be either a pointer to a NamedDecl,
    /// or a pointer to a vector with a flag to indicate if there are further
    /// external declarations.
    llvm::PointerUnion<NamedDecl*, DeclsAndHasExternalTy> Data;
  
  public:
    StoredDeclsList() {}
  
    StoredDeclsList(StoredDeclsList &&RHS) : Data(RHS.Data) {
      RHS.Data = (NamedDecl *)nullptr;
    }
  
    ~StoredDeclsList() {
      // If this is a vector-form, free the vector.
      if (DeclsTy *Vector = getAsVector())
        delete Vector;
    }
  
    StoredDeclsList &operator=(StoredDeclsList &&RHS) {
      if (DeclsTy *Vector = getAsVector())
        delete Vector;
      Data = RHS.Data;
      RHS.Data = (NamedDecl *)nullptr;
      return *this;
    }
  
    bool isNull() const { return Data.isNull(); }
  
    NamedDecl *getAsDecl() const {
      return Data.dyn_cast<NamedDecl *>();
    }
  
    DeclsAndHasExternalTy getAsVectorAndHasExternal() const {
      return Data.dyn_cast<DeclsAndHasExternalTy>();
    }
  
    DeclsTy *getAsVector() const {
      return getAsVectorAndHasExternal().getPointer();
    }
  
    bool hasExternalDecls() const {
      return getAsVectorAndHasExternal().getInt();
    }
  
    void setHasExternalDecls() {
      if (DeclsTy *Vec = getAsVector())
        Data = DeclsAndHasExternalTy(Vec, true);
      else {
        DeclsTy *VT = new DeclsTy();
        if (NamedDecl *OldD = getAsDecl())
          VT->push_back(OldD);
        Data = DeclsAndHasExternalTy(VT, true);
      }
    }
  
    void setOnlyValue(NamedDecl *ND) {
      assert(!getAsVector() && "Not inline");
      Data = ND;
      // Make sure that Data is a plain NamedDecl* so we can use its address
      // at getLookupResult.
      assert(*(NamedDecl **)&Data == ND &&
             "PointerUnion mangles the NamedDecl pointer!");
    }
  
    void remove(NamedDecl *D) {
      assert(!isNull() && "removing from empty list");
      if (NamedDecl *Singleton = getAsDecl()) {
        assert(Singleton == D && "list is different singleton");
        (void)Singleton;
        Data = (NamedDecl *)nullptr;
        return;
      }
  
      DeclsTy &Vec = *getAsVector();
      DeclsTy::iterator I = std::find(Vec.begin(), Vec.end(), D);
      assert(I != Vec.end() && "list does not contain decl");
      Vec.erase(I);
  
      assert(std::find(Vec.begin(), Vec.end(), D)
               == Vec.end() && "list still contains decl");
    }
  
    /// \brief Remove any declarations which were imported from an external
    /// AST source.
    void removeExternalDecls() {
      if (isNull()) {
        // Nothing to do.
      } else if (NamedDecl *Singleton = getAsDecl()) {
        if (Singleton->isFromASTFile())
          *this = StoredDeclsList();
      } else {
        DeclsTy &Vec = *getAsVector();
        Vec.erase(std::remove_if(Vec.begin(), Vec.end(),
                                 std::mem_fn(&Decl::isFromASTFile)),
                  Vec.end());
        // Don't have any external decls any more.
        Data = DeclsAndHasExternalTy(&Vec, false);
      }
    }
  
    /// getLookupResult - Return an array of all the decls that this list
    /// represents.
    DeclContext::lookup_result getLookupResult() {
      if (isNull())
        return DeclContext::lookup_result();
  
      // If we have a single NamedDecl, return it.
      if (NamedDecl *ND = getAsDecl()) {
        assert(!isNull() && "Empty list isn't allowed");
  
        // Data is a raw pointer to a NamedDecl*, return it.
        return DeclContext::lookup_result(ND);
      }
  
      assert(getAsVector() && "Must have a vector at this point");
      DeclsTy &Vector = *getAsVector();
  
      // Otherwise, we have a range result.
      return DeclContext::lookup_result(Vector);
    }
  
    /// HandleRedeclaration - If this is a redeclaration of an existing decl,
    /// replace the old one with D and return true.  Otherwise return false.
    bool HandleRedeclaration(NamedDecl *D, bool IsKnownNewer) {
      // Most decls only have one entry in their list, special case it.
      if (NamedDecl *OldD = getAsDecl()) {
        if (!D->declarationReplaces(OldD, IsKnownNewer))
          return false;
        setOnlyValue(D);
        return true;
      }
  
      // Determine if this declaration is actually a redeclaration.
      DeclsTy &Vec = *getAsVector();
      for (DeclsTy::iterator OD = Vec.begin(), ODEnd = Vec.end();
           OD != ODEnd; ++OD) {
        NamedDecl *OldD = *OD;
        if (D->declarationReplaces(OldD, IsKnownNewer)) {
          *OD = D;
          return true;
        }
      }
  
      return false;
    }
  
    /// AddSubsequentDecl - This is called on the second and later decl when it is
    /// not a redeclaration to merge it into the appropriate place in our list.
    ///
    void AddSubsequentDecl(NamedDecl *D) {
      assert(!isNull() && "don't AddSubsequentDecl when we have no decls");
  
      // If this is the second decl added to the list, convert this to vector
      // form.
      if (NamedDecl *OldD = getAsDecl()) {
        DeclsTy *VT = new DeclsTy();
        VT->push_back(OldD);
        Data = DeclsAndHasExternalTy(VT, false);
      }
  
      DeclsTy &Vec = *getAsVector();
  
      // Using directives end up in a special entry which contains only
      // other using directives, so all this logic is wasted for them.
      // But avoiding the logic wastes time in the far-more-common case
      // that we're *not* adding a new using directive.
  
      // Tag declarations always go at the end of the list so that an
      // iterator which points at the first tag will start a span of
      // decls that only contains tags.
      if (D->hasTagIdentifierNamespace())
        Vec.push_back(D);
  
      // Resolved using declarations go at the front of the list so that
      // they won't show up in other lookup results.  Unresolved using
      // declarations (which are always in IDNS_Using | IDNS_Ordinary)
      // follow that so that the using declarations will be contiguous.
      else if (D->getIdentifierNamespace() & Decl::IDNS_Using) {
        DeclsTy::iterator I = Vec.begin();
        if (D->getIdentifierNamespace() != Decl::IDNS_Using) {
          while (I != Vec.end() &&
                 (*I)->getIdentifierNamespace() == Decl::IDNS_Using)
            ++I;
        }
        Vec.insert(I, D);
  
      // All other declarations go at the end of the list, but before any
      // tag declarations.  But we can be clever about tag declarations
      // because there can only ever be one in a scope.
      } else if (!Vec.empty() && Vec.back()->hasTagIdentifierNamespace()) {
        NamedDecl *TagD = Vec.back();
        Vec.back() = D;
        Vec.push_back(TagD);
      } else
        Vec.push_back(D);
    }
  };
  
  class StoredDeclsMap
    : public llvm::SmallDenseMap<DeclarationName, StoredDeclsList, 4> {
  
  public:
    static void DestroyAll(StoredDeclsMap *Map, bool Dependent);
  
  private:
    friend class ASTContext; // walks the chain deleting these
    friend class DeclContext;
    llvm::PointerIntPair<StoredDeclsMap*, 1> Previous;
  };
  
  class DependentStoredDeclsMap : public StoredDeclsMap {
  public:
    DependentStoredDeclsMap() : FirstDiagnostic(nullptr) {}
  
  private:
    friend class DependentDiagnostic;
    friend class DeclContext; // iterates over diagnostics
  
    DependentDiagnostic *FirstDiagnostic;
  };
  
  } // end namespace clang
  
  #endif
  