Give UnresolvedSet the ability to store access specifiers for each declaration.

Change LookupResult to use UnresolvedSet.  Also extract UnresolvedSet into its
own header and make it templated over an inline capacity.



git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@93959 91177308-0d34-0410-b5e6-96231b3b80d8

10 files changed, 72 insertions, 74 deletions

diff --git a/lib/AST/ASTContext.cpp b/lib/AST/ASTContext.cpp
index c6e3e09fa5..f8fc626457 100644
--- a/lib/AST/ASTContext.cpp
+++ b/lib/AST/ASTContext.cpp
@@ -3759,8 +3759,8 @@ void ASTContext::setObjCConstantStringInterface(ObjCInterfaceDecl *Decl) {
 
 /// \brief Retrieve the template name that corresponds to a non-empty
 /// lookup.
-TemplateName ASTContext::getOverloadedTemplateName(NamedDecl * const *Begin,
-                                                   NamedDecl * const *End) {
+TemplateName ASTContext::getOverloadedTemplateName(UnresolvedSetIterator Begin,
+                                                   UnresolvedSetIterator End) {
   unsigned size = End - Begin;
   assert(size > 1 && "set is not overloaded!");
 
@@ -3769,7 +3769,7 @@ TemplateName ASTContext::getOverloadedTemplateName(NamedDecl * const *Begin,
   OverloadedTemplateStorage *OT = new(memory) OverloadedTemplateStorage(size);
 
   NamedDecl **Storage = OT->getStorage();
-  for (NamedDecl * const *I = Begin; I != End; ++I) {
+  for (UnresolvedSetIterator I = Begin; I != End; ++I) {
     NamedDecl *D = *I;
     assert(isa<FunctionTemplateDecl>(D) ||
            (isa<UsingShadowDecl>(D) &&
diff --git a/lib/AST/DeclCXX.cpp b/lib/AST/DeclCXX.cpp
index 1cce35c0b3..fe6064df32 100644
--- a/lib/AST/DeclCXX.cpp
+++ b/lib/AST/DeclCXX.cpp
@@ -312,8 +312,9 @@ void
 CXXRecordDecl::collectConversionFunctions(
                  llvm::SmallPtrSet<CanQualType, 8>& ConversionsTypeSet) const
 {
-  const UnresolvedSet *Cs = getConversionFunctions();
-  for (UnresolvedSet::iterator I = Cs->begin(), E = Cs->end(); I != E; ++I) {
+  const UnresolvedSetImpl *Cs = getConversionFunctions();
+  for (UnresolvedSetImpl::iterator I = Cs->begin(), E = Cs->end();
+         I != E; ++I) {
     NamedDecl *TopConv = *I;
     CanQualType TConvType;
     if (FunctionTemplateDecl *TConversionTemplate =
@@ -344,10 +345,11 @@ CXXRecordDecl::getNestedVisibleConversionFunctions(CXXRecordDecl *RD,
   bool inTopClass = (RD == this);
   QualType ClassType = getASTContext().getTypeDeclType(this);
   if (const RecordType *Record = ClassType->getAs<RecordType>()) {
-    const UnresolvedSet *Cs
+    const UnresolvedSetImpl *Cs
       = cast<CXXRecordDecl>(Record->getDecl())->getConversionFunctions();
     
-    for (UnresolvedSet::iterator I = Cs->begin(), E = Cs->end(); I != E; ++I) {
+    for (UnresolvedSetImpl::iterator I = Cs->begin(), E = Cs->end();
+           I != E; ++I) {
       NamedDecl *Conv = *I;
       // Only those conversions not exact match of conversions in current
       // class are candidateconversion routines.
@@ -410,7 +412,7 @@ CXXRecordDecl::getNestedVisibleConversionFunctions(CXXRecordDecl *RD,
 
 /// getVisibleConversionFunctions - get all conversion functions visible
 /// in current class; including conversion function templates.
-const UnresolvedSet *CXXRecordDecl::getVisibleConversionFunctions() {
+const UnresolvedSetImpl *CXXRecordDecl::getVisibleConversionFunctions() {
   // If root class, all conversions are visible.
   if (bases_begin() == bases_end())
     return &Conversions;
diff --git a/lib/AST/ExprCXX.cpp b/lib/AST/ExprCXX.cpp
index 81584b7002..a6574efda8 100644
--- a/lib/AST/ExprCXX.cpp
+++ b/lib/AST/ExprCXX.cpp
@@ -135,10 +135,11 @@ UnresolvedLookupExpr::Create(ASTContext &C, bool Dependent,
   return ULE;
 }
 
-bool UnresolvedLookupExpr::ComputeDependence(NamedDecl * const *Begin,
-                                             NamedDecl * const *End,
-                                       const TemplateArgumentListInfo *Args) {
-  for (NamedDecl * const *I = Begin; I != End; ++I)
+bool UnresolvedLookupExpr::
+  ComputeDependence(UnresolvedSetImpl::const_iterator Begin,
+                    UnresolvedSetImpl::const_iterator End,
+                    const TemplateArgumentListInfo *Args) {
+  for (UnresolvedSetImpl::const_iterator I = Begin; I != End; ++I)
     if ((*I)->getDeclContext()->isDependentContext())
       return true;
 
diff --git a/lib/Sema/Lookup.h b/lib/Sema/Lookup.h
index 9064de6aa0..33d1106559 100644
--- a/lib/Sema/Lookup.h
+++ b/lib/Sema/Lookup.h
@@ -123,9 +123,7 @@ public:
     Temporary
   };
 
-  typedef llvm::SmallVector<NamedDecl*, 4> DeclsTy;
-  typedef DeclsTy::const_iterator iterator;
-
+  typedef UnresolvedSetImpl::iterator iterator;
   typedef bool (*ResultFilter)(NamedDecl*, unsigned IDNS);
 
   LookupResult(Sema &SemaRef, DeclarationName Name, SourceLocation NameLoc,
@@ -224,8 +222,8 @@ public:
     return Ambiguity;
   }
 
-  iterator begin() const { return Decls.begin(); }
-  iterator end() const { return Decls.end(); }
+  iterator begin() const { return iterator(Decls.begin()); }
+  iterator end() const { return iterator(Decls.end()); }
 
   /// \brief Return true if no decls were found
   bool empty() const { return Decls.empty(); }
@@ -247,32 +245,20 @@ public:
     return IDNS;
   }
 
-  /// \brief Add a declaration to these results.  Does not test the
-  /// acceptance criteria.
+  /// \brief Add a declaration to these results with no access bits.
+  /// Does not test the acceptance criteria.
   void addDecl(NamedDecl *D) {
-    Decls.push_back(D);
+    Decls.addDecl(D);
     ResultKind = Found;
   }
 
   /// \brief Add all the declarations from another set of lookup
   /// results.
   void addAllDecls(const LookupResult &Other) {
-    Decls.append(Other.begin(), Other.end());
+    Decls.append(Other.Decls.begin(), Other.Decls.end());
     ResultKind = Found;
   }
 
-  /// \brief Hides a set of declarations.
-  template <class NamedDeclSet> void hideDecls(const NamedDeclSet &Set) {
-    unsigned I = 0, N = Decls.size();
-    while (I < N) {
-      if (Set.count(Decls[I]))
-        Decls[I] = Decls[--N];
-      else
-        I++;
-    }
-    Decls.set_size(N);
-  }
-
   /// \brief Determine whether no result was found because we could not
   /// search into dependent base classes of the current instantiation.
   bool wasNotFoundInCurrentInstantiation() const {
@@ -319,13 +305,13 @@ public:
   NamedDecl *getFoundDecl() const {
     assert(getResultKind() == Found
            && "getFoundDecl called on non-unique result");
-    return Decls[0]->getUnderlyingDecl();
+    return (*begin())->getUnderlyingDecl();
   }
 
   /// Fetches a representative decl.  Useful for lazy diagnostics.
   NamedDecl *getRepresentativeDecl() const {
     assert(!Decls.empty() && "cannot get representative of empty set");
-    return Decls[0];
+    return *begin();
   }
 
   /// \brief Asks if the result is a single tag decl.
@@ -403,7 +389,7 @@ public:
   /// sugared.
   class Filter {
     LookupResult &Results;
-    unsigned I;
+    LookupResult::iterator I;
     bool Changed;
 #ifndef NDEBUG
     bool CalledDone;
@@ -411,7 +397,7 @@ public:
     
     friend class LookupResult;
     Filter(LookupResult &Results)
-      : Results(Results), I(0), Changed(false)
+      : Results(Results), I(Results.begin()), Changed(false)
 #ifndef NDEBUG
       , CalledDone(false)
 #endif
@@ -426,23 +412,30 @@ public:
 #endif
 
     bool hasNext() const {
-      return I != Results.Decls.size();
+      return I != Results.end();
     }
 
     NamedDecl *next() {
-      assert(I < Results.Decls.size() && "next() called on empty filter");
-      return Results.Decls[I++];
+      assert(I != Results.end() && "next() called on empty filter");
+      return *I++;
     }
 
     /// Erase the last element returned from this iterator.
     void erase() {
-      Results.Decls[--I] = Results.Decls.back();
-      Results.Decls.pop_back();
+      Results.Decls.erase(--I);
       Changed = true;
     }
 
+    /// Replaces the current entry with the given one, preserving the
+    /// access bits.
     void replace(NamedDecl *D) {
-      Results.Decls[I-1] = D;
+      Results.Decls.replace(I-1, D);
+      Changed = true;
+    }
+
+    /// Replaces the current entry with the given one.
+    void replace(NamedDecl *D, AccessSpecifier AS) {
+      Results.Decls.replace(I-1, D, AS);
       Changed = true;
     }
 
@@ -482,7 +475,7 @@ private:
     assert(ResultKind != Found || Decls.size() == 1);
     assert(ResultKind != FoundOverloaded || Decls.size() > 1 ||
            (Decls.size() == 1 &&
-            isa<FunctionTemplateDecl>(Decls[0]->getUnderlyingDecl())));
+            isa<FunctionTemplateDecl>((*begin())->getUnderlyingDecl())));
     assert(ResultKind != FoundUnresolvedValue || sanityCheckUnresolved());
     assert(ResultKind != Ambiguous || Decls.size() > 1 ||
            (Decls.size() == 1 && Ambiguity == AmbiguousBaseSubobjects));
@@ -492,8 +485,7 @@ private:
   }
 
   bool sanityCheckUnresolved() const {
-    for (DeclsTy::const_iterator I = Decls.begin(), E = Decls.end();
-           I != E; ++I)
+    for (iterator I = begin(), E = end(); I != E; ++I)
       if (isa<UnresolvedUsingValueDecl>(*I))
         return true;
     return false;
@@ -504,7 +496,7 @@ private:
   // Results.
   LookupResultKind ResultKind;
   AmbiguityKind Ambiguity; // ill-defined unless ambiguous
-  DeclsTy Decls;
+  UnresolvedSet<8> Decls;
   CXXBasePaths *Paths;
 
   // Parameters.
diff --git a/lib/Sema/SemaDeclCXX.cpp b/lib/Sema/SemaDeclCXX.cpp
index 669629468d..12b4565cb5 100644
--- a/lib/Sema/SemaDeclCXX.cpp
+++ b/lib/Sema/SemaDeclCXX.cpp
@@ -4487,9 +4487,9 @@ Sema::CheckReferenceInit(Expr *&Init, QualType DeclType,
       = dyn_cast<CXXRecordDecl>(T2->getAs<RecordType>()->getDecl());
 
     OverloadCandidateSet CandidateSet;
-    const UnresolvedSet *Conversions
+    const UnresolvedSetImpl *Conversions
       = T2RecordDecl->getVisibleConversionFunctions();
-    for (UnresolvedSet::iterator I = Conversions->begin(),
+    for (UnresolvedSetImpl::iterator I = Conversions->begin(),
            E = Conversions->end(); I != E; ++I) {
       NamedDecl *D = *I;
       CXXRecordDecl *ActingDC = cast<CXXRecordDecl>(D->getDeclContext());
diff --git a/lib/Sema/SemaExprCXX.cpp b/lib/Sema/SemaExprCXX.cpp
index e4812682a0..b004fc3dba 100644
--- a/lib/Sema/SemaExprCXX.cpp
+++ b/lib/Sema/SemaExprCXX.cpp
@@ -893,9 +893,9 @@ Sema::ActOnCXXDelete(SourceLocation StartLoc, bool UseGlobal,
     if (const RecordType *Record = Type->getAs<RecordType>()) {
       llvm::SmallVector<CXXConversionDecl *, 4> ObjectPtrConversions;
       CXXRecordDecl *RD = cast<CXXRecordDecl>(Record->getDecl());
-      const UnresolvedSet *Conversions = RD->getVisibleConversionFunctions();
+      const UnresolvedSetImpl *Conversions = RD->getVisibleConversionFunctions();
       
-      for (UnresolvedSet::iterator I = Conversions->begin(),
+      for (UnresolvedSetImpl::iterator I = Conversions->begin(),
              E = Conversions->end(); I != E; ++I) {
         // Skip over templated conversion functions; they aren't considered.
         if (isa<FunctionTemplateDecl>(*I))
diff --git a/lib/Sema/SemaInit.cpp b/lib/Sema/SemaInit.cpp
index 1970f56e28..29209d97ff 100644
--- a/lib/Sema/SemaInit.cpp
+++ b/lib/Sema/SemaInit.cpp
@@ -2141,11 +2141,10 @@ static OverloadingResult TryRefInitWithConversionFunction(Sema &S,
     // refers to.
     QualType ToType = AllowRValues? cv1T1 : DestType;
 
-    const UnresolvedSet *Conversions
+    const UnresolvedSetImpl *Conversions
       = T2RecordDecl->getVisibleConversionFunctions();
-    for (UnresolvedSet::iterator I = Conversions->begin(),
-         E = Conversions->end(); 
-         I != E; ++I) {
+    for (UnresolvedSetImpl::const_iterator I = Conversions->begin(),
+           E = Conversions->end(); I != E; ++I) {
       NamedDecl *D = *I;
       CXXRecordDecl *ActingDC = cast<CXXRecordDecl>(D->getDeclContext());
       if (isa<UsingShadowDecl>(D))
@@ -2662,9 +2661,9 @@ static void TryUserDefinedConversion(Sema &S,
       CXXRecordDecl *SourceRecordDecl
         = cast<CXXRecordDecl>(SourceRecordType->getDecl());
       
-      const UnresolvedSet *Conversions
+      const UnresolvedSetImpl *Conversions
         = SourceRecordDecl->getVisibleConversionFunctions();
-      for (UnresolvedSet::iterator I = Conversions->begin(),
+      for (UnresolvedSetImpl::const_iterator I = Conversions->begin(),
            E = Conversions->end(); 
            I != E; ++I) {
         NamedDecl *D = *I;
diff --git a/lib/Sema/SemaLookup.cpp b/lib/Sema/SemaLookup.cpp
index 70baefdae7..da7626780c 100644
--- a/lib/Sema/SemaLookup.cpp
+++ b/lib/Sema/SemaLookup.cpp
@@ -324,9 +324,9 @@ void LookupResult::resolveKind() {
   // If there's a single decl, we need to examine it to decide what
   // kind of lookup this is.
   if (N == 1) {
-    if (isa<FunctionTemplateDecl>(Decls[0]))
+    if (isa<FunctionTemplateDecl>(*Decls.begin()))
       ResultKind = FoundOverloaded;
-    else if (isa<UnresolvedUsingValueDecl>(Decls[0]))
+    else if (isa<UnresolvedUsingValueDecl>(*Decls.begin()))
       ResultKind = FoundUnresolvedValue;
     return;
   }
@@ -463,10 +463,9 @@ static bool LookupDirect(LookupResult &R, const DeclContext *DC) {
     if (!Record->isDefinition())
       return Found;
 
-    const UnresolvedSet *Unresolved = Record->getConversionFunctions();
-    for (UnresolvedSet::iterator U = Unresolved->begin(), 
-                              UEnd = Unresolved->end();
-         U != UEnd; ++U) {
+    const UnresolvedSetImpl *Unresolved = Record->getConversionFunctions();
+    for (UnresolvedSetImpl::iterator U = Unresolved->begin(), 
+           UEnd = Unresolved->end(); U != UEnd; ++U) {
       FunctionTemplateDecl *ConvTemplate = dyn_cast<FunctionTemplateDecl>(*U);
       if (!ConvTemplate)
         continue;
@@ -1243,7 +1242,12 @@ bool Sema::DiagnoseAmbiguousLookup(LookupResult &Result) {
         Diag((*DI)->getLocation(), diag::note_hiding_object);
 
     // For recovery purposes, go ahead and implement the hiding.
-    Result.hideDecls(TagDecls);
+    LookupResult::Filter F = Result.makeFilter();
+    while (F.hasNext()) {
+      if (TagDecls.count(F.next()))
+        F.erase();
+    }
+    F.done();
 
     return true;
   }
diff --git a/lib/Sema/SemaOverload.cpp b/lib/Sema/SemaOverload.cpp
index d710d96586..3b6cf89306 100644
--- a/lib/Sema/SemaOverload.cpp
+++ b/lib/Sema/SemaOverload.cpp
@@ -1533,9 +1533,9 @@ OverloadingResult Sema::IsUserDefinedConversion(Expr *From, QualType ToType,
     if (CXXRecordDecl *FromRecordDecl
          = dyn_cast<CXXRecordDecl>(FromRecordType->getDecl())) {
       // Add all of the conversion functions as candidates.
-      const UnresolvedSet *Conversions
+      const UnresolvedSetImpl *Conversions
         = FromRecordDecl->getVisibleConversionFunctions();
-      for (UnresolvedSet::iterator I = Conversions->begin(),
+      for (UnresolvedSetImpl::iterator I = Conversions->begin(),
              E = Conversions->end(); I != E; ++I) {
         NamedDecl *D = *I;
         CXXRecordDecl *ActingContext = cast<CXXRecordDecl>(D->getDeclContext());
@@ -3280,9 +3280,9 @@ BuiltinCandidateTypeSet::AddTypesConvertedFrom(QualType Ty,
       }
 
       CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(TyRec->getDecl());
-      const UnresolvedSet *Conversions
+      const UnresolvedSetImpl *Conversions
         = ClassDecl->getVisibleConversionFunctions();
-      for (UnresolvedSet::iterator I = Conversions->begin(),
+      for (UnresolvedSetImpl::iterator I = Conversions->begin(),
              E = Conversions->end(); I != E; ++I) {
 
         // Skip conversion function templates; they don't tell us anything
@@ -3344,10 +3344,10 @@ static  Qualifiers CollectVRQualifiers(ASTContext &Context, Expr* ArgExpr) {
     }
     
     CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(TyRec->getDecl());
-    const UnresolvedSet *Conversions =
+    const UnresolvedSetImpl *Conversions =
       ClassDecl->getVisibleConversionFunctions();
     
-    for (UnresolvedSet::iterator I = Conversions->begin(),
+    for (UnresolvedSetImpl::iterator I = Conversions->begin(),
            E = Conversions->end(); I != E; ++I) {
       if (CXXConversionDecl *Conv = dyn_cast<CXXConversionDecl>(*I)) {
         QualType CanTy = Context.getCanonicalType(Conv->getConversionType());
@@ -5938,9 +5938,9 @@ Sema::BuildCallToObjectOfClassType(Scope *S, Expr *Object,
   //   functions for each conversion function declared in an
   //   accessible base class provided the function is not hidden
   //   within T by another intervening declaration.
-  const UnresolvedSet *Conversions
+  const UnresolvedSetImpl *Conversions
     = cast<CXXRecordDecl>(Record->getDecl())->getVisibleConversionFunctions();
-  for (UnresolvedSet::iterator I = Conversions->begin(),
+  for (UnresolvedSetImpl::iterator I = Conversions->begin(),
          E = Conversions->end(); I != E; ++I) {
     NamedDecl *D = *I;
     CXXRecordDecl *ActingContext = cast<CXXRecordDecl>(D->getDeclContext());
diff --git a/lib/Sema/SemaStmt.cpp b/lib/Sema/SemaStmt.cpp
index f0bbdfe762..0c207fa6e8 100644
--- a/lib/Sema/SemaStmt.cpp
+++ b/lib/Sema/SemaStmt.cpp
@@ -412,10 +412,10 @@ static bool CheckCXXSwitchCondition(Sema &S, SourceLocation SwitchLoc,
   llvm::SmallVector<CXXConversionDecl *, 4> ViableConversions;
   llvm::SmallVector<CXXConversionDecl *, 4> ExplicitConversions;
   if (const RecordType *RecordTy = CondType->getAs<RecordType>()) {
-    const UnresolvedSet *Conversions
+    const UnresolvedSetImpl *Conversions
       = cast<CXXRecordDecl>(RecordTy->getDecl())
                                              ->getVisibleConversionFunctions();
-    for (UnresolvedSet::iterator I = Conversions->begin(),
+    for (UnresolvedSetImpl::iterator I = Conversions->begin(),
            E = Conversions->end(); I != E; ++I) {
       if (CXXConversionDecl *Conversion = dyn_cast<CXXConversionDecl>(*I))
         if (Conversion->getConversionType().getNonReferenceType()