Explicitly keep track of temporaries during the consumed analysis.

[klimek]

Summary

This makes the consumed analysis less dependent on the CFG layout and fixes
a bug where we wouldn't warn on an unconsumed value.

[delesley]

LGTM. Thanks for the patch!

include/clang/Analysis/Analyses/Consumed.h

public:
     void setSource(const Stmt *Source) { this->From = Source; }
     
     /// \brief Set the consumed state of a given variable.
     void setState(const VarDecl *Var, ConsumedState State);
     
     /// \brief Set the consumed state of a given temporary value.
     void setState(const CXXBindTemporaryExpr *Tmp, ConsumedState State);
     
-    /// \brief Remove the variable from our state map.
-    void remove(const VarDecl *Var);
+    /// \brief Remove the temporary value from our state map.
+    void remove(const CXXBindTemporaryExpr *Tmp);
     
     /// \brief Tests to see if there is a mismatch in the states stored in two
     /// maps.
     ///
     /// \param Other -- The second map to compare against.
     bool operator!=(const ConsumedStateMap *Other) const;
   };
   

lib/Analysis/Consumed.cpp

void ConsumedStateMap::setState(const VarDecl *Var, ConsumedState State) {
   VarMap[Var] = State;
 }
 
 void ConsumedStateMap::setState(const CXXBindTemporaryExpr *Tmp,
                                 ConsumedState State) {
   TmpMap[Tmp] = State;
 }
 
-void ConsumedStateMap::remove(const VarDecl *Var) {
-  VarMap.erase(Var);
+void ConsumedStateMap::remove(const CXXBindTemporaryExpr *Tmp) {
+  TmpMap.erase(Tmp);
 }
 
 bool ConsumedStateMap::operator!=(const ConsumedStateMap *Other) const {
   for (const auto &DM : Other->VarMap)
     if (this->getState(DM.first) != DM.second)
       return true;  
   return false;
 }
for (const auto &B : *CurrBlock) {
         
       case CFGElement::TemporaryDtor: {
         const CFGTemporaryDtor &DTor = B.castAs<CFGTemporaryDtor>();
         const CXXBindTemporaryExpr *BTE = DTor.getBindTemporaryExpr();
         
         Visitor.checkCallability(PropagationInfo(BTE),
                                  DTor.getDestructorDecl(AC.getASTContext()),
                                  BTE->getExprLoc());
+        CurrStates->remove(BTE);
         break;
       }
       
       case CFGElement::AutomaticObjectDtor: {
         const CFGAutomaticObjDtor &DTor = B.castAs<CFGAutomaticObjDtor>();
         SourceLocation Loc = DTor.getTriggerStmt()->getLocEnd();
         const VarDecl *Var = DTor.getVarDecl();
         
         Visitor.checkCallability(PropagationInfo(Var),
                                  DTor.getDestructorDecl(AC.getASTContext()),
                                  Loc);
         break;
       }
       
       default:
         break;
       }
     }
     
-    CurrStates->clearTemporaries();
-    
     // TODO: Handle other forms of branching with precision, including while-
     //       and for-loops. (Deferred)
     if (!splitState(CurrBlock, Visitor)) {
       CurrStates->setSource(NULL);
       
       if (CurrBlock->succ_size() > 1 ||
           (CurrBlock->succ_size() == 1 &&
            (*CurrBlock->succ_begin())->pred_size() > 1)) {

test/SemaCXX/warn-consumed-analysis.cpp

public:
 
   bool check()  const SET_TYPESTATE(consumed);
   void ignore() const SET_TYPESTATE(consumed);
   // Status& markAsChecked() { return *this; }
 
   void clear() CALLABLE_WHEN("unknown", "consumed") SET_TYPESTATE(consumed);
 
   ~Status() CALLABLE_WHEN("unknown", "consumed");
+
+  operator bool() const; // Will not consume the object.
 };
 
 
 bool   cond();
 Status doSomething();
 void   handleStatus(const Status& s RETURN_TYPESTATE(consumed));
 void   handleStatusRef(Status& s);
 void   handleStatusPtr(Status* s);

 void testSimpleTemporaries2() {
   handleStatus(doSomething());
 }
 
 void testSimpleTemporaries3() {
   Status s = doSomething();
 }  // expected-warning {{invalid invocation of method '~Status' on object 's' while it is in the 'unconsumed' state}}
 
+void testTemporariesWithControlFlow(bool a) {
+  bool b = false || doSomething(); // expected-warning {{invalid invocation of method '~Status' on a temporary object while it is in the 'unconsumed' state}}
+}
+
 Status testSimpleTemporariesReturn0() {
   return doSomething();
 }
 
 Status testSimpleTemporariesReturn1() {
   Status s = doSomething();
   return s;
 }