AST: Avoid using SmallVector::set_size() in UnresolvedSet

[dexonsmith]

Summary

Update UnresolvedSet to use (and expose) SmallVector::truncate() instead
of SmallVector::set_size(). The latter is going to made private in a
future commit to avoid misuse.

Currently depends on https://reviews.llvm.org/D115383. It seems to improve readability to use truncate() instead of resize() (known to shrink the size), and it keeps an assertion in place (not sure of value?) that this doesn't grow. I can't imagine the former's performance characteristics are important here, so I could be convinced to just use resize()...

Blocker for https://reviews.llvm.org/D115380.

[dexonsmith]

Adding a couple of other possible reviewers.

[no change, just retriggering bots after spurious failure]

[dexonsmith]

clang/lib/Sema/SemaLookup.cpp

623

Two things to confirm here.

First is that the destructors are trivial. From clang/include/clang/AST/DeclAccessPair.h:

class DeclAccessPair {
  uintptr_t Ptr; // we'd use llvm::PointerUnion, but it isn't trivial

(If they hadn't been trivial, then hypothetically there could been other code somewhere that ran the destructors later...)

Second is that set_size() was only used for truncation. I confirmed that that three ways:

• Looking backward, N starts as Decls.size() and the only changes are decrement operatoers.
• Looking forward, there's no code that would initialize / assign to the new member (so if it increased size, it would likely have led to problems elsewhere).
• Tests pass.

[dblaikie]

Looks good.

clang/lib/Sema/SemaLookup.cpp

623

Thanks for the details!

clang/include/clang/AST/UnresolvedSet.h

public:
 
   void erase(unsigned I) { decls()[I] = decls().pop_back_val(); }
 
   void erase(iterator I) { *I.I = decls().pop_back_val(); }
 
   void setAccess(iterator I, AccessSpecifier AS) { I.I->setAccess(AS); }
 
   void clear() { decls().clear(); }
-  void set_size(unsigned N) { decls().set_size(N); }
+  void truncate(unsigned N) { decls().truncate(N); }
 
   bool empty() const { return decls().empty(); }
   unsigned size() const { return decls().size(); }
 
   void append(iterator I, iterator E) { decls().append(I.I, E.I); }
 
   template<typename Iter> void assign(Iter I, Iter E) { decls().assign(I, E); }
 

clang/lib/Sema/SemaLookup.cpp

void LookupResult::resolveKind() {
   }
 
   // FIXME: This diagnostic should really be delayed until we're done with
   // the lookup result, in case the ambiguity is resolved by the caller.
   if (!EquivalentNonFunctions.empty() && !Ambiguous)
     getSema().diagnoseEquivalentInternalLinkageDeclarations(
         getNameLoc(), HasNonFunction, EquivalentNonFunctions);
 
-  Decls.set_size(N);
+  Decls.truncate(N);
 
   if (HasNonFunction && (HasFunction || HasUnresolved))
     Ambiguous = true;
 
   if (Ambiguous)
     setAmbiguous(LookupResult::AmbiguousReference);
   else if (HasUnresolved)
     ResultKind = LookupResult::FoundUnresolvedValue;