[analyzer][UninitializedObjectChecker] Refactoring p3.: printTail moved out from FieldChainInfo

[Szelethus]

Summary

This is a standalone part of the effort to reduce FieldChainInfos inteerface.

lib/StaticAnalyzer/Checkers/UninitializedObject/UninitializedObject.h

 /// first element of the chain is the object under checking (not stored), and
 /// every other element is a field, and the element that precedes it is the
 /// object that contains it.
 ///
 /// Note that this class is immutable, and new fields may only be added through
 /// constructor calls.
 class FieldChainInfo {
 public:
+  using FieldChainImpl = llvm::ImmutableListImpl<const FieldRegion *>;
   using FieldChain = llvm::ImmutableList<const FieldRegion *>;
 
 private:
   FieldChain::Factory &Factory;
   FieldChain Chain;
 
   const bool IsDereferenced = false;
 
 public:
   FieldChainInfo() = delete;
   FieldChainInfo(FieldChain::Factory &F) : Factory(F) {}
 
   FieldChainInfo(const FieldChainInfo &Other, const bool IsDereferenced)
-      : Factory(Other.Factory), Chain(Other.Chain), IsDereferenced(IsDereferenced) {}
+      : Factory(Other.Factory), Chain(Other.Chain),
+        IsDereferenced(IsDereferenced) {}
 
   FieldChainInfo(const FieldChainInfo &Other, const FieldRegion *FR,
                  const bool IsDereferenced = false);
 
   bool contains(const FieldRegion *FR) const { return Chain.contains(FR); }
   bool isPointer() const;
 
   /// If this is a fieldchain whose last element is an uninitialized region of a
   /// pointer type, `IsDereferenced` will store whether the pointer itself or
   /// the pointee is uninitialized.
   bool isDereferenced() const;
   const FieldDecl *getEndOfChain() const;
   void print(llvm::raw_ostream &Out) const;
 
 private:
-  /// 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 `print`.
-  static void printTail(llvm::raw_ostream &Out,
-                        const llvm::ImmutableListImpl<const FieldRegion *> *L);
   friend struct FieldChainInfoComparator;
 };
 
 struct FieldChainInfoComparator {
   bool operator()(const FieldChainInfo &lhs, const FieldChainInfo &rhs) const {
     assert(!lhs.Chain.isEmpty() && !rhs.Chain.isEmpty() &&
            "Attempted to store an empty fieldchain!");
     return *lhs.Chain.begin() < *rhs.Chain.begin();

lib/StaticAnalyzer/Checkers/UninitializedObject/UninitializedObjectChecker.cpp

 // To read about how the checker works, refer to the comments in
 // UninitializedObject.h.
 //
 // Some of the logic is implemented in UninitializedPointee.cpp, to reduce the
 // complexity of this file.
 //
 //===----------------------------------------------------------------------===//
 
-#include "UninitializedObject.h"
 #include "ClangSACheckers.h"
+#include "UninitializedObject.h"
 #include "clang/StaticAnalyzer/Core/BugReporter/BugType.h"
 #include "clang/StaticAnalyzer/Core/Checker.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/DynamicTypeMap.h"
 
 using namespace clang;
 using namespace clang::ento;
 

 // region.
 static Optional<nonloc::LazyCompoundVal>
 getObjectVal(const CXXConstructorDecl *CtorDecl, CheckerContext &Context);
 
 /// Checks whether the object constructed by \p Ctor will be analyzed later
 /// (e.g. if the object is a field of another object, in which case we'd check
 /// it multiple times).
 static bool willObjectBeAnalyzedLater(const CXXConstructorDecl *Ctor,
                                       CheckerContext &Context);
 
 /// Constructs a note message for a given FieldChainInfo object.
 static void printNoteMessage(llvm::raw_ostream &Out,
                              const FieldChainInfo &Chain);
 
 /// Returns with Field's name. This is a helper function to get the correct name
 /// even if Field is a captured lambda variable.
 static StringRef getVariableName(const FieldDecl *Field);
bool FieldChainInfo::isDereferenced() const {
   return IsDereferenced;
 }
 
 const FieldDecl *FieldChainInfo::getEndOfChain() const {
   assert(!Chain.isEmpty() && "Empty fieldchain!");
   return (*Chain.begin())->getDecl();
 }
 
+/// 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 `print`.
+static void printTail(llvm::raw_ostream &Out,
+                      const FieldChainInfo::FieldChainImpl *L);
+
 // TODO: This function constructs an incorrect string if a void pointer is a
 // part of the chain:
 //
 //   struct B { int x; }
 //
 //   struct A {
 //     void *vptr;
 //     A(void* vptr) : vptr(vptr) {}

 // 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::print(llvm::raw_ostream &Out) const {
   if (Chain.isEmpty())
     return;
 
-  const llvm::ImmutableListImpl<const FieldRegion *> *L =
-      Chain.getInternalPointer();
+  const FieldChainImpl *L = Chain.getInternalPointer();
   printTail(Out, L->getTail());
   Out << getVariableName(L->getHead()->getDecl());
 }
 
-void FieldChainInfo::printTail(
-    llvm::raw_ostream &Out,
-    const llvm::ImmutableListImpl<const FieldRegion *> *L) {
+static void printTail(llvm::raw_ostream &Out,
+                      const FieldChainInfo::FieldChainImpl *L) {
   if (!L)
     return;
 
   printTail(Out, L->getTail());
   const FieldDecl *Field = L->getHead()->getDecl();
   Out << getVariableName(Field);
   Out << (Field->getType()->isPointerType() ? "->" : ".");
 }
getObjectVal(const CXXConstructorDecl *CtorDecl, CheckerContext &Context) {
 
   // Getting the value for '*this'.
   SVal Object = Context.getState()->getSVal(This.castAs<Loc>());
 
   return Object.getAs<nonloc::LazyCompoundVal>();
 }
 
 static bool willObjectBeAnalyzedLater(const CXXConstructorDecl *Ctor,
                                       CheckerContext &Context) {
 
   Optional<nonloc::LazyCompoundVal> CurrentObject = getObjectVal(Ctor, Context);
   if (!CurrentObject)
     return false;
 
   const LocationContext *LC = Context.getLocationContext();
   while ((LC = LC->getParent())) {
 

lib/StaticAnalyzer/Checkers/UninitializedObject/UninitializedPointee.cpp

 // To read about command line options and a description what this checker does,
 // refer to UninitializedObjectChecker.cpp.
 //
 // To read about how the checker works, refer to the comments in
 // UninitializedObject.h.
 //
 //===----------------------------------------------------------------------===//
 
-#include "UninitializedObject.h"
 #include "ClangSACheckers.h"
+#include "UninitializedObject.h"
 #include "clang/StaticAnalyzer/Core/BugReporter/BugType.h"
 #include "clang/StaticAnalyzer/Core/Checker.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/DynamicTypeMap.h"
 
 using namespace clang;
 using namespace clang::ento;