[analyzer] Don't pretend that unknown block calls have one null parameter.

[NoQ]

Summary

CallEvent::parameters() returns an ArrayRef<ParmVarDecl *> and usually either delegates all the work to the underlying Decl or return an empty array if the underlying Decl is unavailable (eg., calling a symbolic function pointer). Returning an empty array is usually done with a convenient ArrayRef(llvm::NoneType) constructor: return None;. Returning an {} would have the same effect, and i don't have any preferences here.

At the same time, return nullptr; means a completely different thing: it produces an ArrayRef to a literal array of 1 element, and this element is equal to nullptr. This corresponds to the other common pattern: when something accepts an ArrayRef, it also automatically accepts a single element and transparently turns it into an array of 1 element, which is often convenient.

The BlockCall kind of CallEvent was incorrectly returning nullptr. This, well, wasn't quite expected by the newly added OSObject support in RetainCountChecker.

Fix BlockCall to return an empty parameter array when a symbolic block is called.

[dcoughlin]

Looks good to me!

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

const BlockDataRegion *BlockCall::getBlockRegion() const {
   const MemRegion *DataReg = getSVal(Callee).getAsRegion();
 
   return dyn_cast_or_null<BlockDataRegion>(DataReg);
 }
 
 ArrayRef<ParmVarDecl*> BlockCall::parameters() const {
   const BlockDecl *D = getDecl();
   if (!D)
-    return nullptr;
+    return None;
   return D->parameters();
 }
 
 void BlockCall::getExtraInvalidatedValues(ValueList &Values,
                   RegionAndSymbolInvalidationTraits *ETraits) const {
   // FIXME: This also needs to invalidate captured globals.
   if (const MemRegion *R = getBlockRegion())
     Values.push_back(loc::MemRegionVal(R));

cfe/trunk/test/Analysis/osobject-retain-release.cpp

-// RUN: %clang_analyze_cc1 -analyze -analyzer-checker=core,osx -analyzer-output=text -verify %s
+// RUN: %clang_analyze_cc1 -fblocks -analyze -analyzer-output=text\
+// RUN:                    -analyzer-checker=core,osx -verify %s
 
 struct OSMetaClass;
 
 #define OS_CONSUME __attribute__((os_consumed))
 #define OS_RETURNS_RETAINED __attribute__((os_returns_retained))
 #define OS_RETURNS_NOT_RETAINED __attribute__((os_returns_not_retained))
 #define OS_CONSUMES_THIS __attribute__((os_consumes_this))
 

 }
 
 unsigned int ok_release_with_unknown_source(ArrayOwner *owner) {
   OSArray *arr = owner->getArraySourceUnknown(); // +0
   arr->retain(); // +1
   arr->release(); // +0
   return arr->getCount();
 }
+
+OSObject *getObject();
+typedef bool (^Blk)(OSObject *);
+
+void test_escape_to_unknown_block(Blk blk) {
+  blk(getObject()); // no-crash
+}
+