A non-principled fix of the symptom.

[klimek]

Summary

Fixing the asserts for static temporary destructors...

[alexmc]

Thanks Manuel!

lib/StaticAnalyzer/Core/ExprEngine.cpp

1383

Could you please add a comment explaining what this does (handle blocks that only have a terminator, which are constructed for temporary object handling by VisitBinaryOperatorForTemporaryDtors)?

1389

Could you add an assert message (or comment) explaining what's happened when this assert fires? This is still somewhat mysterious to me.

lib/StaticAnalyzer/Core/ExprEngine.cpp

for (; I != E; ++I) {
     Optional<CFGStmt> CS = Elem.getAs<CFGStmt>();
     if (!CS)
       continue;
     if (CS->getStmt() != Condition)
       break;
     return Condition;
   }
 
+  if (I == E) {
+    const Stmt *TC = B->getTerminatorCondition();
+    assert(TC);
+    return TC;
+  }
+
   assert(I != E);
 
   while (Condition) {
     BO = dyn_cast<BinaryOperator>(Condition);
     if (!BO || !BO->isLogicalOp())
       return Condition;
     Condition = BO->getRHS()->IgnoreParens();
   }
   llvm_unreachable("could not resolve condition");

test/Analysis/temporaries.cpp

 namespace destructors {
   void testPR16664andPR18159Crash() {
     struct Dtor {
       ~Dtor();
     };
     extern bool coin();
     extern bool check(const Dtor &);
 
-#ifndef TEMPORARY_DTORS
     // FIXME: Don't assert here when tmp dtors are enabled.
     // PR16664 and PR18159
     if (coin() && (coin() || coin() || check(Dtor()))) {
       Dtor();
     }
-#endif
   }
 
 #ifdef TEMPORARY_DTORS
   struct NoReturnDtor {
     ~NoReturnDtor() __attribute__((noreturn));
   };
 
   void noReturnTemp(int *x) {
void testConsistencyTernary(int i) {
     if (i != 5)
       return;
 
     (i == 5 && (i == 4 || check(NoReturnDtor()) || i == 5)) ? 1 : 0;
 
     clang_analyzer_eval(true); // no warning, unreachable code
   }
 
-/*
+
   // PR16664 and PR18159
-  FIXME: Don't assert here.
+  //FIXME: Don't assert here.
   void testConsistencyNested(int i) {
     extern bool compute(bool);
   
     if (i == 5 && (i == 4 || i == 5 || check(NoReturnDtor())))
-      clang_analyzer_eval(true); // expected TRUE
+      clang_analyzer_eval(true); // expected-warning{{TRUE}}
   
     if (i == 5 && (i == 4 || i == 5 || check(NoReturnDtor())))
-      clang_analyzer_eval(true);  // expected TRUE
+      clang_analyzer_eval(true);  // expected-warning{{TRUE}}
 
     if (i != 5)
       return;
 
     if (compute(i == 5 &&
                 (i == 4 || compute(true) ||
                  compute(i == 5 && (i == 4 || check(NoReturnDtor()))))) ||
         i != 4) {
-      clang_analyzer_eval(true); // expected TRUE
+      clang_analyzer_eval(true); // expected-warning{{TRUE}}
     }
 
-    FIXME: This shouldn't cause a warning.
-    if (compute(i == 5 &&
+    //FIXME: This shouldn't cause a warning.
+    if (check(NoReturnDtor()) &&
+        compute(i == 5 &&
                 (i == 4 || i == 4 ||
                  compute(i == 5 && (i == 4 || check(NoReturnDtor()))))) ||
         i != 4) {
       clang_analyzer_eval(true); // no warning, unreachable code
     }
-  }*/
+  }
 
   // PR16664 and PR18159
   void testConsistencyNestedSimple(bool value) {
     if (value) {
       if (!value || check(NoReturnDtor())) {
         clang_analyzer_eval(true); // no warning, unreachable code
       }
     }