[analyzer] [NFC] Clean up the mess of constructing argument effects in RetainCountChecker

[george.karpenkov]

Summary

Previously, argument effects were stored in a method variable, which was effectively global.
The global state was reset at each (hopefully) entrance point to the summary construction,
and every function could modify it.

[NoQ]

I'm very happy to see this global mutable state exterminated.

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

class RetainSummaryManager {
 
   /// BPAlloc - A BumpPtrAllocator used for allocating summaries, ArgEffects,
   ///  and all other data used by the checker.
   llvm::BumpPtrAllocator BPAlloc;
 
   /// AF - A factory for ArgEffects objects.
   ArgEffects::Factory AF;
 
-  /// ScratchArgs - A holding buffer for construct ArgEffects.
-  ArgEffects ScratchArgs;
-
   /// ObjCAllocRetE - Default return effect for methods returning Objective-C
   ///  objects.
   RetEffect ObjCAllocRetE;
 
   /// ObjCInitRetE - Default return effect for init methods returning
   ///   Objective-C objects.
   RetEffect ObjCInitRetE;
 
   /// SimpleSummaries - Used for uniquing summaries that don't have special
   /// effects.
   llvm::FoldingSet<CachedSummaryNode> SimpleSummaries;
 
-  /// getArgEffects - Returns a persistent ArgEffects object based on the
-  ///  data in ScratchArgs.
-  ArgEffects getArgEffects();
-
   /// Create an OS object at +1.
   const RetainSummary *getOSSummaryCreateRule(const FunctionDecl *FD);
 
   /// Get an OS object at +0.
   const RetainSummary *getOSSummaryGetRule(const FunctionDecl *FD);
 
   /// Increment the reference count on OS object.
   const RetainSummary *getOSSummaryRetainRule(const FunctionDecl *FD);
class RetainSummaryManager {
 
   const RetainSummary *getCFSummaryCreateRule(const FunctionDecl *FD);
   const RetainSummary *getCFSummaryGetRule(const FunctionDecl *FD);
   const RetainSummary *getCFCreateGetRuleSummary(const FunctionDecl *FD);
 
   const RetainSummary *getPersistentSummary(const RetainSummary &OldSumm);
 
   const RetainSummary *getPersistentSummary(RetEffect RetEff,
+                                            ArgEffects ScratchArgs,
                                             ArgEffect ReceiverEff = DoNothing,
                                             ArgEffect DefaultEff = MayEscape,
                                             ArgEffect ThisEff = DoNothing) {
-    RetainSummary Summ(getArgEffects(), RetEff, DefaultEff, ReceiverEff,
+    RetainSummary Summ(ScratchArgs, RetEff, DefaultEff, ReceiverEff,
                        ThisEff);
     return getPersistentSummary(Summ);
   }
 
   const RetainSummary *getDoNothingSummary() {
-    return getPersistentSummary(RetEffect::MakeNoRet(), DoNothing, DoNothing);
+    return getPersistentSummary(RetEffect::MakeNoRet(),
+                                ArgEffects(AF.getEmptyMap()),
+                                DoNothing, DoNothing);
   }
 
   const RetainSummary *getDefaultSummary() {
     return getPersistentSummary(RetEffect::MakeNoRet(),
+                                ArgEffects(AF.getEmptyMap()),
                                 DoNothing, MayEscape);
   }
 
   const RetainSummary *getPersistentStopSummary() {
     return getPersistentSummary(RetEffect::MakeNoRet(),
+                                ArgEffects(AF.getEmptyMap()),
                                 StopTracking, StopTracking);
   }
 
   void InitializeClassMethodSummaries();
   void InitializeMethodSummaries();
 
   void addNSObjectClsMethSummary(Selector S, const RetainSummary *Summ) {
     ObjCClassMethodSummaries[S] = Summ;
const RetainSummary *getSummaryForObjCOrCFObject(
     bool &AllowAnnotations);
 
   /// Apply the annotation of {@code pd} in function {@code FD}
   /// to the resulting summary stored in out-parameter {@code Template}.
   /// \return whether an annotation was applied.
   bool applyFunctionParamAnnotationEffect(const ParmVarDecl *pd,
                                         unsigned parm_idx,
                                         const FunctionDecl *FD,
-                                        ArgEffects::Factory &AF,
                                         RetainSummaryTemplate &Template);
 
 public:
   RetainSummaryManager(ASTContext &ctx,
                        bool usesARC,
                        bool trackObjCAndCFObjects,
                        bool trackOSObjects)
    : Ctx(ctx),
      ARCEnabled(usesARC),
      TrackObjCAndCFObjects(trackObjCAndCFObjects),
      TrackOSObjects(trackOSObjects),
-     AF(BPAlloc), ScratchArgs(AF.getEmptyMap()),
+     AF(BPAlloc),
      ObjCAllocRetE(usesARC ? RetEffect::MakeNotOwned(RetEffect::ObjC)
                                : RetEffect::MakeOwned(RetEffect::ObjC)),
      ObjCInitRetE(usesARC ? RetEffect::MakeNotOwned(RetEffect::ObjC)
                                : RetEffect::MakeOwnedWhenTrackedReceiver()) {
     InitializeClassMethodSummaries();
     InitializeMethodSummaries();
   }
 

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

if (isOneOf<T, CFConsumedAttr, CFReturnsRetainedAttr,
     return TrackObjCAndCFObjects;
   } else if (isOneOf<T, OSConsumedAttr, OSConsumesThisAttr,
                      OSReturnsNotRetainedAttr, OSReturnsRetainedAttr>()) {
     return TrackOSObjects;
   }
   llvm_unreachable("Unexpected attribute passed");
 }
 
-ArgEffects RetainSummaryManager::getArgEffects() {
-  ArgEffects AE = ScratchArgs;
-  ScratchArgs = AF.getEmptyMap();
-  return AE;
-}
-
 const RetainSummary *
 RetainSummaryManager::getPersistentSummary(const RetainSummary &OldSumm) {
   // Unique "simple" summaries -- those without ArgEffects.
   if (OldSumm.isSimple()) {
     ::llvm::FoldingSetNodeID ID;
     OldSumm.Profile(ID);
 
     void *Pos;

 
 const RetainSummary *RetainSummaryManager::getSummaryForObjCOrCFObject(
     const FunctionDecl *FD,
     StringRef FName,
     QualType RetTy,
     const FunctionType *FT,
     bool &AllowAnnotations) {
 
-  std::string RetTyName = RetTy.getAsString();
+  ArgEffects ScratchArgs(AF.getEmptyMap());
 
-  // FIXME: This should all be refactored into a chain of "summary lookup"
-  //  filters.
-  assert(ScratchArgs.isEmpty());
+  std::string RetTyName = RetTy.getAsString();
   if (FName == "pthread_create" || FName == "pthread_setspecific") {
     // Part of: <rdar://problem/7299394> and <rdar://problem/11282706>.
     // This will be addressed better with IPA.
     return getPersistentStopSummary();
   } else if(FName == "NSMakeCollectable") {
     // Handle: id NSMakeCollectable(CFTypeRef)
     AllowAnnotations = false;
     return RetTy->isObjCIdType() ? getUnarySummary(FT, cfmakecollectable)
                                  : getPersistentStopSummary();
   } else if (FName == "CMBufferQueueDequeueAndRetain" ||
              FName == "CMBufferQueueDequeueIfDataReadyAndRetain") {
     // Part of: <rdar://problem/39390714>.
-    return getPersistentSummary(RetEffect::MakeOwned(RetEffect::CF), DoNothing,
+    return getPersistentSummary(RetEffect::MakeOwned(RetEffect::CF),
+                                ScratchArgs,
+                                DoNothing,
                                 DoNothing);
   } else if (FName == "CFPlugInInstanceCreate") {
-    return getPersistentSummary(RetEffect::MakeNoRet());
+    return getPersistentSummary(RetEffect::MakeNoRet(), ScratchArgs);
   } else if (FName == "IORegistryEntrySearchCFProperty" ||
              (RetTyName == "CFMutableDictionaryRef" &&
               (FName == "IOBSDNameMatching" || FName == "IOServiceMatching" ||
                FName == "IOServiceNameMatching" ||
                FName == "IORegistryEntryIDMatching" ||
                FName == "IOOpenFirmwarePathMatching"))) {
     // Part of <rdar://problem/6961230>. (IOKit)
     // This should be addressed using a API table.
-    return getPersistentSummary(RetEffect::MakeOwned(RetEffect::CF), DoNothing,
-                             DoNothing);
+    return getPersistentSummary(RetEffect::MakeOwned(RetEffect::CF),
+                                ScratchArgs, DoNothing, DoNothing);
   } else if (FName == "IOServiceGetMatchingService" ||
              FName == "IOServiceGetMatchingServices") {
     // FIXES: <rdar://problem/6326900>
     // This should be addressed using a API table.  This strcmp is also
     // a little gross, but there is no need to super optimize here.
     ScratchArgs = AF.add(ScratchArgs, 1, DecRef);
-    return getPersistentSummary(RetEffect::MakeNoRet(), DoNothing, DoNothing);
+    return getPersistentSummary(RetEffect::MakeNoRet(),
+                                ScratchArgs,
+                                DoNothing, DoNothing);
   } else if (FName == "IOServiceAddNotification" ||
              FName == "IOServiceAddMatchingNotification") {
     // Part of <rdar://problem/6961230>. (IOKit)
     // This should be addressed using a API table.
     ScratchArgs = AF.add(ScratchArgs, 2, DecRef);
-    return getPersistentSummary(RetEffect::MakeNoRet(), DoNothing, DoNothing);
+    return getPersistentSummary(RetEffect::MakeNoRet(),
+                                ScratchArgs,
+                                DoNothing, DoNothing);
   } else if (FName == "CVPixelBufferCreateWithBytes") {
     // FIXES: <rdar://problem/7283567>
     // Eventually this can be improved by recognizing that the pixel
     // buffer passed to CVPixelBufferCreateWithBytes is released via
     // a callback and doing full IPA to make sure this is done correctly.
     // FIXME: This function has an out parameter that returns an
     // allocated object.
     ScratchArgs = AF.add(ScratchArgs, 7, StopTracking);
-    return getPersistentSummary(RetEffect::MakeNoRet(), DoNothing, DoNothing);
+    return getPersistentSummary(RetEffect::MakeNoRet(),
+                                ScratchArgs,
+                                DoNothing, DoNothing);
   } else if (FName == "CGBitmapContextCreateWithData") {
     // FIXES: <rdar://problem/7358899>
     // Eventually this can be improved by recognizing that 'releaseInfo'
     // passed to CGBitmapContextCreateWithData is released via
     // a callback and doing full IPA to make sure this is done correctly.
     ScratchArgs = AF.add(ScratchArgs, 8, StopTracking);
-    return getPersistentSummary(RetEffect::MakeOwned(RetEffect::CF), DoNothing,
-                             DoNothing);
+    return getPersistentSummary(RetEffect::MakeOwned(RetEffect::CF),
+                                ScratchArgs, DoNothing, DoNothing);
   } else if (FName == "CVPixelBufferCreateWithPlanarBytes") {
     // FIXES: <rdar://problem/7283567>
     // Eventually this can be improved by recognizing that the pixel
     // buffer passed to CVPixelBufferCreateWithPlanarBytes is released
     // via a callback and doing full IPA to make sure this is done
     // correctly.
     ScratchArgs = AF.add(ScratchArgs, 12, StopTracking);
-    return getPersistentSummary(RetEffect::MakeNoRet(), DoNothing, DoNothing);
+    return getPersistentSummary(RetEffect::MakeNoRet(),
+                                ScratchArgs,
+                                DoNothing, DoNothing);
   } else if (FName == "VTCompressionSessionEncodeFrame") {
     // The context argument passed to VTCompressionSessionEncodeFrame()
     // is passed to the callback specified when creating the session
     // (e.g. with VTCompressionSessionCreate()) which can release it.
     // To account for this possibility, conservatively stop tracking
     // the context.
     ScratchArgs = AF.add(ScratchArgs, 5, StopTracking);
-    return getPersistentSummary(RetEffect::MakeNoRet(), DoNothing, DoNothing);
+    return getPersistentSummary(RetEffect::MakeNoRet(),
+                                ScratchArgs,
+                                DoNothing, DoNothing);
   } else if (FName == "dispatch_set_context" ||
              FName == "xpc_connection_set_context") {
     // <rdar://problem/11059275> - The analyzer currently doesn't have
     // a good way to reason about the finalizer function for libdispatch.
     // If we pass a context object that is memory managed, stop tracking it.
     // <rdar://problem/13783514> - Same problem, but for XPC.
     // FIXME: this hack should possibly go away once we can handle
     // libdispatch and XPC finalizers.
     ScratchArgs = AF.add(ScratchArgs, 1, StopTracking);
-    return getPersistentSummary(RetEffect::MakeNoRet(), DoNothing, DoNothing);
+    return getPersistentSummary(RetEffect::MakeNoRet(),
+                                ScratchArgs,
+                                DoNothing, DoNothing);
   } else if (FName.startswith("NSLog")) {
     return getDoNothingSummary();
   } else if (FName.startswith("NS") &&
              (FName.find("Insert") != StringRef::npos)) {
     // Whitelist NSXXInsertXX, for example NSMapInsertIfAbsent, since they can
     // be deallocated by NSMapRemove. (radar://11152419)
     ScratchArgs = AF.add(ScratchArgs, 1, StopTracking);
     ScratchArgs = AF.add(ScratchArgs, 2, StopTracking);
-    return getPersistentSummary(RetEffect::MakeNoRet(), DoNothing, DoNothing);
+    return getPersistentSummary(RetEffect::MakeNoRet(),
+                                ScratchArgs, DoNothing, DoNothing);
   }
 
   if (RetTy->isPointerType()) {
 
     // For CoreFoundation ('CF') types.
     if (cocoa::isRefType(RetTy, "CF", FName)) {
       if (isRetain(FD, FName)) {
         // CFRetain isn't supposed to be annotated. However, this may as
else {
       ArgEffect E = (StrInStrNoCase(FName, "InsertValue") != StringRef::npos ||
                      StrInStrNoCase(FName, "AddValue") != StringRef::npos ||
                      StrInStrNoCase(FName, "SetValue") != StringRef::npos ||
                      StrInStrNoCase(FName, "AppendValue") != StringRef::npos ||
                      StrInStrNoCase(FName, "SetAttribute") != StringRef::npos)
                         ? MayEscape
                         : DoNothing;
 
-      return getPersistentSummary(RetEffect::MakeNoRet(), DoNothing, E);
+      return getPersistentSummary(RetEffect::MakeNoRet(), ScratchArgs,
+                                  DoNothing, E);
     }
   }
 
   return nullptr;
 }
 
 const RetainSummary *
 RetainSummaryManager::generateSummary(const FunctionDecl *FD,
RetainSummaryManager::generateSummary(const FunctionDecl *FD,
 
   if (TrackObjCAndCFObjects)
     if (const RetainSummary *S =
             getSummaryForObjCOrCFObject(FD, FName, RetTy, FT, AllowAnnotations))
       return S;
 
   if (const auto *MD = dyn_cast<CXXMethodDecl>(FD))
     if (!(TrackOSObjects && isOSObjectRelated(MD)))
-      return getPersistentSummary(RetEffect::MakeNoRet(), DoNothing, StopTracking,
+      return getPersistentSummary(RetEffect::MakeNoRet(),
+                                  ArgEffects(AF.getEmptyMap()),
+                                  DoNothing, StopTracking,
                                   DoNothing);
 
   return getDefaultSummary();
 }
 
 const RetainSummary *
 RetainSummaryManager::getFunctionSummary(const FunctionDecl *FD) {
   // If we don't know what function we're calling, use our default summary.

 void RetainSummaryManager::updateSummaryForCall(const RetainSummary *&S,
                                                 const CallEvent &Call) {
   if (Call.hasNonZeroCallbackArg()) {
     ArgEffect RecEffect =
       getStopTrackingHardEquivalent(S->getReceiverEffect());
     ArgEffect DefEffect =
       getStopTrackingHardEquivalent(S->getDefaultArgEffect());
 
+    ArgEffects ScratchArgs(AF.getEmptyMap());
     ArgEffects CustomArgEffects = S->getArgEffects();
     for (ArgEffects::iterator I = CustomArgEffects.begin(),
                               E = CustomArgEffects.end();
          I != E; ++I) {
       ArgEffect Translated = getStopTrackingHardEquivalent(I->second);
       if (Translated != DefEffect)
         ScratchArgs = AF.add(ScratchArgs, I->first, Translated);
     }
if (const SimpleFunctionCall *FC = dyn_cast<SimpleFunctionCall>(&Call)) {
         // The callback in dispatch_data_create frees the buffer, but not
         // the data object.
         if (Name->isStr("CGBitmapContextCreateWithData") ||
             Name->isStr("dispatch_data_create"))
           RE = S->getRetEffect();
       }
     }
 
-    S = getPersistentSummary(RE, RecEffect, DefEffect);
+    S = getPersistentSummary(RE, ScratchArgs, RecEffect, DefEffect);
   }
 
   // Special case '[super init];' and '[self init];'
   //
   // Even though calling '[super init]' without assigning the result to self
   // and checking if the parent returns 'nil' is a bad pattern, it is common.
   // Additionally, our Self Init checker already warns about it. To avoid
   // overwhelming the user with messages from both checkers, we model the case
RetainSummaryManager::canEval(const CallExpr *CE, const FunctionDecl *FD,
 
   return None;
 }
 
 const RetainSummary *
 RetainSummaryManager::getUnarySummary(const FunctionType* FT,
                                       UnaryFuncKind func) {
 
+  // Unary functions have no arg effects by definition.
+  ArgEffects ScratchArgs(AF.getEmptyMap());
+
   // Sanity check that this is *really* a unary function.  This can
   // happen if people do weird things.
   const FunctionProtoType* FTP = dyn_cast<FunctionProtoType>(FT);
   if (!FTP || FTP->getNumParams() != 1)
     return getPersistentStopSummary();
 
-  assert (ScratchArgs.isEmpty());
-
   ArgEffect Effect;
   switch (func) {
   case cfretain: Effect = IncRef; break;
   case cfrelease: Effect = DecRef; break;
   case cfautorelease: Effect = Autorelease; break;
   case cfmakecollectable: Effect = MakeCollectable; break;
   }
 
   ScratchArgs = AF.add(ScratchArgs, 0, Effect);
-  return getPersistentSummary(RetEffect::MakeNoRet(), DoNothing, DoNothing);
+  return getPersistentSummary(RetEffect::MakeNoRet(),
+                              ScratchArgs,
+                              DoNothing, DoNothing);
 }
 
 const RetainSummary *
 RetainSummaryManager::getOSSummaryRetainRule(const FunctionDecl *FD) {
   return getPersistentSummary(RetEffect::MakeNoRet(),
+                              AF.getEmptyMap(),
                               /*ReceiverEff=*/DoNothing,
                               /*DefaultEff=*/DoNothing,
                               /*ThisEff=*/IncRef);
 }
 
 const RetainSummary *
 RetainSummaryManager::getOSSummaryReleaseRule(const FunctionDecl *FD) {
   return getPersistentSummary(RetEffect::MakeNoRet(),
+                              AF.getEmptyMap(),
                               /*ReceiverEff=*/DoNothing,
                               /*DefaultEff=*/DoNothing,
                               /*ThisEff=*/DecRef);
 }
 
 const RetainSummary *
 RetainSummaryManager::getOSSummaryFreeRule(const FunctionDecl *FD) {
   return getPersistentSummary(RetEffect::MakeNoRet(),
+                              AF.getEmptyMap(),
                               /*ReceiverEff=*/DoNothing,
                               /*DefaultEff=*/DoNothing,
                               /*ThisEff=*/Dealloc);
 }
 
 const RetainSummary *
 RetainSummaryManager::getOSSummaryCreateRule(const FunctionDecl *FD) {
-  return getPersistentSummary(RetEffect::MakeOwned(RetEffect::OS));
+  return getPersistentSummary(RetEffect::MakeOwned(RetEffect::OS),
+                              AF.getEmptyMap());
 }
 
 const RetainSummary *
 RetainSummaryManager::getOSSummaryGetRule(const FunctionDecl *FD) {
-  return getPersistentSummary(RetEffect::MakeNotOwned(RetEffect::OS));
+  return getPersistentSummary(RetEffect::MakeNotOwned(RetEffect::OS),
+                              AF.getEmptyMap());
 }
 
 const RetainSummary *
 RetainSummaryManager::getCFSummaryCreateRule(const FunctionDecl *FD) {
-  assert (ScratchArgs.isEmpty());
-
-  return getPersistentSummary(RetEffect::MakeOwned(RetEffect::CF));
+  return getPersistentSummary(RetEffect::MakeOwned(RetEffect::CF),
+                              ArgEffects(AF.getEmptyMap()));
 }
 
 const RetainSummary *
 RetainSummaryManager::getCFSummaryGetRule(const FunctionDecl *FD) {
-  assert (ScratchArgs.isEmpty());
   return getPersistentSummary(RetEffect::MakeNotOwned(RetEffect::CF),
+                              ArgEffects(AF.getEmptyMap()),
                               DoNothing, DoNothing);
 }
 
 
 
 
 //===----------------------------------------------------------------------===//
 // Summary creation for Selectors.
RetainSummaryManager::getRetEffectFromAnnotations(QualType RetTy,
   if (const auto *MD = dyn_cast<CXXMethodDecl>(D))
     for (const auto *PD : MD->overridden_methods())
       if (auto RE = getRetEffectFromAnnotations(RetTy, PD))
         return RE;
 
   return None;
 }
 
-bool RetainSummaryManager::applyFunctionParamAnnotationEffect(const ParmVarDecl *pd,
-                                        unsigned parm_idx,
-                                        const FunctionDecl *FD,
-                                        ArgEffects::Factory &AF,
-                                        RetainSummaryTemplate &Template) {
+bool RetainSummaryManager::applyFunctionParamAnnotationEffect(
+    const ParmVarDecl *pd, unsigned parm_idx, const FunctionDecl *FD,
   if (hasEnabledAttr<NSConsumedAttr>(pd)) {
     Template->addArg(AF, parm_idx, DecRefMsg);
     return true;
   } else if (hasEnabledAttr<CFConsumedAttr>(pd) ||
              hasEnabledAttr<OSConsumedAttr>(pd) ||
              hasRCAnnotation(pd, "rc_ownership_consumed")) {
     Template->addArg(AF, parm_idx, DecRef);
     return true;
if (!PointeeTy.isNull()) {
         Template->addArg(AF, parm_idx, UnretainedOutParameter);
         return true;
       }
     }
   } else {
     if (const auto *MD = dyn_cast<CXXMethodDecl>(FD)) {
       for (const auto *OD : MD->overridden_methods()) {
         const ParmVarDecl *OP = OD->parameters()[parm_idx];
-        if (applyFunctionParamAnnotationEffect(OP, parm_idx, OD, AF, Template))
+        if (applyFunctionParamAnnotationEffect(OP, parm_idx, OD, Template))
           return true;
       }
     }
   }
 
   return false;
 }
 
 void
 RetainSummaryManager::updateSummaryFromAnnotations(const RetainSummary *&Summ,
                                                    const FunctionDecl *FD) {
   if (!FD)
     return;
 
   assert(Summ && "Must have a summary to add annotations to.");
   RetainSummaryTemplate Template(Summ, *this);
 
   // Effects on the parameters.
   unsigned parm_idx = 0;
   for (auto pi = FD->param_begin(),
          pe = FD->param_end(); pi != pe; ++pi, ++parm_idx) {
     const ParmVarDecl *pd = *pi;
-    applyFunctionParamAnnotationEffect(pd, parm_idx, FD, AF, Template);
+    applyFunctionParamAnnotationEffect(pd, parm_idx, FD, Template);
   }
 
   QualType RetTy = FD->getReturnType();
   if (Optional<RetEffect> RetE = getRetEffectFromAnnotations(RetTy, FD))
     Template->setRetEffect(*RetE);
 
   if (hasEnabledAttr<OSConsumesThisAttr>(FD))
     Template->setThisEffect(DecRef);
for (unsigned i = 0, e = S.getNumArgs(); i != e; ++i) {
         if (ResultEff == ObjCInitRetE)
           ResultEff = RetEffect::MakeNoRetHard();
         else
           ReceiverEff = StopTrackingHard;
       }
     }
   }
 
-  if (ScratchArgs.isEmpty() && ReceiverEff == DoNothing &&
+  if (ReceiverEff == DoNothing &&
       ResultEff.getKind() == RetEffect::NoRet)
     return getDefaultSummary();
 
-  return getPersistentSummary(ResultEff, ReceiverEff, MayEscape);
+  return getPersistentSummary(ResultEff, ArgEffects(AF.getEmptyMap()),
+                              ReceiverEff, MayEscape);
 }
 
 const RetainSummary *RetainSummaryManager::getInstanceMethodSummary(
-    const ObjCMethodCall &Msg, QualType ReceiverType) {
+    const ObjCMethodCall &Msg,
+    QualType ReceiverType) {
   const ObjCInterfaceDecl *ReceiverClass = nullptr;
 
   // We do better tracking of the type of the object than the core ExprEngine.
   // See if we have its type in our private state.
   if (!ReceiverType.isNull())
     if (const auto *PT = ReceiverType->getAs<ObjCObjectPointerType>())
       ReceiverClass = PT->getInterfaceDecl();
 
const RetainSummary *RetainSummaryManager::getInstanceMethodSummary(
   if (!Method && ReceiverClass)
     Method = ReceiverClass->getInstanceMethod(S);
 
   return getMethodSummary(S, ReceiverClass, Method, Msg.getResultType(),
                           ObjCMethodSummaries);
 }
 
 const RetainSummary *
-RetainSummaryManager::getMethodSummary(Selector S, const ObjCInterfaceDecl *ID,
+RetainSummaryManager::getMethodSummary(Selector S,
+                                       const ObjCInterfaceDecl *ID,
                                        const ObjCMethodDecl *MD, QualType RetTy,
                                        ObjCMethodSummariesTy &CachedSummaries) {
 
   // Objective-C method summaries are only applicable to ObjC and CF objects.
   if (!TrackObjCAndCFObjects)
     return getDefaultSummary();
 
   // Look up a summary in our summary cache.
   const RetainSummary *Summ = CachedSummaries.find(ID, S);
 
   if (!Summ) {
     Summ = getStandardMethodSummary(MD, S, RetTy);
 
     // Annotations override defaults.
     updateSummaryFromAnnotations(Summ, MD);
 
     // Memoize the summary.
     CachedSummaries[ObjCSummaryKey(ID, S)] = Summ;
   }
 
   return Summ;
 }
 
 void RetainSummaryManager::InitializeClassMethodSummaries() {
-  assert(ScratchArgs.isEmpty());
+  ArgEffects ScratchArgs = AF.getEmptyMap();
+
   // Create the [NSAssertionHandler currentHander] summary.
   addClassMethSummary("NSAssertionHandler", "currentHandler",
-                getPersistentSummary(RetEffect::MakeNotOwned(RetEffect::ObjC)));
+                getPersistentSummary(RetEffect::MakeNotOwned(RetEffect::ObjC),
+                                     ScratchArgs));
 
   // Create the [NSAutoreleasePool addObject:] summary.
   ScratchArgs = AF.add(ScratchArgs, 0, Autorelease);
   addClassMethSummary("NSAutoreleasePool", "addObject",
                       getPersistentSummary(RetEffect::MakeNoRet(),
+                                           ScratchArgs,
                                            DoNothing, Autorelease));
 }
 
 void RetainSummaryManager::InitializeMethodSummaries() {
 
-  assert (ScratchArgs.isEmpty());
-
+  ArgEffects ScratchArgs = AF.getEmptyMap();
   // Create the "init" selector.  It just acts as a pass-through for the
   // receiver.
-  const RetainSummary *InitSumm = getPersistentSummary(ObjCInitRetE, DecRefMsg);
+  const RetainSummary *InitSumm = getPersistentSummary(ObjCInitRetE,
+                                                       ScratchArgs,
+                                                       DecRefMsg);
   addNSObjectMethSummary(GetNullarySelector("init", Ctx), InitSumm);
 
   // awakeAfterUsingCoder: behaves basically like an 'init' method.  It
   // claims the receiver and returns a retained object.
   addNSObjectMethSummary(GetUnarySelector("awakeAfterUsingCoder", Ctx),
                          InitSumm);
 
   // The next methods are allocators.
-  const RetainSummary *AllocSumm = getPersistentSummary(ObjCAllocRetE);
+  const RetainSummary *AllocSumm = getPersistentSummary(ObjCAllocRetE,
+                                                        ScratchArgs);
   const RetainSummary *CFAllocSumm =
-    getPersistentSummary(RetEffect::MakeOwned(RetEffect::CF));
+    getPersistentSummary(RetEffect::MakeOwned(RetEffect::CF), ScratchArgs);
 
   // Create the "retain" selector.
   RetEffect NoRet = RetEffect::MakeNoRet();
-  const RetainSummary *Summ = getPersistentSummary(NoRet, IncRefMsg);
+  const RetainSummary *Summ = getPersistentSummary(NoRet, ScratchArgs, IncRefMsg);
   addNSObjectMethSummary(GetNullarySelector("retain", Ctx), Summ);
 
   // Create the "release" selector.
-  Summ = getPersistentSummary(NoRet, DecRefMsg);
+  Summ = getPersistentSummary(NoRet, ScratchArgs, DecRefMsg);
   addNSObjectMethSummary(GetNullarySelector("release", Ctx), Summ);
 
   // Create the -dealloc summary.
-  Summ = getPersistentSummary(NoRet, Dealloc);
+  Summ = getPersistentSummary(NoRet, ScratchArgs, Dealloc);
   addNSObjectMethSummary(GetNullarySelector("dealloc", Ctx), Summ);
 
   // Create the "autorelease" selector.
-  Summ = getPersistentSummary(NoRet, Autorelease);
+  Summ = getPersistentSummary(NoRet, ScratchArgs, Autorelease);
   addNSObjectMethSummary(GetNullarySelector("autorelease", Ctx), Summ);
 
   // For NSWindow, allocated objects are (initially) self-owned.
   // FIXME: For now we opt for false negatives with NSWindow, as these objects
   //  self-own themselves.  However, they only do this once they are displayed.
   //  Thus, we need to track an NSWindow's display status.
   //  This is tracked in <rdar://problem/6062711>.
   //  See also http://llvm.org/bugs/show_bug.cgi?id=3714.
-  const RetainSummary *NoTrackYet = getPersistentSummary(RetEffect::MakeNoRet(),
-                                                   StopTracking,
-                                                   StopTracking);
+  const RetainSummary *NoTrackYet = getPersistentSummary(
+      RetEffect::MakeNoRet(), ScratchArgs, StopTracking, StopTracking);
 
   addClassMethSummary("NSWindow", "alloc", NoTrackYet);
 
   // For NSPanel (which subclasses NSWindow), allocated objects are not
   //  self-owned.
   // FIXME: For now we don't track NSPanels. object for the same reason
   //   as for NSWindow objects.
   addClassMethSummary("NSPanel", "alloc", NoTrackYet);