more useful names and anonymous namespaces

Author: usx95

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

@@ -24,7 +24,8 @@ namespace clang::lifetimes::internal {
 /// Runs the lifetime checker, which detects use-after-free errors by
 /// examining loan expiration points and checking if any live origins hold
 /// the expired loan.
-void runLifetimeChecker(const LoanPropagation &LP, const LiveOrigins &LO,
+void runLifetimeChecker(const LoanPropagationAnalysis &LoanPropagation,
+                        const LiveOriginsAnalysis &LiveOrigins,
                         const FactManager &FactMgr, AnalysisDeclContext &ADC,
                         LifetimeSafetyReporter *Reporter);
 

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

@@ -204,6 +204,17 @@ class FactManager {
 
   void dump(const CFG &Cfg, AnalysisDeclContext &AC) const;
 
+  /// Retrieves program points that were specially marked in the source code
+  /// for testing.
+  ///
+  /// The analysis recognizes special function calls of the form
+  /// `void("__lifetime_test_point_<name>")` as test points. This method returns
+  /// a map from the annotation string (<name>) to the corresponding
+  /// `ProgramPoint`. This allows test harnesses to query the analysis state at
+  /// user-defined locations in the code.
+  /// \note This is intended for testing only.
+  llvm::StringMap<ProgramPoint> getTestPoints() const;
+
   LoanManager &getLoanMgr() { return LoanMgr; }
   const LoanManager &getLoanMgr() const { return LoanMgr; }
   OriginManager &getOriginMgr() { return OriginMgr; }

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

@@ -22,8 +22,6 @@
 #include "clang/Analysis/Analyses/LifetimeSafety/LiveOrigins.h"
 #include "clang/Analysis/Analyses/LifetimeSafety/LoanPropagation.h"
 #include "clang/Analysis/AnalysisDeclContext.h"
-#include "clang/Analysis/CFG.h"
-#include "llvm/ADT/StringMap.h"
 
 namespace clang::lifetimes {
 
@@ -52,7 +50,6 @@ namespace internal {
 /// An object to hold the factories for immutable collections, ensuring
 /// that all created states share the same underlying memory management.
 struct LifetimeFactory {
-  // llvm::BumpPtrAllocator Allocator;
   OriginLoanMap::Factory OriginMapFactory{/*canonicalize=*/false};
   LoanSet::Factory LoanSetFactory{/*canonicalize=*/false};
   LivenessMap::Factory LivenessMapFactory{/*canonicalize=*/false};
@@ -67,57 +64,20 @@ class LifetimeSafetyAnalysis {
 
   void run();
 
-  /// Returns the loan propagation analysis object.
-  /// \note This is intended for testing only.
-  LoanPropagation &getLoanPropagation() const {
-    assert(LP && "Analysis has not been run.");
-    return *LP;
+  /// \note These are provided only for testing purposes.
+  LoanPropagationAnalysis &getLoanPropagation() const {
+    return *LoanPropagation;
   }
-
-  /// Returns the live origin analysis object.
-  /// \note This is intended for testing only.
-  LiveOrigins &getLiveOriginAnalysis() const {
-    assert(LO && "Analysis has not been run.");
-    return *LO;
-  }
-
-  /// Returns the set of origins that are live at a specific program point,
-  /// along with the confidence level of their liveness.
-  ///
-  /// An origin is considered live if there are potential future uses of that
-  /// origin after the given program point. The confidence level indicates
-  /// whether the origin is definitely live (Definite) due to being domintated
-  /// by a set of uses or only possibly live (Maybe) only on some but not all
-  /// control flow paths.
-  std::vector<std::pair<OriginID, LivenessKind>>
-  getLiveOriginsAtPoint(ProgramPoint PP) const;
-
-  /// Finds the OriginID for a given declaration.
-  /// Returns a null optional if not found.
-  std::optional<OriginID> getOriginIDForDecl(const ValueDecl *D) const;
-
-  /// Finds the LoanID's for the loan created with the specific variable as
-  /// their Path.
-  std::vector<LoanID> getLoanIDForVar(const VarDecl *VD) const;
-
-  /// Retrieves program points that were specially marked in the source code
-  /// for testing.
-  ///
-  /// The analysis recognizes special function calls of the form
-  /// `void("__lifetime_test_point_<name>")` as test points. This method returns
-  /// a map from the annotation string (<name>) to the corresponding
-  /// `ProgramPoint`. This allows test harnesses to query the analysis state at
-  /// user-defined locations in the code.
-  /// \note This is intended for testing only.
-  llvm::StringMap<ProgramPoint> getTestPoints() const;
+  LiveOriginsAnalysis &getLiveOrigins() const { return *LiveOrigins; }
+  FactManager &getFactManager() { return FactMgr; }
 
 private:
   AnalysisDeclContext &AC;
   LifetimeSafetyReporter *Reporter;
   LifetimeFactory Factory;
   FactManager FactMgr;
-  std::unique_ptr<LiveOrigins> LO;
-  std::unique_ptr<LoanPropagation> LP;
+  std::unique_ptr<LiveOriginsAnalysis> LiveOrigins;
+  std::unique_ptr<LoanPropagationAnalysis> LoanPropagation;
 };
 } // namespace internal
 } // namespace clang::lifetimes

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

@@ -72,13 +72,16 @@ struct LivenessInfo {
 
 using LivenessMap = llvm::ImmutableMap<OriginID, LivenessInfo>;
 
-class LiveOrigins {
+class LiveOriginsAnalysis {
 public:
-  LiveOrigins(const CFG &C, AnalysisDeclContext &AC, FactManager &F,
-              LivenessMap::Factory &SF);
-  ~LiveOrigins();
+  LiveOriginsAnalysis(const CFG &C, AnalysisDeclContext &AC, FactManager &F,
+                      LivenessMap::Factory &SF);
+  ~LiveOriginsAnalysis();
+
+  /// Returns the set of origins that are live at a specific program point,
+  /// along with the confidence level of their liveness.
+  LivenessMap getLiveOriginsAt(ProgramPoint P) const;
 
-  LivenessMap getLiveOrigins(ProgramPoint P) const;
   // Dump liveness values on all test points in the program.
   void dump(llvm::raw_ostream &OS,
             llvm::StringMap<ProgramPoint> TestPoints) const;

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

@@ -29,19 +29,17 @@ namespace clang::lifetimes::internal {
 using LoanSet = llvm::ImmutableSet<LoanID>;
 using OriginLoanMap = llvm::ImmutableMap<OriginID, LoanSet>;
 
-class LoanPropagation {
+class LoanPropagationAnalysis {
 public:
-  LoanPropagation(const CFG &C, AnalysisDeclContext &AC, FactManager &F,
-                  OriginLoanMap::Factory &OriginLoanMapFactory,
-                  LoanSet::Factory &LoanSetFactory);
-  ~LoanPropagation();
+  LoanPropagationAnalysis(const CFG &C, AnalysisDeclContext &AC, FactManager &F,
+                          OriginLoanMap::Factory &OriginLoanMapFactory,
+                          LoanSet::Factory &LoanSetFactory);
+  ~LoanPropagationAnalysis();
 
   LoanSet getLoans(OriginID OID, ProgramPoint P) const;
 
 private:
   class Impl;
-
-public:
   std::unique_ptr<Impl> PImpl;
 };
 

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

@@ -58,70 +58,21 @@ class OriginManager {
 public:
   OriginManager() = default;
 
-  Origin &addOrigin(OriginID ID, const clang::ValueDecl &D) {
-    AllOrigins.emplace_back(ID, &D);
-    return AllOrigins.back();
-  }
-  Origin &addOrigin(OriginID ID, const clang::Expr &E) {
-    AllOrigins.emplace_back(ID, &E);
-    return AllOrigins.back();
-  }
+  Origin &addOrigin(OriginID ID, const clang::ValueDecl &D);
+  Origin &addOrigin(OriginID ID, const clang::Expr &E);
 
   // TODO: Mark this method as const once we remove the call to getOrCreate.
-  OriginID 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
-    // DeclRefExpr itself.
-    if (const auto *DRE = dyn_cast<DeclRefExpr>(&E))
-      return get(*DRE->getDecl());
-    // TODO: This should be an assert(It != ExprToOriginID.end()). The current
-    // implementation falls back to getOrCreate to avoid crashing on
-    // yet-unhandled pointer expressions, creating an empty origin for them.
-    return getOrCreate(E);
-  }
+  OriginID get(const Expr &E);
 
-  OriginID get(const ValueDecl &D) {
-    auto It = DeclToOriginID.find(&D);
-    // TODO: This should be an assert(It != DeclToOriginID.end()). The current
-    // implementation falls back to getOrCreate to avoid crashing on
-    // yet-unhandled pointer expressions, creating an empty origin for them.
-    if (It == DeclToOriginID.end())
-      return getOrCreate(D);
+  OriginID get(const ValueDecl &D);
 
-    return It->second;
-  }
+  OriginID getOrCreate(const Expr &E);
 
-  OriginID getOrCreate(const Expr &E) {
-    auto It = ExprToOriginID.find(&E);
-    if (It != ExprToOriginID.end())
-      return It->second;
-
-    OriginID NewID = getNextOriginID();
-    addOrigin(NewID, E);
-    ExprToOriginID[&E] = NewID;
-    return NewID;
-  }
-
-  const Origin &getOrigin(OriginID ID) const {
-    assert(ID.Value < AllOrigins.size());
-    return AllOrigins[ID.Value];
-  }
+  const Origin &getOrigin(OriginID ID) const;
 
   llvm::ArrayRef<Origin> getOrigins() const { return AllOrigins; }
 
-  OriginID getOrCreate(const ValueDecl &D) {
-    auto It = DeclToOriginID.find(&D);
-    if (It != DeclToOriginID.end())
-      return It->second;
-    OriginID NewID = getNextOriginID();
-    addOrigin(NewID, D);
-    DeclToOriginID[&D] = NewID;
-    return NewID;
-  }
+  OriginID getOrCreate(const ValueDecl &D);
 
   void dump(OriginID OID, llvm::raw_ostream &OS) const;
 

clang/lib/Analysis/LifetimeSafety/Checker.cpp

@@ -26,13 +26,6 @@
 
 namespace clang::lifetimes::internal {
 
-/// Struct to store the complete context for a potential lifetime violation.
-struct PendingWarning {
-  SourceLocation ExpiryLoc; // Where the loan expired.
-  const Expr *UseExpr;      // Where the origin holding this loan was used.
-  Confidence ConfidenceLevel;
-};
-
 static Confidence livenessKindToConfidence(LivenessKind K) {
   switch (K) {
   case LivenessKind::Must:
@@ -45,22 +38,29 @@ static Confidence livenessKindToConfidence(LivenessKind K) {
   llvm_unreachable("unknown liveness kind");
 }
 
+namespace {
+
+/// Struct to store the complete context for a potential lifetime violation.
+struct PendingWarning {
+  SourceLocation ExpiryLoc; // Where the loan expired.
+  const Expr *UseExpr;      // Where the origin holding this loan was used.
+  Confidence ConfidenceLevel;
+};
+
 class LifetimeChecker {
 private:
   llvm::DenseMap<LoanID, PendingWarning> FinalWarningsMap;
-  const LoanPropagation &LP;
-  const LiveOrigins &LO;
+  const LoanPropagationAnalysis &LoanPropagation;
+  const LiveOriginsAnalysis &LiveOrigins;
   const FactManager &FactMgr;
-  AnalysisDeclContext &ADC;
   LifetimeSafetyReporter *Reporter;
 
 public:
-  LifetimeChecker(const LoanPropagation &LP, const LiveOrigins &LO,
-                  const FactManager &FM, AnalysisDeclContext &ADC,
-                  LifetimeSafetyReporter *Reporter)
-      : LP(LP), LO(LO), FactMgr(FM), ADC(ADC), Reporter(Reporter) {}
-
-  void run() {
+  LifetimeChecker(const LoanPropagationAnalysis &LoanPropagation,
+                  const LiveOriginsAnalysis &LiveOrigins, const FactManager &FM,
+                  AnalysisDeclContext &ADC, LifetimeSafetyReporter *Reporter)
+      : LoanPropagation(LoanPropagation), LiveOrigins(LiveOrigins), FactMgr(FM),
+        Reporter(Reporter) {
     for (const CFGBlock *B : *ADC.getAnalysis<PostOrderCFGView>())
       for (const Fact *F : FactMgr.getFacts(B))
         if (const auto *EF = F->getAs<ExpireFact>())
@@ -81,11 +81,11 @@ class LifetimeChecker {
   /// propagation (e.g., a loan may only be held on some execution paths).
   void checkExpiry(const ExpireFact *EF) {
     LoanID ExpiredLoan = EF->getLoanID();
-    LivenessMap Origins = LO.getLiveOrigins(EF);
+    LivenessMap Origins = LiveOrigins.getLiveOriginsAt(EF);
     Confidence CurConfidence = Confidence::None;
     const UseFact *BadUse = nullptr;
     for (auto &[OID, LiveInfo] : Origins) {
-      LoanSet HeldLoans = LP.getLoans(OID, EF);
+      LoanSet HeldLoans = LoanPropagation.getLoans(OID, EF);
       if (!HeldLoans.contains(ExpiredLoan))
         continue;
       // Loan is defaulted.
@@ -117,13 +117,14 @@ class LifetimeChecker {
     }
   }
 };
+} // namespace
 
-void runLifetimeChecker(const LoanPropagation &LP, const LiveOrigins &LO,
+void runLifetimeChecker(const LoanPropagationAnalysis &LP,
+                        const LiveOriginsAnalysis &LO,
                         const FactManager &FactMgr, AnalysisDeclContext &ADC,
                         LifetimeSafetyReporter *Reporter) {
   llvm::TimeTraceScope TimeProfile("LifetimeChecker");
   LifetimeChecker Checker(LP, LO, FactMgr, ADC, Reporter);
-  Checker.run();
 }
 
 } // namespace clang::lifetimes::internal

clang/lib/Analysis/LifetimeSafety/Dataflow.h

@@ -75,11 +75,11 @@ class DataflowAnalysis {
   static constexpr bool isForward() { return Dir == Direction::Forward; }
 
 protected:
-  FactManager &AllFacts;
+  FactManager &FactMgr;
 
-  explicit DataflowAnalysis(const CFG &C, AnalysisDeclContext &AC,
-                            FactManager &F)
-      : Cfg(C), AC(AC), AllFacts(F) {}
+  explicit DataflowAnalysis(const CFG &Cfg, AnalysisDeclContext &AC,
+                            FactManager &FactMgr)
+      : Cfg(Cfg), AC(AC), FactMgr(FactMgr) {}
 
 public:
   void run() {
@@ -140,7 +140,7 @@ class DataflowAnalysis {
   /// Computes the state at one end of a block by applying all its facts
   /// sequentially to a given state from the other end.
   Lattice transferBlock(const CFGBlock *Block, Lattice State) {
-    auto Facts = AllFacts.getFacts(Block);
+    auto Facts = FactMgr.getFacts(Block);
     if constexpr (isForward()) {
       for (const Fact *F : Facts) {
         State = transferFact(State, F);

clang/lib/Analysis/LifetimeSafety/Facts.cpp

@@ -62,6 +62,22 @@ void TestPointFact::dump(llvm::raw_ostream &OS, const LoanManager &,
   OS << "TestPoint (Annotation: \"" << getAnnotation() << "\")\n";
 }
 
+llvm::StringMap<ProgramPoint> FactManager::getTestPoints() const {
+  llvm::StringMap<ProgramPoint> AnnotationToPointMap;
+  for (const CFGBlock *Block : BlockToFactsMap.keys()) {
+    for (const Fact *F : getFacts(Block)) {
+      if (const auto *TPF = F->getAs<TestPointFact>()) {
+        StringRef PointName = TPF->getAnnotation();
+        assert(AnnotationToPointMap.find(PointName) ==
+                   AnnotationToPointMap.end() &&
+               "more than one test points with the same name");
+        AnnotationToPointMap[PointName] = F;
+      }
+    }
+  }
+  return AnnotationToPointMap;
+}
+
 void FactManager::dump(const CFG &Cfg, AnalysisDeclContext &AC) const {
   llvm::dbgs() << "==========================================\n";
   llvm::dbgs() << "       Lifetime Analysis Facts:\n";