[CFG] [analyzer] Remove unnecessary CXXBindTemporaryExpr from lifetime-extended temporary construction contexts.

[NoQ]

Summary

CXXBindTemporaryExpr is used for attaching the destructor of the temporary object to it.

If the object is lifetime-extended (which is indicated by the surrounding MaterializeTemporaryExpr's storage duration property), then it doesn't require a temporary object destructor; it'll instead be destroyed automatically.

Remove CXXBindTemporaryExpr completely from the ConstructionContext in this case, instead of making clients take care of it.

[NoQ]

Rebase.

cfe/trunk/lib/Analysis/ConstructionContext.cpp

if (const auto *BTE = dyn_cast<CXXBindTemporaryExpr>(S)) {
                                                                         I, BTE);
         }
         assert(ParentLayer->getTriggerStmt() &&
                "Non-statement-based layers have been handled above!");
         // This is the normal, non-C++17 case: a temporary object which has
         // both destruction and materialization info attached to it in the AST.
         if ((MTE = dyn_cast<MaterializeTemporaryExpr>(
                  ParentLayer->getTriggerStmt()))) {
+          if (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;
+          }
+
           // Handle pre-C++17 copy and move elision.
           const CXXConstructExpr *ElidedCE = nullptr;
           const ConstructionContext *ElidedCC = nullptr;
           if (const ConstructionContextLayer *ElidedLayer =
                   ParentLayer->getParent()) {
             ElidedCE = cast<CXXConstructExpr>(ElidedLayer->getTriggerStmt());
             assert(ElidedCE->isElidable());
             // We're creating a construction context that might have already

cfe/trunk/lib/StaticAnalyzer/Core/ExprEngineCXX.cpp

if (CC) {
     case ConstructionContext::ElidedTemporaryObjectKind:
       assert(AMgr.getAnalyzerOptions().shouldElideConstructors());
       // FALL-THROUGH
     case ConstructionContext::SimpleTemporaryObjectKind: {
       // TODO: Copy elision implementation goes here.
       const auto *TCC = cast<TemporaryObjectConstructionContext>(CC);
       const CXXBindTemporaryExpr *BTE = TCC->getCXXBindTemporaryExpr();
       const MaterializeTemporaryExpr *MTE = TCC->getMaterializedTemporaryExpr();
+      SVal V = UnknownVal();
 
       if (MTE) {
         if (const ValueDecl *VD = MTE->getExtendingDecl()) {
           assert(MTE->getStorageDuration() != SD_FullExpression);
           if (!VD->getType()->isReferenceType()) {
             // We're lifetime-extended by a surrounding aggregate.
             // Automatic destructors aren't quite working in this case
             // on the CFG side. We should warn the caller about that.
             // FIXME: Is there a better way to retrieve this information from
             // the MaterializeTemporaryExpr?
             CallOpts.IsTemporaryLifetimeExtendedViaAggregate = true;
           }
         }
-      }
-
-      SVal V = UnknownVal();
-      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 (MTE->getStorageDuration() == SD_Static ||
             MTE->getStorageDuration() == SD_Thread)
           V = loc::MemRegionVal(MRMgr.getCXXStaticTempObjectRegion(E));
       }
 
       if (V.isUnknown())
         V = loc::MemRegionVal(MRMgr.getCXXTempObjectRegion(E, LCtx));

cfe/trunk/test/Analysis/auto-obj-dtors-cfg-output.cpp

 // CHECK:      [B1]
 // WARNINGS-NEXT:   1:  (CXXConstructExpr, class A)
 // ANALYZER-NEXT:   1:  (CXXConstructExpr, [B1.2], class A)
 // CHECK-NEXT:   2: A a;
 // CHECK-NEXT:   3: a
 // CHECK-NEXT:   4: [B1.3] (ImplicitCastExpr, NoOp, const class A)
 // CHECK-NEXT:   5: const A &b = a;
 // WARNINGS-NEXT:   6: A() (CXXConstructExpr, class A)
-// ANALYZER-NEXT:   6: A() (CXXConstructExpr, [B1.7], [B1.9], class A)
+// ANALYZER-NEXT:   6: A() (CXXConstructExpr, [B1.9], class A)
 // CHECK-NEXT:   7: [B1.6] (BindTemporary)
 // CHECK-NEXT:   8: [B1.7] (ImplicitCastExpr, NoOp, const class A)
 // CHECK-NEXT:   9: [B1.8]
 // CHECK:       10: const A &c = A();
 // CHECK:       11: [B1.10].~A() (Implicit destructor)
 // CHECK:       12: [B1.2].~A() (Implicit destructor)
 // CHECK-NEXT:   Preds (1): B2
 // CHECK-NEXT:   Succs (1): B0
 // CHECK:      [B0 (EXIT)]
 // CHECK-NEXT:   Preds (1): B1
 void test_const_ref() {
   A a;
   const A& b = a;
   const A& c = A();
 }
 
 // CHECK:      [B2 (ENTRY)]
 // CHECK-NEXT:   Succs (1): B1
 // CHECK:      [B1]
 // WARNINGS-NEXT:   1: A() (CXXConstructExpr, class A)
 // CXX98-ANALYZER-NEXT:   1: A() (CXXConstructExpr, [B1.2], class A)
-// CXX11-ANALYZER-NEXT:   1: A() (CXXConstructExpr, [B1.2], [B1.3], class A)
+// CXX11-ANALYZER-NEXT:   1: A() (CXXConstructExpr, [B1.3], class A)
 // CHECK-NEXT:   2: [B1.1] (BindTemporary)
 // CXX98-NEXT:   3: [B1.2].x
 // CXX98-NEXT:   4: [B1.3]
 // CXX98-NEXT:   5: const int &x = A().x;
 // CXX98-NEXT:   6: [B1.5].~A() (Implicit destructor)
 // CXX11-NEXT:   3: [B1.2]
 // CXX11-NEXT:   4: [B1.3].x
 // CXX11-NEXT:   5: [B1.4] (ImplicitCastExpr, NoOp, const int)
 // CXX11-NEXT:   6: const int &x = A().x;
 // CXX11-NEXT:   7: [B1.6].~A() (Implicit destructor)
 // CHECK-NEXT:   Preds (1): B2
 // CHECK-NEXT:   Succs (1): B0
 // CHECK:      [B0 (EXIT)]
 // CHECK-NEXT:   Preds (1): B1
 void test_const_ref_to_field() {
   const int &x = A().x;
 }
 
 // CHECK:        [B2 (ENTRY)]
 // CHECK-NEXT:     Succs (1): B1
 // CHECK:        [B1]
 // WARNINGS-NEXT:     1: A() (CXXConstructExpr, class A)
 // CXX98-ANALYZER-NEXT:     1: A() (CXXConstructExpr, [B1.2], class A)
-// CXX11-ANALYZER-NEXT:     1: A() (CXXConstructExpr, [B1.2], [B1.3], class A)
+// CXX11-ANALYZER-NEXT:     1: A() (CXXConstructExpr, [B1.3], class A)
 // CHECK-NEXT:     2: [B1.1] (BindTemporary)
 // CXX98-NEXT:     3: A::x
 // CXX98-NEXT:     4: &[B1.3]
 // CXX98-NEXT:     5: [B1.2] .* [B1.4]
 // CXX98-NEXT:     6: [B1.5]
 // CXX98-NEXT:     7: const int &x = A() .* &A::x;
 // CXX98-NEXT:     8: [B1.7].~A() (Implicit destructor)
 // CXX11-NEXT:     3: [B1.2]
void test_pointer_to_member() {
   const int &x = A().*&A::x;
 }
 
 // FIXME: There should be automatic destructors at the end of scope.
 // CHECK:        [B2 (ENTRY)]
 // CHECK-NEXT:     Succs (1): B1
 // CHECK:        [B1]
 // WARNINGS-NEXT:     1: A() (CXXConstructExpr, class A)
-// ANALYZER-NEXT:     1: A() (CXXConstructExpr, [B1.2], [B1.4], class A)
+// ANALYZER-NEXT:     1: A() (CXXConstructExpr, [B1.4], class A)
 // CHECK-NEXT:     2: [B1.1] (BindTemporary)
 // CHECK-NEXT:     3: [B1.2] (ImplicitCastExpr, NoOp, const class A)
 // CHECK-NEXT:     4: [B1.3]
 // CHECK-NEXT:     5: {[B1.4]}
 // CHECK-NEXT:     6: B b = {A()};
 // WARNINGS-NEXT:     7: A() (CXXConstructExpr, class A)
-// ANALYZER-NEXT:     7: A() (CXXConstructExpr, [B1.8], [B1.10], class A)
+// ANALYZER-NEXT:     7: A() (CXXConstructExpr, [B1.10], class A)
 // CHECK-NEXT:     8: [B1.7] (BindTemporary)
 // CHECK-NEXT:     9: [B1.8] (ImplicitCastExpr, NoOp, const class A)
 // CHECK-NEXT:    10: [B1.9]
 // CHECK-NEXT:    11: {[B1.10]}
 // WARNINGS-NEXT:    12: A() (CXXConstructExpr, class A)
-// ANALYZER-NEXT:    12: A() (CXXConstructExpr, [B1.13], [B1.15], class A)
+// ANALYZER-NEXT:    12: A() (CXXConstructExpr, [B1.15], class A)
 // CHECK-NEXT:    13: [B1.12] (BindTemporary)
 // CHECK-NEXT:    14: [B1.13] (ImplicitCastExpr, NoOp, const class A)
 // CHECK-NEXT:    15: [B1.14]
 // CHECK-NEXT:    16: {[B1.15]}
 // CHECK-NEXT:    17: {[B1.10], [B1.15]}
 // CHECK-NEXT:    18: B bb[2] = {A(), A()};
 // CHECK-NEXT:     Preds (1): B2
 // CHECK-NEXT:     Succs (1): B0

cfe/trunk/test/Analysis/cfg-rich-constructors.cpp

 // CHECK-NEXT:     7: ~temporary_object_expr_with_dtors::D() (Temporary object destructor)
 // CHECK-NEXT:     T: if [B2.6]
 void temporaryInCondition() {
   if (D());
 }
 
 // CHECK: void referenceVariableWithConstructor()
 // CHECK:          1: 0
-// CHECK-NEXT:     2: [B1.1] (CXXConstructExpr, [B1.3], [B1.4], const class temporary_object_expr_with_dtors::D)
+// CHECK-NEXT:     2: [B1.1] (CXXConstructExpr, [B1.4], const class temporary_object_expr_with_dtors::D)
 // CHECK-NEXT:     3: [B1.2] (BindTemporary)
 // CHECK-NEXT:     4: [B1.3]
 // CHECK-NEXT:     5: const temporary_object_expr_with_dtors::D &d(0);
 // CHECK-NEXT:     6: [B1.5].~D() (Implicit destructor)
 void referenceVariableWithConstructor() {
   const D &d(0);
 }
 
 // CHECK: void referenceVariableWithInitializer()
-// CHECK:          1: temporary_object_expr_with_dtors::D() (CXXConstructExpr, [B1.2], [B1.4], class temporary_object_expr_with_dtors::D)
+// CHECK:          1: temporary_object_expr_with_dtors::D() (CXXConstructExpr, [B1.4], class temporary_object_expr_with_dtors::D)
 // CHECK-NEXT:     2: [B1.1] (BindTemporary)
 // CHECK-NEXT:     3: [B1.2] (ImplicitCastExpr, NoOp, const class temporary_object_expr_with_dtors::D)
 // CHECK-NEXT:     4: [B1.3]
 // CHECK-NEXT:     5: const temporary_object_expr_with_dtors::D &d = temporary_object_expr_with_dtors::D();
 // CHECK-NEXT:     6: [B1.5].~D() (Implicit destructor)
 void referenceVariableWithInitializer() {
   const D &d = D();
 }

 // CXX11:        [B5]
 // CXX11-NEXT:     1: D::get
 // CXX11-NEXT:     2: [B5.1] (ImplicitCastExpr, FunctionToPointerDecay, class temporary_object_expr_with_dtors::D (*)(void))
 // CXX11-ELIDE-NEXT:     3: [B5.2]() (CXXRecordTypedCall, [B5.4], [B5.6], [B5.7])
 // CXX11-NOELIDE-NEXT:     3: [B5.2]() (CXXRecordTypedCall, [B5.4], [B5.6])
 // CXX11-NEXT:     4: [B5.3] (BindTemporary)
 // CXX11-NEXT:     5: [B5.4] (ImplicitCastExpr, NoOp, const class temporary_object_expr_with_dtors::D)
 // CXX11-NEXT:     6: [B5.5]
-// CXX11-NEXT:     7: [B5.6] (CXXConstructExpr, [B5.8], [B4.3], class temporary_object_expr_with_dtors::D)
+// CXX11-NEXT:     7: [B5.6] (CXXConstructExpr, [B4.3], class temporary_object_expr_with_dtors::D)
 // CXX11-NEXT:     8: [B5.7] (BindTemporary)
 // CXX11:        [B6]
 // CXX11-NEXT:     1: 0
 // CXX11-ELIDE-NEXT:     2: [B6.1] (CXXConstructExpr, [B6.3], [B6.6], [B6.7], class temporary_object_expr_with_dtors::D)
 // CXX11-NOELIDE-NEXT:     2: [B6.1] (CXXConstructExpr, [B6.3], [B6.6], class temporary_object_expr_with_dtors::D)
 // CXX11-NEXT:     3: [B6.2] (BindTemporary)
 // CXX11-NEXT:     4: temporary_object_expr_with_dtors::D([B6.3]) (CXXFunctionalCastExpr, ConstructorConversion, class temporary_object_expr_with_dtors::D)
 // CXX11-NEXT:     5: [B6.4] (ImplicitCastExpr, NoOp, const class temporary_object_expr_with_dtors::D)
 // CXX11-NEXT:     6: [B6.5]
-// CXX11-NEXT:     7: [B6.6] (CXXConstructExpr, [B6.8], [B4.3], class temporary_object_expr_with_dtors::D)
+// CXX11-NEXT:     7: [B6.6] (CXXConstructExpr, [B4.3], class temporary_object_expr_with_dtors::D)
 // CXX11-NEXT:     8: [B6.7] (BindTemporary)
 // CXX11:        [B7]
 // CXX11-NEXT:     1: coin
 // CXX11-NEXT:     2: [B7.1] (ImplicitCastExpr, LValueToRValue, _Bool)
 // CXX11-NEXT:     T: [B7.2] ? ... : ...
 // CXX17:        [B1]
 // CXX17-NEXT:     1: [B4.2] ? [B2.4] : [B3.4]
 // CXX17-NEXT:     2: [B1.1] (ImplicitCastExpr, NoOp, const class temporary_object_expr_with_dtors::D)
 // CXX17-NEXT:     3: [B1.2]
 // CXX17-NEXT:     4: const temporary_object_expr_with_dtors::D &d = coin ? D::get() : temporary_object_expr_with_dtors::D(0);
 // CXX17-NEXT:     5: [B1.4].~D() (Implicit destructor)
 // CXX17:        [B2]
 // CXX17-NEXT:     1: D::get
 // CXX17-NEXT:     2: [B2.1] (ImplicitCastExpr, FunctionToPointerDecay, class temporary_object_expr_with_dtors::D (*)(void))
-// CXX17-NEXT:     3: [B2.2]() (CXXRecordTypedCall, [B2.4], [B1.3])
+// CXX17-NEXT:     3: [B2.2]() (CXXRecordTypedCall, [B1.3])
 // CXX17-NEXT:     4: [B2.3] (BindTemporary)
 // CXX17:        [B3]
 // CXX17-NEXT:     1: 0
-// CXX17-NEXT:     2: [B3.1] (CXXConstructExpr, [B3.3], [B1.3], class temporary_object_expr_with_dtors::D)
+// CXX17-NEXT:     2: [B3.1] (CXXConstructExpr, [B1.3], class temporary_object_expr_with_dtors::D)
 // CXX17-NEXT:     3: [B3.2] (BindTemporary)
 // CXX17-NEXT:     4: temporary_object_expr_with_dtors::D([B3.3]) (CXXFunctionalCastExpr, ConstructorConversion, class temporary_object_expr_with_dtors::D)
 // CXX17:        [B4]
 // CXX17-NEXT:     1: coin
 // CXX17-NEXT:     2: [B4.1] (ImplicitCastExpr, LValueToRValue, _Bool)
 // CXX17-NEXT:     T: [B4.2] ? ... : ...
 void referenceVariableWithTernaryOperator(bool coin) {
   const D &d = coin ? D::get() : D(0);
 }
 
 // CHECK: void referenceWithFunctionalCast()
 // CHECK:          1: 1
-// CHECK-NEXT:     2: [B1.1] (CXXConstructExpr, [B1.3], [B1.5], class temporary_object_expr_with_dtors::D)
+// CHECK-NEXT:     2: [B1.1] (CXXConstructExpr, [B1.5], class temporary_object_expr_with_dtors::D)
 // CHECK-NEXT:     3: [B1.2] (BindTemporary)
 // CHECK-NEXT:     4: temporary_object_expr_with_dtors::D([B1.3]) (CXXFunctionalCastExpr, ConstructorCon
 // CHECK-NEXT:     5: [B1.4]
 // CHECK-NEXT:     6: temporary_object_expr_with_dtors::D &&d = temporary_object_expr_with_dtors::D(1);
 // CHECK-NEXT:     7: [B1.6].~D() (Implicit destructor)
 void referenceWithFunctionalCast() {
   D &&d = D(1);
 }

cfe/trunk/test/Analysis/temp-obj-dtors-cfg-output.cpp

 // CHECK:     Succs (2): B9 B8
 // CHECK:   [B11]
 // WARNINGS:     1: A() (CXXConstructExpr, class A)
 // ANALYZER:     1: A() (CXXConstructExpr, [B11.2], [B11.4], [B11.5], class A)
 // CHECK:     2: [B11.1] (BindTemporary)
 // CHECK:     3: [B11.2] (ImplicitCastExpr, NoOp, const class A)
 // CHECK:     4: [B11.3]
 // WARNINGS:     5: [B11.4] (CXXConstructExpr, class A)
-// ANALYZER:     5: [B11.4] (CXXConstructExpr, [B11.6], [B10.3], class A)
+// ANALYZER:     5: [B11.4] (CXXConstructExpr, [B10.3], class A)
 // CHECK:     6: [B11.5] (BindTemporary)
 // CHECK:     Preds (1): B13
 // CHECK:     Succs (1): B10
 // CHECK:   [B12]
 // WARNINGS:     1: B() (CXXConstructExpr, class B)
 // ANALYZER:     1: B() (CXXConstructExpr, [B12.2], class B)
 // CHECK:     2: [B12.1] (BindTemporary)
 // CHECK:     3: [B12.2].operator A
 // CHECK:     4: [B12.2]
 // CHECK:     5: [B12.4] (ImplicitCastExpr, UserDefinedConversion, class A)
 // CHECK:     6: [B12.5] (BindTemporary)
 // CHECK:     7: [B12.6] (ImplicitCastExpr, NoOp, const class A)
 // CHECK:     8: [B12.7]
 // WARNINGS:     9: [B12.8] (CXXConstructExpr, class A)
 // ANALYZER:     9: [B12.8] (CXXConstructExpr, [B12.10], [B12.13], [B12.14], class A)
 // CHECK:    10: [B12.9] (BindTemporary)
 // CHECK:    11: A([B12.10]) (CXXFunctionalCastExpr, ConstructorConversion, class A)
 // CHECK:    12: [B12.11] (ImplicitCastExpr, NoOp, const class A)
 // CHECK:    13: [B12.12]
 // WARNINGS:    14: [B12.13] (CXXConstructExpr, class A)
-// ANALYZER:    14: [B12.13] (CXXConstructExpr, [B12.15], [B10.3], class A)
+// ANALYZER:    14: [B12.13] (CXXConstructExpr, [B10.3], class A)
 // CHECK:    15: [B12.14] (BindTemporary)
 // CHECK:     Preds (1): B13
 // CHECK:     Succs (1): B10
 // CHECK:   [B13]
 // WARNINGS:     1: B() (CXXConstructExpr, class B)
 // ANALYZER:     1: B() (CXXConstructExpr, [B13.2], class B)
 // CHECK:     2: [B13.1] (BindTemporary)
 // CHECK:     3: [B13.2].operator bool

 // CHECK:     Preds (1): B2
 // CHECK:     Succs (1): B0
 // CHECK:   [B0 (EXIT)]
 // CHECK:     Preds (1): B1
 // CHECK:   [B2 (ENTRY)]
 // CHECK:     Succs (1): B1
 // CHECK:   [B1]
 // WARNINGS:     1: A() (CXXConstructExpr, class A)
-// ANALYZER:     1: A() (CXXConstructExpr, [B1.2], [B1.4], class A)
+// ANALYZER:     1: A() (CXXConstructExpr, [B1.4], class A)
 // CHECK:     2: [B1.1] (BindTemporary)
 // CHECK:     3: [B1.2] (ImplicitCastExpr, NoOp, const class A)
 // CHECK:     4: [B1.3]
 // CHECK:     5: const A &a = A();
 // CHECK:     6: foo
 // CHECK:     7: [B1.6] (ImplicitCastExpr, FunctionToPointerDecay, void (*)(const class A &))
 // WARNINGS:     8: A() (CXXConstructExpr, class A)
 // ANALYZER:     8: A() (CXXConstructExpr, [B1.9], [B1.11], class A)

 // CHECK:   [B0 (EXIT)]
 // CHECK:     Preds (1): B1
 // CHECK:   [B2 (ENTRY)]
 // CHECK:     Succs (1): B1
 // CHECK:   [B1]
 // CHECK:     1: A::make
 // CHECK:     2: [B1.1] (ImplicitCastExpr, FunctionToPointerDecay, class A (*)(void))
 // WARNINGS:     3: [B1.2]()
-// ANALYZER:     3: [B1.2]() (CXXRecordTypedCall, [B1.4], [B1.6])
+// ANALYZER:     3: [B1.2]() (CXXRecordTypedCall, [B1.6])
 // CHECK:     4: [B1.3] (BindTemporary)
 // CHECK:     5: [B1.4] (ImplicitCastExpr, NoOp, const class A)
 // CHECK:     6: [B1.5]
 // CHECK:     7: const A &a = A::make();
 // CHECK:     8: foo
 // CHECK:     9: [B1.8] (ImplicitCastExpr, FunctionToPointerDecay, void (*)(const class A &))
 // CHECK:    10: A::make
 // CHECK:    11: [B1.10] (ImplicitCastExpr, FunctionToPointerDecay, class A (*)(void))