[analyzer] NFC: Refactor the code for obtaining temporary lifetime info into a method.

[NoQ]

Summary

Because @george.karpenkov wanted that and because i was about to copy-paste it.
This makes the assertions on CallOpts go away, but those aren't very valuable.

[NoQ]

Rebase.

include/clang/StaticAnalyzer/Core/PathSensitive/ExprEngine.h

private:
 
   /// Check if all temporary materialization regions are clear for the given
   /// context range (including FromLC, not including ToLC).
   /// This is useful for assertions.
   static bool areTemporaryMaterializationsClear(ProgramStateRef State,
                                                 const LocationContext *FromLC,
                                                 const LocationContext *ToLC);
 
+  /// Adds an initialized temporary and/or a materialization, whichever is
+  /// necessary, by looking at the whole construction context. Handles
+  /// function return values, which need the construction context of the parent
+  /// stack frame, automagically.
+  ProgramStateRef addAllNecessaryTemporaryInfo(
+      ProgramStateRef State, const ConstructionContext *CC,
+      const LocationContext *LC, const MemRegion *R);
+
   /// Store the region returned by operator new() so that the constructor
   /// that follows it knew what location to initialize. The value should be
   /// cleared once the respective CXXNewExpr CFGStmt element is processed.
   static ProgramStateRef
   setCXXNewAllocatorValue(ProgramStateRef State, const CXXNewExpr *CNE,
                           const LocationContext *CallerLC, SVal V);
 
   /// Retrieve the location returned by the current operator new().

lib/StaticAnalyzer/Core/ExprEngine.cpp

 #include "clang/AST/ParentMap.h"
 #include "clang/AST/PrettyPrinter.h"
 #include "clang/AST/Stmt.h"
 #include "clang/AST/StmtCXX.h"
 #include "clang/AST/StmtObjC.h"
 #include "clang/AST/Type.h"
 #include "clang/Analysis/AnalysisDeclContext.h"
 #include "clang/Analysis/CFG.h"
+#include "clang/Analysis/ConstructionContext.h"
 #include "clang/Analysis/ProgramPoint.h"
 #include "clang/Basic/IdentifierTable.h"
 #include "clang/Basic/LLVM.h"
 #include "clang/Basic/LangOptions.h"
 #include "clang/Basic/PrettyStackTrace.h"
 #include "clang/Basic/SourceLocation.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Basic/Specifiers.h"
for (auto I : State->get<TemporaryMaterializations>())
       if (I.first.second == LC)
         return false;
 
     LC = LC->getParent();
   }
   return true;
 }
 
+ProgramStateRef ExprEngine::addAllNecessaryTemporaryInfo(
+    ProgramStateRef State, const ConstructionContext *CC,
+    const LocationContext *LC, const MemRegion *R) {
+  const CXXBindTemporaryExpr *BTE = nullptr;
+  const MaterializeTemporaryExpr *MTE = nullptr;
+  const LocationContext *TempLC = LC;
+
+  if (CC) {
+    // In case of temporary object construction, extract data necessary for
+    // destruction and lifetime extension.
+    const auto *TCC = dyn_cast<TemporaryObjectConstructionContext>(CC);
+
+    // If the temporary is being returned from the function, it will be
+    // destroyed or lifetime-extended in the caller stack frame.
+    if (const auto *RCC = dyn_cast<ReturnedValueConstructionContext>(CC)) {
+      const StackFrameContext *SFC = LC->getCurrentStackFrame();
+      assert(SFC);
+      if (SFC->getParent()) {
+        TempLC = SFC->getParent();
+        const CFGElement &CallElem =
+            (*SFC->getCallSiteBlock())[SFC->getIndex()];
+        if (auto RTCElem = CallElem.getAs<CFGCXXRecordTypedCall>()) {
+          TCC = cast<TemporaryObjectConstructionContext>(
+              RTCElem->getConstructionContext());
+        }
+      }
+    }
+    if (TCC) {
+      if (AMgr.getAnalyzerOptions().includeTemporaryDtorsInCFG()) {
+        BTE = TCC->getCXXBindTemporaryExpr();
+        MTE = TCC->getMaterializedTemporaryExpr();
+        if (!BTE) {
+          // FIXME: Lifetime extension for temporaries without destructors
+          // is not implemented yet.
+          MTE = nullptr;
+        }
+        if (MTE && MTE->getStorageDuration() != SD_FullExpression) {
+          // If the temporary is lifetime-extended, don't save the BTE,
+          // because we don't need a temporary destructor, but an automatic
+          // destructor.
+          BTE = nullptr;
+        }
+      }
+    }
+
+    if (BTE) {
+      State = addInitializedTemporary(State, BTE, TempLC,
+                                      cast<CXXTempObjectRegion>(R));
+    }
+
+    if (MTE) {
+      State = addTemporaryMaterialization(State, MTE, TempLC,
+                                          cast<CXXTempObjectRegion>(R));
+    }
+  }
+
+  return State;
+}
+
 ProgramStateRef
 ExprEngine::setCXXNewAllocatorValue(ProgramStateRef State,
                                     const CXXNewExpr *CNE,
                                     const LocationContext *CallerLC, SVal V) {
   assert(!State->get<CXXNewAllocatorValues>(std::make_pair(CNE, CallerLC)) &&
          "Allocator value already set!");
   return State->set<CXXNewAllocatorValues>(std::make_pair(CNE, CallerLC), V);
 }

lib/StaticAnalyzer/Core/ExprEngineCXX.cpp

void ExprEngine::VisitCXXConstructExpr(const CXXConstructExpr *CE,
   // For now, we just run the first constructor (which should still invalidate
   // the entire array).
 
   EvalCallOptions CallOpts;
   auto C = getCurrentCFGElement().getAs<CFGConstructor>();
   assert(C || getCurrentCFGElement().getAs<CFGStmt>());
   const ConstructionContext *CC = C ? C->getConstructionContext() : nullptr;
 
-  bool IsReturnedIntoParentStackFrame = false;
-  const CXXBindTemporaryExpr *BTE = nullptr;
-  const MaterializeTemporaryExpr *MTE = nullptr;
-
   switch (CE->getConstructionKind()) {
   case CXXConstructExpr::CK_Complete: {
     Target = getRegionForConstructedObject(CE, Pred, CC, CallOpts);
-
-    if (CC) {
-      // In case of temporary object construction, extract data necessary for
-      // destruction and lifetime extension.
-      const auto *TCC = dyn_cast<TemporaryObjectConstructionContext>(CC);
-
-      // If the temporary is being returned from the function, it will be
-      // destroyed or lifetime-extended in the caller stack frame.
-      if (const auto *RCC = dyn_cast<ReturnedValueConstructionContext>(CC)) {
-        const StackFrameContext *SFC = LCtx->getCurrentStackFrame();
-        assert(SFC);
-        if (SFC->getParent()) {
-          IsReturnedIntoParentStackFrame = true;
-          const CFGElement &CallElem =
-              (*SFC->getCallSiteBlock())[SFC->getIndex()];
-          if (auto RTCElem = CallElem.getAs<CFGCXXRecordTypedCall>()) {
-            TCC = cast<TemporaryObjectConstructionContext>(
-                RTCElem->getConstructionContext());
-          }
-        }
-      }
-
-      if (TCC) {
-        assert(CallOpts.IsTemporaryCtorOrDtor);
-        assert(!CallOpts.IsCtorOrDtorWithImproperlyModeledTargetRegion);
-        if (AMgr.getAnalyzerOptions().includeTemporaryDtorsInCFG()) {
-          BTE = TCC->getCXXBindTemporaryExpr();
-          MTE = TCC->getMaterializedTemporaryExpr();
-          if (!BTE) {
-            // FIXME: lifetime extension for temporaries without destructors
-            // is not implemented yet.
-            MTE = nullptr;
-          }
-          if (MTE && MTE->getStorageDuration() != SD_FullExpression) {
-            // If the temporary is lifetime-extended, don't save the BTE,
-            // because we don't need a temporary destructor, but an automatic
-            // destructor.
-            BTE = nullptr;
-          }
-        }
-      }
-    }
     break;
   }
   case CXXConstructExpr::CK_VirtualBase:
     // Make sure we are not calling virtual base class initializers twice.
     // Only the most-derived object should initialize virtual base classes.
     if (const Stmt *Outer = LCtx->getCurrentStackFrame()->getCallSite()) {
       const CXXConstructExpr *OuterCtor = dyn_cast<CXXConstructExpr>(Outer);
       if (OuterCtor) {
for (ExplodedNodeSet::iterator I = DstPreVisit.begin(),
         // initialize the entire array, not just the first element -- but our
         // handling of arrays everywhere else is weak as well, so this shouldn't
         // actually make things worse. Placement new makes this tricky as well,
         // since it's then possible to be initializing one part of a multi-
         // dimensional array.
         State = State->bindDefault(loc::MemRegionVal(Target), ZeroVal, LCtx);
       }
 
-      // Set up destruction and lifetime extension information.
-      const LocationContext *TempLCtx =
-          IsReturnedIntoParentStackFrame
-              ? LCtx->getCurrentStackFrame()->getParent()
-              : LCtx;
-
-      if (BTE) {
-        State = addInitializedTemporary(State, BTE, TempLCtx,
-                                        cast<CXXTempObjectRegion>(Target));
-      }
-
-      if (MTE) {
-        State = addTemporaryMaterialization(State, MTE, TempLCtx,
-                                            cast<CXXTempObjectRegion>(Target));
-      }
+      State = addAllNecessaryTemporaryInfo(State, CC, LCtx, Target);
 
       Bldr.generateNode(CE, *I, State, /*tag=*/nullptr,
                         ProgramPoint::PreStmtKind);
     }
   }
 
   ExplodedNodeSet DstPreCall;
   getCheckerManager().runCheckersForPreCall(DstPreCall, PreInitialized,