[analyzer] RetainCountChecker: remove untested, unused, incorrect option IncludeAllocationLine

[george.karpenkov]

Summary

The option has no tests, is not used anywhere, and is actually incorrect: it prints the line number without the reference to a file, which can be outright incorrect.

[NoQ]

Burn it.

lib/StaticAnalyzer/Checkers/RetainCountChecker/RetainCountChecker.cpp

if (RE.getKind() != RetEffect::NoRet) {
         // Generate an error node.
         state = setRefBinding(state, Sym, X);
 
         static CheckerProgramPointTag ReturnOwnLeakTag(this, "ReturnsOwnLeak");
         ExplodedNode *N = C.addTransition(state, Pred, &ReturnOwnLeakTag);
         if (N) {
           const LangOptions &LOpts = C.getASTContext().getLangOpts();
           auto R = llvm::make_unique<CFRefLeakReport>(
-              *getLeakAtReturnBug(LOpts), LOpts, SummaryLog, N, Sym, C,
-              IncludeAllocationLine);
+              *getLeakAtReturnBug(LOpts), LOpts, SummaryLog, N, Sym, C);
           C.emitReport(std::move(R));
         }
         return N;
       }
     }
   } else if (X.isReturnedNotOwned()) {
     if (RE.isOwned()) {
       if (X.getIvarAccessHistory() ==
for (SmallVectorImpl<SymbolRef>::iterator
          I = Leaked.begin(), E = Leaked.end(); I != E; ++I) {
 
       const LangOptions &LOpts = Ctx.getASTContext().getLangOpts();
       CFRefBug *BT = Pred ? getLeakWithinFunctionBug(LOpts)
                           : getLeakAtReturnBug(LOpts);
       assert(BT && "BugType not initialized.");
 
       Ctx.emitReport(llvm::make_unique<CFRefLeakReport>(
-          *BT, LOpts, SummaryLog, N, *I, Ctx, IncludeAllocationLine));
+          *BT, LOpts, SummaryLog, N, *I, Ctx));
     }
   }
 
   return N;
 }
 
 static bool isISLObjectRef(QualType Ty) {
   return StringRef(Ty.getAsString()).startswith("isl_");

 // Checker registration.
 //===----------------------------------------------------------------------===//
 
 void ento::registerRetainCountChecker(CheckerManager &Mgr) {
   auto *Chk = Mgr.registerChecker<RetainCountChecker>();
 
   AnalyzerOptions &Options = Mgr.getAnalyzerOptions();
 
-  Chk->IncludeAllocationLine = Options.getCheckerBooleanOption(
-                           "leak-diagnostics-reference-allocation", false, Chk);
   Chk->ShouldCheckOSObjectRetainCount = Options.getCheckerBooleanOption(
                                                     "CheckOSObject", true, Chk);
 }

lib/StaticAnalyzer/Checkers/RetainCountChecker/RetainCountDiagnostics.h

class CFRefLeakReport : public CFRefReport {
   const Stmt *AllocStmt;
 
   // Finds the function declaration where a leak warning for the parameter
   // 'sym' should be raised.
   void deriveParamLocation(CheckerContext &Ctx, SymbolRef sym);
   // Finds the location where a leak warning for 'sym' should be raised.
   void deriveAllocLocation(CheckerContext &Ctx, SymbolRef sym);
   // Produces description of a leak warning which is printed on the console.
-  void createDescription(CheckerContext &Ctx, bool IncludeAllocationLine);
+  void createDescription(CheckerContext &Ctx);
 
 public:
   CFRefLeakReport(CFRefBug &D, const LangOptions &LOpts,
                   const SummaryLogTy &Log, ExplodedNode *n, SymbolRef sym,
-                  CheckerContext &Ctx,
-                  bool IncludeAllocationLine);
+                  CheckerContext &Ctx);
 
   PathDiagnosticLocation getLocation(const SourceManager &SM) const override {
     assert(Location.isValid());
     return Location;
   }
 };
 
 } // end namespace retaincountchecker
 } // end namespace ento
 } // end namespace clang
 
 #endif

lib/StaticAnalyzer/Checkers/RetainCountChecker/RetainCountDiagnostics.cpp

void CFRefLeakReport::deriveAllocLocation(CheckerContext &Ctx,
   Location = AllocLocation;
 
   // Set uniqieing info, which will be used for unique the bug reports. The
   // leaks should be uniqued on the allocation site.
   UniqueingLocation = AllocLocation;
   UniqueingDecl = AllocNode->getLocationContext()->getDecl();
 }
 
-void CFRefLeakReport::createDescription(CheckerContext &Ctx,
-                                        bool IncludeAllocationLine) {
+void CFRefLeakReport::createDescription(CheckerContext &Ctx) {
   assert(Location.isValid() && UniqueingDecl && UniqueingLocation.isValid());
   Description.clear();
   llvm::raw_string_ostream os(Description);
   os << "Potential leak of an object";
 
   Optional<std::string> RegionDescription = describeRegion(AllocBinding);
   if (RegionDescription) {
     os << " stored into '" << *RegionDescription << '\'';
-    if (IncludeAllocationLine) {
-      FullSourceLoc SL(AllocStmt->getBeginLoc(), Ctx.getSourceManager());
-      os << " (allocated on line " << SL.getSpellingLineNumber() << ")";
-    }
   } else {
 
     // If we can't figure out the name, just supply the type information.
     os << " of type " << getPrettyTypeName(Sym->getType());
   }
 }
 
 CFRefLeakReport::CFRefLeakReport(CFRefBug &D, const LangOptions &LOpts,
                                  const SummaryLogTy &Log,
                                  ExplodedNode *n, SymbolRef sym,
-                                 CheckerContext &Ctx,
-                                 bool IncludeAllocationLine)
+                                 CheckerContext &Ctx)
   : CFRefReport(D, LOpts, Log, n, sym, false) {
 
   deriveAllocLocation(Ctx, sym);
   if (!AllocBinding)
     deriveParamLocation(Ctx, sym);
 
-  createDescription(Ctx, IncludeAllocationLine);
+  createDescription(Ctx);
 
   addVisitor(llvm::make_unique<CFRefLeakReportVisitor>(sym, Log));
 }