[analyzer] [RetainCountChecker] Remove obsolete "MakeCollectable" enum value

[NoQ]

No tests have failed? I find it mildly amusing.

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

enum ArgEffectKind {
   /// The argument has its reference count decreased by 1 to model
   /// a transferred bridge cast under ARC.
   DecRefBridgedTransferred,
 
   /// The argument has its reference count increased by 1.  This is as
   /// if CFRetain has been called on the argument.
   IncRef,
 
-  /// The argument acts as if has been passed to CFMakeCollectable, which
-  /// transfers the object to the Garbage Collector under GC.
-  MakeCollectable,
-
   /// The argument is a pointer to a retain-counted object; on exit, the new
   /// value of the pointer is a +0 value or NULL.
   UnretainedOutParameter,
 
   /// The argument is a pointer to a retain-counted object; on exit, the new
   /// value of the pointer is a +1 value or NULL.
   RetainedOutParameter,
 

clang/lib/StaticAnalyzer/Checkers/RetainCountChecker/RetainCountChecker.cpp

if (AE.getObjKind() == ObjKind::ObjC && IgnoreRetainMsg) {
     case DecRef:
       AE = AE.withKind(DoNothing);
       break;
     case DecRefAndStopTrackingHard:
       AE = AE.withKind(StopTracking);
       break;
     }
   }
-  if (AE.getKind() == MakeCollectable)
-    AE = AE.withKind(DoNothing);
 
   // Handle all use-after-releases.
   if (V.getKind() == RefVal::Released) {
     V = V ^ RefVal::ErrorUseAfterRelease;
     hasErr = V.getKind();
     return setRefBinding(state, sym, V);
   }
 
   switch (AE.getKind()) {
-    case MakeCollectable:
-      llvm_unreachable("MakeCollectable already converted");
-
     case UnretainedOutParameter:
     case RetainedOutParameter:
       llvm_unreachable("Applies to pointer-to-pointer parameters, which should "
                        "not have ref state.");
 
     case Dealloc:
       switch (V.getKind()) {
         default:

clang/lib/StaticAnalyzer/Core/RetainSummaryManager.cpp

 //===----------------------------------------------------------------------===//
 
 static ArgEffect getStopTrackingHardEquivalent(ArgEffect E) {
   switch (E.getKind()) {
   case DoNothing:
   case Autorelease:
   case DecRefBridgedTransferred:
   case IncRef:
-  case MakeCollectable:
   case UnretainedOutParameter:
   case RetainedOutParameter:
   case MayEscape:
   case StopTracking:
   case StopTrackingHard:
     return E.withKind(StopTrackingHard);
   case DecRef:
   case DecRefAndStopTrackingHard:
RetainSummaryManager::getUnarySummary(const FunctionType* FT,
   if (!FTP || FTP->getNumParams() != 1)
     return getPersistentStopSummary();
 
   ArgEffect Effect(DoNothing, ObjKind::CF);
   switch (func) {
   case cfretain: Effect = Effect.withKind(IncRef); break;
   case cfrelease: Effect = Effect.withKind(DecRef); break;
   case cfautorelease: Effect = Effect.withKind(Autorelease); break;
-  case cfmakecollectable: Effect = Effect.withKind(MakeCollectable); break;
+  case cfmakecollectable: Effect = Effect.withKind(DoNothing); break;
   }
 
   ScratchArgs = AF.add(ScratchArgs, 0, Effect);
   return getPersistentSummary(RetEffect::MakeNoRet(),
                               ScratchArgs,
                               ArgEffect(DoNothing), ArgEffect(DoNothing));
 }