[analyzer] pr37166, pr37139: Disable constructor inlining when lifetime extension through aggregate initialization occurs.

[NoQ]

Summary

This hotfix is similar to D43689 (and needs a follow-up similar to D44238 and D44239). CFG again doesn't provide us with correct automatic destructors, this time it's in the following code:

struct A {
  const C &c;
};

void foo() {
  A a = { C() };
}

In this code a is an aggregate, so it doesn't require construction or destruction. Instead, C() is lifetime-extended until the end of a's scope.

Additionally, we used to crash on my defensive "i know C++" assertion (no, i don't).

[NoQ]

Add a test similar to pr37166. It should be actually fixed now with this patch. Essentially, we may also be lifetime-extended by an array of aggregate structures (with arbitrary amounts of interleaving array and aggregate structure brace-initializers).

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

struct EvalCallOptions {
     /// This call is a constructor or a destructor of a temporary value.
     bool IsTemporaryCtorOrDtor = false;
 
     /// This call is a constructor for a temporary that is lifetime-extended
     /// by binding a smaller object within it to a reference, for example
     /// 'const int &x = C().x;'.
     bool IsTemporaryLifetimeExtendedViaSubobject = false;
 
+    /// This call is a constructor for a temporary that is lifetime-extended
+    /// by binding it to a reference-type field within an aggregate,
+    /// for example 'A { const C &c; }; A a = { C() };'
+    bool IsTemporaryLifetimeExtendedViaAggregate = false;
+
     EvalCallOptions() {}
   };
 
 private:
   cross_tu::CrossTranslationUnitContext &CTU;
 
   AnalysisManager &AMgr;
   

lib/StaticAnalyzer/Core/ExprEngineCXX.cpp

case ConstructionContext::NewAllocatedObjectKind: {
           }
           return MR;
         }
       }
       break;
     }
     case ConstructionContext::TemporaryObjectKind: {
       const auto *TOCC = cast<TemporaryObjectConstructionContext>(CC);
-      // See if we're lifetime-extended via our field. If so, take a note.
-      // Because automatic destructors aren't quite working in this case.
       if (const auto *MTE = TOCC->getMaterializedTemporaryExpr()) {
         if (const ValueDecl *VD = MTE->getExtendingDecl()) {
+          if (const auto *RD = VD->getType()->getAsCXXRecordDecl()) {
+            // We're lifetime-extended by a surrounding aggregate.
+            // Automatic destructors aren't quite working in this case.
+            assert(RD->isAggregate());
+            assert(RD != CE->getConstructor()->getParent());
+            CallOpts.IsTemporaryLifetimeExtendedViaAggregate = true;
+          } else {
             assert(VD->getType()->isReferenceType());
             if (VD->getType()->getPointeeType().getCanonicalType() !=
                 MTE->GetTemporaryExpr()->getType().getCanonicalType()) {
+              // We're lifetime-extended via our field. Automatic destructors
+              // aren't quite working in this case.
               CallOpts.IsTemporaryLifetimeExtendedViaSubobject = true;
             }
           }
         }
+      }
       // TODO: Support temporaries lifetime-extended via static references.
       // They'd need a getCXXStaticTempObjectRegion().
       CallOpts.IsTemporaryCtorOrDtor = true;
       return MRMgr.getCXXTempObjectRegion(CE, LCtx);
     }
     case ConstructionContext::SimpleReturnedValueKind: {
       // The temporary is to be managed by the parent stack frame.
       // So build it in the parent stack frame if we're not in the

lib/StaticAnalyzer/Core/ExprEngineCallAndReturn.cpp

if (CtorExpr->getConstructionKind() == CXXConstructExpr::CK_Complete) {
       // the fake temporary target.
       if (CallOpts.IsCtorOrDtorWithImproperlyModeledTargetRegion)
         return CIP_DisallowedOnce;
 
       // If the temporary is lifetime-extended by binding a smaller object
       // within it to a reference, automatic destructors don't work properly.
       if (CallOpts.IsTemporaryLifetimeExtendedViaSubobject)
         return CIP_DisallowedOnce;
+
+      // If the temporary is lifetime-extended by binding it to a reference-typ
+      // field within an aggregate, automatic destructors don't work properly.
+      if (CallOpts.IsTemporaryLifetimeExtendedViaAggregate)
+        return CIP_DisallowedOnce;
     }
 
     break;
   }
   case CE_CXXDestructor: {
     if (!Opts.mayInlineCXXMemberFunction(CIMK_Destructors))
       return CIP_DisallowedAlways;
 

test/Analysis/lifetime-extension.cpp

 void f5() {
   C *after, *before;
   {
     const bool &x = C(true, &after, &before).x; // no-crash
   }
   // FIXME: Should be TRUE. Should not warn about garbage value.
   clang_analyzer_eval(after == before); // expected-warning{{UNKNOWN}}
 }
+
+void f6() {
+  C *after, *before;
+  {
+    struct A { // A is an aggregate.
+      const C &c;
+    };
+    A a{C(true, &after, &before)};
+  }
+  // FIXME: Should be TRUE. Should not warn about garbage value.
+  clang_analyzer_eval(after == before); // expected-warning{{UNKNOWN}}
+}
+
+void f7() {
+  C *after, *before;
+  {
+    struct A { // A is an aggregate.
+      const C &c;
+    };
+    A a = {C(true, &after, &before)};
+  }
+  // FIXME: Should be TRUE. Should not warn about garbage value.
+  clang_analyzer_eval(after == before); // expected-warning{{UNKNOWN}}
+}
 } // end namespace maintain_original_object_address_on_lifetime_extension
 
 namespace maintain_original_object_address_on_move {
 class C {
   int *x;
 
 public:
   C() : x(nullptr) {}