[analyzer] ConditionBRVisitor: Boolean support

[Charusso]

Summary

-

[NoQ]

Yup. Yay.

[Charusso]

• Rebased: tookTrue -> TookTrue.

[Charusso]

Whops, sorry.

[Charusso]

• Rebased

lib/StaticAnalyzer/Core/BugReporterVisitors.cpp

bool ConditionBRVisitor::printValue(const Expr *CondVarExpr,
 
   if (!Ty->isIntegralOrEnumerationType())
     return false;
 
   Optional<const llvm::APSInt *> IntValue;
   if (!IsAssuming)
     IntValue = getConcreteIntegerValue(CondVarExpr, N);
 
-  if (IsAssuming || !IntValue.hasValue())
+  if (IsAssuming || !IntValue.hasValue()) {
+    if (Ty->isBooleanType())
+      Out << (TookTrue ? "true" : "false");
+    else
       Out << (TookTrue ? "not equal to 0" : "0");
+  } else {
+    if (Ty->isBooleanType())
+      Out << (IntValue.getValue()->getBoolValue() ? "true" : "false");
     else
       Out << *IntValue.getValue();
+  }
 
   return true;
 }
 
 const char *const ConditionBRVisitor::TrueMessage = "The condition is true";
 const char *const ConditionBRVisitor::FalseMessage = "The condition is false";
 const char *const ConditionBRVisitor::AssumingTrueMessage =
     "Assuming the condition is true";

test/Analysis/Inputs/expected-plists/cxx-for-range.cpp.plist

<array>
          <key>line</key><integer>32</integer>
          <key>col</key><integer>10</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>1</integer>
      <key>extended_message</key>
-     <string>&apos;fail&apos; is 1</string>
+     <string>&apos;fail&apos; is true</string>
      <key>message</key>
-     <string>&apos;fail&apos; is 1</string>
+     <string>&apos;fail&apos; is true</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>

test/Analysis/diagnostics/no-store-func-path-notes.cpp

 
 struct C {
   int x;
   int y;
   C(int pX, int pY) : x(pX) {} // expected-note{{Returning without writing to 'this->y'}}
 
   C(int pX, int pY, bool Flag) {
     x = pX;
-    if (Flag) // expected-note{{Assuming 'Flag' is not equal to 0}}
+    if (Flag) // expected-note{{Assuming 'Flag' is true}}
               // expected-note@-1{{Taking true branch}}
       return; // expected-note{{Returning without writing to 'this->y'}}
     y = pY;
   }
 };
 
 int use_constructor() {
   C c(0, 0); // expected-note{{Calling constructor for 'C'}}

test/Analysis/inner-pointer.cpp

const char *c, *d;
     std::string s;
     c = s.c_str(); // expected-note {{Pointer to inner buffer of 'std::string' obtained here}}
     d = s.data();  // expected-note {{Pointer to inner buffer of 'std::string' obtained here}}
   }                // expected-note {{Inner buffer of 'std::string' deallocated by call to destructor}}
   // expected-note@-1 {{Inner buffer of 'std::string' deallocated by call to destructor}}
   std::string s;
   const char *c2 = s.c_str();
   if (cond) {
-    // expected-note@-1 {{Assuming 'cond' is not equal to 0}}
+    // expected-note@-1 {{Assuming 'cond' is true}}
     // expected-note@-2 {{Taking true branch}}
-    // expected-note@-3 {{Assuming 'cond' is 0}}
+    // expected-note@-3 {{Assuming 'cond' is false}}
     // expected-note@-4 {{Taking false branch}}
     consume(c); // expected-warning {{Inner pointer of container used after re/deallocation}}
     // expected-note@-1 {{Inner pointer of container used after re/deallocation}}
   } else {
     consume(d); // expected-warning {{Inner pointer of container used after re/deallocation}}
     // expected-note@-1 {{Inner pointer of container used after re/deallocation}}
   }
 }
const wchar_t *c, *d;
     std::wstring s;
     c = s.c_str(); // expected-note {{Pointer to inner buffer of 'std::wstring' obtained here}}
     d = s.data();  // expected-note {{Pointer to inner buffer of 'std::wstring' obtained here}}
   }                // expected-note {{Inner buffer of 'std::wstring' deallocated by call to destructor}}
   // expected-note@-1 {{Inner buffer of 'std::wstring' deallocated by call to destructor}}
   std::wstring s;
   const wchar_t *c2 = s.c_str();
   if (cond) {
-    // expected-note@-1 {{Assuming 'cond' is not equal to 0}}
+    // expected-note@-1 {{Assuming 'cond' is true}}
     // expected-note@-2 {{Taking true branch}}
-    // expected-note@-3 {{Assuming 'cond' is 0}}
+    // expected-note@-3 {{Assuming 'cond' is false}}
     // expected-note@-4 {{Taking false branch}}
     consume(c); // expected-warning {{Inner pointer of container used after re/deallocation}}
     // expected-note@-1 {{Inner pointer of container used after re/deallocation}}
   } else {
     consume(d); // expected-warning {{Inner pointer of container used after re/deallocation}}
     // expected-note@-1 {{Inner pointer of container used after re/deallocation}}
   }
 }
const char *c1, *d1;
     d1 = s1.data();  // expected-note {{Pointer to inner buffer of 'std::string' obtained here}}
     const char *local = s1.c_str();
     consume(local); // no-warning
   }                 // expected-note {{Inner buffer of 'std::string' deallocated by call to destructor}}
   // expected-note@-1 {{Inner buffer of 'std::string' deallocated by call to destructor}}
   std::string s2;
   const char *c2 = s2.c_str();
   if (cond) {
-    // expected-note@-1 {{Assuming 'cond' is not equal to 0}}
+    // expected-note@-1 {{Assuming 'cond' is true}}
     // expected-note@-2 {{Taking true branch}}
-    // expected-note@-3 {{Assuming 'cond' is 0}}
+    // expected-note@-3 {{Assuming 'cond' is false}}
     // expected-note@-4 {{Taking false branch}}
     consume(c1); // expected-warning {{Inner pointer of container used after re/deallocation}}
     // expected-note@-1 {{Inner pointer of container used after re/deallocation}}
   } else {
     consume(d1); // expected-warning {{Inner pointer of container used after re/deallocation}}
   }              // expected-note@-1 {{Inner pointer of container used after re/deallocation}}
 }
 

test/Analysis/use-after-move.cpp

void uniqueTest(bool cond) {
   A a(42, 42.0);
   A b;
   b = std::move(a);
 
   if (cond) {
     a.foo();
 #ifndef PEACEFUL
   // expected-note@-5 {{Object 'a' is moved}}
-  // expected-note@-4 {{Assuming 'cond' is not equal to 0}}
+  // expected-note@-4 {{Assuming 'cond' is true}}
   // expected-note@-5 {{Taking true branch}}
   // expected-warning@-5 {{Method called on moved-from object 'a'}}
   // expected-note@-6    {{Method called on moved-from object 'a'}}
 #endif
   }
   if (cond) {
     a.bar(); // no-warning
   }