[analyzer][UninitializedObjectChecker] Using the new const methods of ImmutableList

[Szelethus]

Summary

Clang side changes to D51881. This is an improvement, and won't cause compilation errors if not commited together.

[Szelethus]

Ping :)

[NoQ]

Hmm, how did i miss it?

lib/StaticAnalyzer/Checkers/UninitializedObject/UninitializedObject.h

 /// other element is a field, and the element that precedes it is the object
 /// that contains it.
 ///
 /// Note that this class is immutable (essentially a wrapper around an
 /// ImmutableList), new FieldChainInfo objects may be created by member
 /// functions such as add() and replaceHead().
 class FieldChainInfo {
 public:
-  using FieldChainImpl = llvm::ImmutableListImpl<const FieldNode &>;
   using FieldChain = llvm::ImmutableList<const FieldNode &>;
 
 private:
   FieldChain::Factory &ChainFactory;
   FieldChain Chain;
 
   FieldChainInfo(FieldChain::Factory &F, FieldChain NewChain)
       : FieldChainInfo(F) {
public:
 
   /// Constructs a new FieldChainInfo object with \p FN as the new head of the
   /// list.
   template <class FieldNodeT> FieldChainInfo replaceHead(const FieldNodeT &FN);
 
   bool contains(const FieldRegion *FR) const;
   bool isEmpty() const { return Chain.isEmpty(); }
 
-  const FieldRegion *getUninitRegion() const;
-  const FieldNode &getHead() { return Chain.getHead(); }
+  const FieldNode &getHead() const { return Chain.getHead(); }
+  const FieldRegion *getUninitRegion() const { return getHead().getRegion(); }
 
   void printNoteMsg(llvm::raw_ostream &Out) const;
 };
 
 using UninitFieldMap = std::map<const FieldRegion *, llvm::SmallString<50>>;
 
 /// Searches for and stores uninitialized fields in a non-union object.
 class FindUninitializedFields {

lib/StaticAnalyzer/Checkers/UninitializedObject/UninitializedObjectChecker.cpp

bool FindUninitializedFields::isPrimitiveUninit(const SVal &V) {
   IsAnyFieldInitialized = true;
   return false;
 }
 
 //===----------------------------------------------------------------------===//
 //                       Methods for FieldChainInfo.
 //===----------------------------------------------------------------------===//
 
-const FieldRegion *FieldChainInfo::getUninitRegion() const {
-  assert(!Chain.isEmpty() && "Empty fieldchain!");
-
-  // ImmutableList::getHead() isn't a const method, hence the not too nice
-  // implementation.
-  return (*Chain.begin()).getRegion();
-}
-
 bool FieldChainInfo::contains(const FieldRegion *FR) const {
   for (const FieldNode &Node : Chain) {
     if (Node.isSameRegion(FR))
       return true;
   }
   return false;
 }
 
 /// Prints every element except the last to `Out`. Since ImmutableLists store
 /// elements in reverse order, and have no reverse iterators, we use a
 /// recursive function to print the fieldchain correctly. The last element in
 /// the chain is to be printed by `FieldChainInfo::print`.
 static void printTail(llvm::raw_ostream &Out,
-                      const FieldChainInfo::FieldChainImpl *L);
+                      const FieldChainInfo::FieldChain L);
 
 // FIXME: This function constructs an incorrect string in the following case:
 //
 //   struct Base { int x; };
 //   struct D1 : Base {}; struct D2 : Base {};
 //
 //   struct MostDerived : D1, D2 {
 //     MostDerived() {}
 //   }
 //
 // A call to MostDerived::MostDerived() will cause two notes that say
 // "uninitialized field 'this->x'", but we can't refer to 'x' directly,
 // we need an explicit namespace resolution whether the uninit field was
 // 'D1::x' or 'D2::x'.
 void FieldChainInfo::printNoteMsg(llvm::raw_ostream &Out) const {
   if (Chain.isEmpty())
     return;
 
-  const FieldChainImpl *L = Chain.getInternalPointer();
-  const FieldNode &LastField = L->getHead();
+  const FieldNode &LastField = getHead();
 
   LastField.printNoteMsg(Out);
   Out << '\'';
 
   for (const FieldNode &Node : Chain)
     Node.printPrefix(Out);
 
   Out << "this->";
-  printTail(Out, L->getTail());
+  printTail(Out, Chain.getTail());
   LastField.printNode(Out);
   Out << '\'';
 }
 
 static void printTail(llvm::raw_ostream &Out,
-                      const FieldChainInfo::FieldChainImpl *L) {
-  if (!L)
+                      const FieldChainInfo::FieldChain L) {
+  if (L.isEmpty())
     return;
 
-  printTail(Out, L->getTail());
+  printTail(Out, L.getTail());
 
-  L->getHead().printNode(Out);
-  L->getHead().printSeparator(Out);
+  L.getHead().printNode(Out);
+  L.getHead().printSeparator(Out);
 }
 
 //===----------------------------------------------------------------------===//
 //                           Utility functions.
 //===----------------------------------------------------------------------===//
 
 static Optional<nonloc::LazyCompoundVal>
 getObjectVal(const CXXConstructorDecl *CtorDecl, CheckerContext &Context) {