Introduce intra-procedural lifetime analysis in Clang

[usx95]

This patch introduces the initial implementation of the intra-procedural, flow-sensitive lifetime analysis for Clang, as proposed in the recent RFC: https://discourse.llvm.org/t/rfc-intra-procedural-lifetime-analysis-in-clang/86291

The primary goal of this initial submission is to establish the core dataflow framework and gather feedback on the overall design, fact representation, and testing strategy. The focus is on the dataflow mechanism itself rather than exhaustively covering all C++ AST edge cases, which will be addressed in subsequent patches.

Key Components

• Conceptual Model: Introduces the fundamental concepts of Loan, Origin, and Path to model memory borrows and the lifetime of pointers.
• Fact Generation: A frontend pass traverses the Clang CFG to generate a representation of lifetime-relevant events, such as pointer assignments, taking an address, and variables going out of scope.
• Dataflow Lattice: A dataflow lattice used to map each pointer's symbolic Origin to the set of Loans it may contain at any given program point.
• Fixed-Point Analysis: A worklist-based, flow-sensitive analysis that propagates the lattice state across the CFG to a fixed point.
• Testing: llvm-lit tests validate the analysis by checking the generated facts and final dataflow state.

Next Steps

(Not covered in this PR but planned for subsequent patches)

The following functionality is planned for the upcoming patches to build upon this foundation and make the analysis usable in practice:

• Placeholder Loans: Introduce placeholder loans to represent the lifetimes of function parameters, forming the basis for analysis involving function calls.
• Annotation and Opaque Call Handling: Use placeholder loans to correctly model function calls, both by respecting [[clang::lifetimebound]] annotations and by conservatively handling opaque/un-annotated functions.
• Error Reporting: Implement the final analysis phase that consumes the dataflow results to generate user-facing diagnostics.
• Strict vs. Permissive Modes: Add the logic to support both high-confidence (permissive) and more comprehensive (strict) warning levels.
• Expanded C++ Coverage: Broaden support for common patterns, including the lifetimes of temporary objects and pointers within aggregate types (structs/containers).
• Performance benchmarking
• Capping number of iterations or number of times a CFGBlock is processed.

Performance on pathological test cases:

The pathological case arise when we have N origins initially holding N loans and we have a cyclic assignment of these origins in a loop. The fixed point reaches after N iterations when all the origins contain all the loans.
For N = 4, the test case would like like:

struct MyObj {
  int id;
  ~MyObj() {}
};

void long_cycle(bool condition) {
  MyObj v1{1};
  MyObj v2{1};
  MyObj v3{1};
  MyObj v4{1};

  MyObj* p1 = &v1;
  MyObj* p2 = &v2;
  MyObj* p3 = &v3;
  MyObj* p4 = &v4;

  while (condition) {
    MyObj* temp = p1;
    p1 = p2;
    p2 = p3;
    p3 = p4;
    p4 = temp;
  }
}

[github-actions]

✅ With the latest revision this PR passed the Python code formatter.