Made MissingOriginCollector internal to Origins.cpp

Author: DEBADRIBASAK

clang/include/clang/Analysis/Analyses/LifetimeSafety/LifetimeSafety.h

@@ -39,8 +39,10 @@ enum class Confidence : uint8_t {
 };
 
 /// A structure to hold the statistics related to LifetimeAnalysis.
-/// Curently it holds only the missing origin details.
+/// Currently it holds only the missing origin details.
 struct LifetimeSafetyStats {
+  /// A map from `ExpressionClassName<QualType>` to their missing origin
+  /// counts.
   llvm::StringMap<unsigned> MissingOriginCount;
 };
 
@@ -106,7 +108,6 @@ class LifetimeSafetyAnalysis {
   std::unique_ptr<LoanPropagationAnalysis> LoanPropagation;
 };
 } // namespace internal
-
 } // namespace clang::lifetimes
 
 #endif // LLVM_CLANG_ANALYSIS_ANALYSES_LIFETIMESAFETY_H

clang/include/clang/Analysis/Analyses/LifetimeSafety/Origins.h

@@ -87,9 +87,7 @@ class OriginManager {
 
   void dump(OriginID OID, llvm::raw_ostream &OS) const;
 
-  const llvm::DenseMap<const clang::Expr *, OriginID> &
-  getExprToOriginId() const;
-
+  /// Collects statistics about expressions that lack associated origins.
   void collectMissingOrigins(Stmt *FunctionBody, LifetimeSafetyStats &LSStats);
 
 private:
@@ -102,22 +100,6 @@ class OriginManager {
   llvm::DenseMap<const clang::ValueDecl *, OriginID> DeclToOriginID;
   llvm::DenseMap<const clang::Expr *, OriginID> ExprToOriginID;
 };
-
-/// An utility class to traverse the function body in the analysis
-/// context and collect the count of expressions with missing origins.
-class MissingOriginCollector
-    : public RecursiveASTVisitor<MissingOriginCollector> {
-public:
-  MissingOriginCollector(const OriginManager &om,
-                         llvm::StringMap<unsigned> &MissingOriginCount)
-      : OM(om), MissingOriginCount(MissingOriginCount) {}
-  bool VisitExpr(Expr *E);
-
-private:
-  const OriginManager &OM;
-  llvm::StringMap<unsigned> &MissingOriginCount;
-};
-
 } // namespace clang::lifetimes::internal
 
 #endif // LLVM_CLANG_ANALYSIS_ANALYSES_LIFETIMESAFETY_ORIGINS_H

clang/lib/Analysis/LifetimeSafety/LifetimeSafety.cpp

@@ -84,22 +84,21 @@ void collectLifetimeStats(AnalysisDeclContext &AC, OriginManager &OM,
 void printStats(const LifetimeSafetyStats &Stats) {
   llvm::errs() << "\n*** LifetimeSafety Missing Origin Stats "
                   "(expression_type : count) :\n\n";
-  unsigned totalMissingOrigins = 0;
+  unsigned TotalMissingOrigins = 0;
   for (const auto &[expr, count] : Stats.MissingOriginCount) {
     llvm::errs() << expr << " : " << count << '\n';
-    totalMissingOrigins += count;
+    TotalMissingOrigins += count;
   }
-  llvm::errs() << "Total missing origins: " << totalMissingOrigins << "\n";
+  llvm::errs() << "Total missing origins: " << TotalMissingOrigins << "\n";
   llvm::errs() << "\n****************************************\n";
 }
 
 void runLifetimeSafetyAnalysis(AnalysisDeclContext &AC,
                                LifetimeSafetyReporter *Reporter,
                                LifetimeSafetyStats &Stats, bool CollectStats) {
-  std::unique_ptr<internal::LifetimeSafetyAnalysis> Analysis =
-      std::make_unique<internal::LifetimeSafetyAnalysis>(AC, Reporter);
-  Analysis->run();
+  internal::LifetimeSafetyAnalysis Analysis(AC, Reporter);
+  Analysis.run();
   if (CollectStats)
-    collectLifetimeStats(AC, Analysis->getFactManager().getOriginMgr(), Stats);
+    collectLifetimeStats(AC, Analysis.getFactManager().getOriginMgr(), Stats);
 }
 } // namespace clang::lifetimes

clang/lib/Analysis/LifetimeSafety/Origins.cpp

@@ -34,6 +34,37 @@ static bool hasOrigin(const Expr *E) {
   return E->isGLValue() || isPointerType(E->getType());
 }
 
+namespace {
+/// An utility class to traverse the function body in the analysis
+/// context and collect the count of expressions with missing origins.
+class MissingOriginCollector
+    : public RecursiveASTVisitor<MissingOriginCollector> {
+public:
+  MissingOriginCollector(
+      const llvm::DenseMap<const clang::Expr *, OriginID> &ExprToOriginId,
+      llvm::StringMap<unsigned> &MissingOriginCount)
+      : ExprToOriginId(ExprToOriginId), MissingOriginCount(MissingOriginCount) {
+  }
+  bool VisitExpr(Expr *E) {
+    if (!hasOrigin(E))
+      return true;
+    // Check if we have an origin for this expression.
+    auto It = this->ExprToOriginId.find(E);
+    if (It == this->ExprToOriginId.end()) {
+      // No origin found: count this as missing origin.
+      std::string ExprStr = std::string(E->getStmtClassName()) +
+                            " (Type: " + E->getType().getAsString() + ")";
+      MissingOriginCount[ExprStr]++;
+    }
+    return true;
+  }
+
+private:
+  const llvm::DenseMap<const clang::Expr *, OriginID> &ExprToOriginId;
+  llvm::StringMap<unsigned> &MissingOriginCount;
+};
+} // namespace
+
 void OriginManager::dump(OriginID OID, llvm::raw_ostream &OS) const {
   OS << OID << " (";
   Origin O = getOrigin(OID);
@@ -63,7 +94,6 @@ OriginID OriginManager::get(const Expr &E) {
   auto It = ExprToOriginID.find(&E);
   if (It != ExprToOriginID.end())
     return It->second;
-
   // If the expression itself has no specific origin, and it's a reference
   // to a declaration, its origin is that of the declaration it refers to.
   // For pointer types, where we don't pre-emptively create an origin for the
@@ -113,33 +143,14 @@ OriginID OriginManager::getOrCreate(const ValueDecl &D) {
   return NewID;
 }
 
-const llvm::DenseMap<const clang::Expr *, OriginID> &
-OriginManager::getExprToOriginId() const {
-  return ExprToOriginID;
-}
-
 void OriginManager::collectMissingOrigins(Stmt *FunctionBody,
                                           LifetimeSafetyStats &LSStats) {
   if (!FunctionBody)
     return;
 
-  MissingOriginCollector Collector(*this, LSStats.MissingOriginCount);
+  MissingOriginCollector Collector(this->ExprToOriginID,
+                                   LSStats.MissingOriginCount);
   Collector.TraverseStmt(const_cast<Stmt *>(FunctionBody));
 }
 
-bool MissingOriginCollector::VisitExpr(Expr *E) {
-  if (!hasOrigin(E))
-    return true;
-  // Check if we have an origin for this expression
-  const auto &ExprToOriginId = OM.getExprToOriginId();
-  auto It = ExprToOriginId.find(E);
-  if (It == ExprToOriginId.end()) {
-    // No origin found - count this as missing
-    std::string ExprStr = std::string(E->getStmtClassName()) + "<" +
-                          E->getType().getAsString() + ">";
-    MissingOriginCount[ExprStr]++;
-  }
-  return true;
-}
-
 } // namespace clang::lifetimes::internal

clang/lib/Sema/AnalysisBasedWarnings.cpp

@@ -29,9 +29,7 @@
 #include "clang/Analysis/Analyses/CFGReachabilityAnalysis.h"
 #include "clang/Analysis/Analyses/CalledOnceCheck.h"
 #include "clang/Analysis/Analyses/Consumed.h"
-#include "clang/Analysis/Analyses/LifetimeSafety/Facts.h"
 #include "clang/Analysis/Analyses/LifetimeSafety/LifetimeSafety.h"
-#include "clang/Analysis/Analyses/LifetimeSafety/Origins.h"
 #include "clang/Analysis/Analyses/ReachableCode.h"
 #include "clang/Analysis/Analyses/ThreadSafety.h"
 #include "clang/Analysis/Analyses/UninitializedValues.h"
@@ -49,7 +47,6 @@
 #include "clang/Sema/SemaInternal.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/BitVector.h"
-#include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/MapVector.h"
 #include "llvm/ADT/STLFunctionalExtras.h"
 #include "llvm/ADT/SmallVector.h"