[LifetimeSafety] Cross-TU Vs Intra-TU Annotation Suggestions (#171972)

Differentiate between cross-TU and intra-TU annotation suggestions.

This PR refines the lifetime annotation suggestion feature by
introducing a distinction between cross-TU and intra-TU annotation
suggestions. The primary purpose of this change is to differentiate
between suggestions which can be replaced by inference and other
cross-tu suggestions where inference is not sufficient to replace the
need of explicit annotations.

We have introduced two new warning groups under Lifetime Safety
Suggestions:

- `-Wexperimental-lifetime-safety-cross-tu-suggestions`: These are for
functions whose declarations are in header, definition in source file.
These are higher priority as it affects callers in other translation
units. Inference cannot replace these annotations across TU boundaries
(even in its most powerful form). Annotation suggestion is on the header
declaration.

- `-Wexperimental-lifetime-safety-intra-tu-suggestions`: For suggestions
on functions which are in the same TU. These can be considered
lower-priority suggestions as inference can potentially handle these
within the same TU.

Example:

```cpp
// Header file r.h
#include <iostream>
#include <string>

std::string_view public_func(std::string_view a);

inline std::string_view inline_header(std::string_view a) {
    return a;
}

```

```cpp
// Source (cpp file)
#include <iostream>
#include <string>
#include "r.h"

std::string_view public_func(std::string_view a) {
  return a;
}

namespace {
std::string_view private_func(std::string_view a) {
  return a;
}
}
```

The warnings generated are:

```
./r.h:6:39: warning: parameter in intra-TU function should be marked [[clang::lifetimebound]] [-Wexperimental-lifetime-safety-intra-tu-suggestions]
    6 | inline std::string_view inline_header(std::string_view a) {
      |                                       ^~~~~~~~~~~~~~~~~~
      |                                                          [[clang::lifetimebound]]
./r.h:7:12: note: param returned here
    7 |     return a;
./r.h:4:30: warning: parameter in cross-TU function should be marked [[clang::lifetimebound]] [-Wexperimental-lifetime-safety-cross-tu-suggestions]
    4 | std::string_view public_func(std::string_view a);
      |                              ^~~~~~~~~~~~~~~~~~
      |                                                 [[clang::lifetimebound]]
r.cpp:6:10: note: param returned here
    6 |   return a;
      |          ^
r.cpp:10:33: warning: parameter in intra-TU function should be marked [[clang::lifetimebound]] [-Wexperimental-lifetime-safety-intra-tu-suggestions]
   10 |   std::string_view private_func(std::string_view a) {
      |                                 ^~~~~~~~~~~~~~~~~~
      |                                                    [[clang::lifetimebound]]
r.cpp:11:10: note: param returned here
   11 |   return a;
      |          ^
```
6 files changed
tree: 33c4d4201770d514f08c3cd1f8c85924adb4dbaa
  1. .ci/
  2. .github/
  3. bolt/
  4. clang/
  5. clang-tools-extra/
  6. cmake/
  7. compiler-rt/
  8. cross-project-tests/
  9. flang/
  10. flang-rt/
  11. libc/
  12. libclc/
  13. libcxx/
  14. libcxxabi/
  15. libsycl/
  16. libunwind/
  17. lld/
  18. lldb/
  19. llvm/
  20. llvm-libgcc/
  21. mlir/
  22. offload/
  23. openmp/
  24. orc-rt/
  25. polly/
  26. runtimes/
  27. third-party/
  28. utils/
  29. .clang-format
  30. .clang-format-ignore
  31. .clang-tidy
  32. .git-blame-ignore-revs
  33. .gitattributes
  34. .gitignore
  35. .mailmap
  36. CODE_OF_CONDUCT.md
  37. CONTRIBUTING.md
  38. LICENSE.TXT
  39. pyproject.toml
  40. README.md
  41. SECURITY.md
README.md

The LLVM Compiler Infrastructure

OpenSSF Scorecard OpenSSF Best Practices libc++

Welcome to the LLVM project!

This repository contains the source code for LLVM, a toolkit for the construction of highly optimized compilers, optimizers, and run-time environments.

The LLVM project has multiple components. The core of the project is itself called “LLVM”. This contains all of the tools, libraries, and header files needed to process intermediate representations and convert them into object files. Tools include an assembler, disassembler, bitcode analyzer, and bitcode optimizer.

C-like languages use the Clang frontend. This component compiles C, C++, Objective-C, and Objective-C++ code into LLVM bitcode -- and from there into object files, using LLVM.

Other components include: the libc++ C++ standard library, the LLD linker, and more.

Getting the Source Code and Building LLVM

Consult the Getting Started with LLVM page for information on building and running LLVM.

For information on how to contribute to the LLVM project, please take a look at the Contributing to LLVM guide.

Getting in touch

Join the LLVM Discourse forums, Discord chat, LLVM Office Hours or Regular sync-ups.

The LLVM project has adopted a code of conduct for participants to all modes of communication within the project.