[analyzer] [RetainCountChecker] Do not invalidate references passed to constructors and operators

[NoQ]

Let's see how it goes.

cfe/trunk/include/clang/StaticAnalyzer/Core/RetainSummaryManager.h

enum Kind {
     /// Indicates that the object is not owned and controlled by the
     /// Garbage collector.
     GCNotOwnedSymbol,
     /// Indicates that the return value is an owned object when the
     /// receiver is also a tracked object.
     OwnedWhenTrackedReceiver,
     // Treat this function as returning a non-tracked symbol even if
     // the function has been inlined. This is used where the call
-    // site summary is more presise than the summary indirectly produced
+    // site summary is more precise than the summary indirectly produced
     // by inlining the function
     NoRetHard
   };
 
   /// Determines the object kind of a tracked object.
   enum ObjKind {
     /// Indicates that the tracked object is a CF object.  This is
     /// important between GC and non-GC code.

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

RetainSummaryManager::getSummary(const CallEvent &Call,
   switch (Call.getKind()) {
   case CE_Function:
     Summ = getFunctionSummary(cast<SimpleFunctionCall>(Call).getDecl());
     break;
   case CE_CXXMember:
     Summ = getFunctionSummary(cast<CXXMemberCall>(Call).getDecl());
     break;
   case CE_CXXMemberOperator:
-  case CE_Block:
+    Summ = getFunctionSummary(cast<CXXMemberOperatorCall>(Call).getDecl());
+    break;
   case CE_CXXConstructor:
+    Summ = getFunctionSummary(cast<CXXConstructorCall>(Call).getDecl());
+    break;
+  case CE_Block:
   case CE_CXXDestructor:
   case CE_CXXAllocator:
     // FIXME: These calls are currently unsupported.
     return getPersistentStopSummary();
   case CE_ObjCMessage: {
     const ObjCMethodCall &Msg = cast<ObjCMethodCall>(Call);
     if (Msg.isInstanceMessage())
       Summ = getInstanceMethodSummary(Msg, ReceiverType);

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

struct OSArray : public OSObject {
   static OS_RETURNS_RETAINED OSArray *getOoopsActuallyCreate();
 
 
   static const OSMetaClass * const metaClass;
 };
 
 struct OtherStruct {
   static void doNothingToArray(OSArray *array);
+  OtherStruct(OSArray *arr);
 };
 
 struct OSMetaClassBase {
   static OSObject *safeMetaCast(const OSObject *inst, const OSMetaClass *meta);
 };
 
 void check_no_invalidation() {
   OSArray *arr = OSArray::withCapacity(10); // expected-note{{Call to function 'withCapacity' returns an OSObject of type struct OSArray * with a +1 retain count}}
   OtherStruct::doNothingToArray(arr);
 } // expected-warning{{Potential leak of an object stored into 'arr'}}
   // expected-note@-1{{Object leaked}}
 
+void check_no_invalidation_other_struct() {
+  OSArray *arr = OSArray::withCapacity(10); // expected-note{{Call to function 'withCapacity' returns an OSObject of type struct OSArray * with a +1 retain count}}
+  OtherStruct other(arr); // expected-warning{{Potential leak}}
+                          // expected-note@-1{{Object leaked}}
+}
+
 void check_rc_consumed() {
   OSArray *arr = OSArray::withCapacity(10);
   OSArray::consumeArray(arr);
 }
 
 void check_rc_consume_temporary() {
   OSArray::consumeArray(OSArray::withCapacity(10));
 }