[libcxx] adds an include-what-you-use (IWYU) mapping file
This makes it possible for programmers to run IWYU and get more accurate
standard library inclusions. Prior to this commit, the following program
would be transformed thusly:
```cpp
// Before
#include <algorithm>
#include <vector>
void f() {
auto v = std::vector{0, 1};
std::find(std::ranges::begin(v), std::ranges::end(v), 0);
}
```
```cpp
// After
#include <__algorithm/find.h>
#include <__ranges/access.h>
#include <vector>
...
```
There are two ways to fix this issue: to use [comment pragmas](https://github.com/include-what-you-use/include-what-you-use/blob/master/docs/IWYUPragmas.md)
on every private include, or to write a canonical [mapping file](https://github.com/include-what-you-use/include-what-you-use/blob/master/docs/IWYUMappings.md)
that provides the tool with a manual on how libc++ is laid out. Due to
the complexity of libc++, this commit opts for the latter, to maximise
correctness and minimise developer burden.
To mimimise developer updates to the file, it makes use of wildcards
that match everything within listed subdirectories. A script has also
been added to ensure that the mapping is always fresh in CI, and makes
the process a single step.
Finally, documentation has been added to inform users that IWYU is
supported, and what they need to do in order to leverage the mapping
file.
Closes #56937.
Differential Revision: https://reviews.llvm.org/D138189
2022-11-17 15:36:37 +08:00
|
|
|
[
|
|
|
|
|
{ include: [ "<__hash_table>", "private", "<unordered_map>", "public" ] },
|
|
|
|
|
{ include: [ "<__hash_table>", "private", "<unordered_set>", "public" ] },
|
|
|
|
|
{ include: [ "<__locale>", "private", "<locale>", "public" ] },
|
|
|
|
|
{ include: [ "<__node_handle>", "private", "<map>", "public" ] },
|
|
|
|
|
{ include: [ "<__node_handle>", "private", "<set>", "public" ] },
|
|
|
|
|
{ include: [ "<__node_handle>", "private", "<unordered_map>", "public" ] },
|
|
|
|
|
{ include: [ "<__node_handle>", "private", "<unordered_set>", "public" ] },
|
|
|
|
|
{ include: [ "<__split_buffer>", "private", "<deque>", "public" ] },
|
|
|
|
|
{ include: [ "<__split_buffer>", "private", "<vector>", "public" ] },
|
|
|
|
|
{ include: [ "<__std_stream>", "private", "<iostream>", "public" ] },
|
|
|
|
|
{ include: [ "<__threading_support>", "private", "<atomic>", "public" ] },
|
|
|
|
|
{ include: [ "<__threading_support>", "private", "<mutex>", "public" ] },
|
|
|
|
|
{ include: [ "<__threading_support>", "private", "<semaphore>", "public" ] },
|
|
|
|
|
{ include: [ "<__threading_support>", "private", "<thread>", "public" ] },
|
|
|
|
|
{ include: [ "<__tree>", "private", "<map>", "public" ] },
|
|
|
|
|
{ include: [ "<__tree>", "private", "<set>", "public" ] },
|
|
|
|
|
{ include: [ "@<__algorithm/.*>", "private", "<algorithm>", "public" ] },
|
2023-01-14 09:53:52 +08:00
|
|
|
{ include: [ "@<__atomic/.*>", "private", "<atomic>", "public" ] },
|
[libcxx] adds an include-what-you-use (IWYU) mapping file
This makes it possible for programmers to run IWYU and get more accurate
standard library inclusions. Prior to this commit, the following program
would be transformed thusly:
```cpp
// Before
#include <algorithm>
#include <vector>
void f() {
auto v = std::vector{0, 1};
std::find(std::ranges::begin(v), std::ranges::end(v), 0);
}
```
```cpp
// After
#include <__algorithm/find.h>
#include <__ranges/access.h>
#include <vector>
...
```
There are two ways to fix this issue: to use [comment pragmas](https://github.com/include-what-you-use/include-what-you-use/blob/master/docs/IWYUPragmas.md)
on every private include, or to write a canonical [mapping file](https://github.com/include-what-you-use/include-what-you-use/blob/master/docs/IWYUMappings.md)
that provides the tool with a manual on how libc++ is laid out. Due to
the complexity of libc++, this commit opts for the latter, to maximise
correctness and minimise developer burden.
To mimimise developer updates to the file, it makes use of wildcards
that match everything within listed subdirectories. A script has also
been added to ensure that the mapping is always fresh in CI, and makes
the process a single step.
Finally, documentation has been added to inform users that IWYU is
supported, and what they need to do in order to leverage the mapping
file.
Closes #56937.
Differential Revision: https://reviews.llvm.org/D138189
2022-11-17 15:36:37 +08:00
|
|
|
{ include: [ "@<__bit/.*>", "private", "<bit>", "public" ] },
|
|
|
|
|
{ include: [ "@<__charconv/.*>", "private", "<charconv>", "public" ] },
|
|
|
|
|
{ include: [ "@<__chrono/.*>", "private", "<chrono>", "public" ] },
|
|
|
|
|
{ include: [ "@<__compare/.*>", "private", "<compare>", "public" ] },
|
|
|
|
|
{ include: [ "@<__concepts/.*>", "private", "<concepts>", "public" ] },
|
|
|
|
|
{ include: [ "@<__coroutine/.*>", "private", "<coroutine>", "public" ] },
|
|
|
|
|
{ include: [ "@<__debug_utils/.*>", "private", "<debug_utils>", "public" ] },
|
2023-03-02 03:13:55 +08:00
|
|
|
{ include: [ "@<__exception/.*>", "private", "<exception>", "public" ] },
|
2022-11-04 19:42:42 +08:00
|
|
|
{ include: [ "@<__expected/.*>", "private", "<expected>", "public" ] },
|
[libcxx] adds an include-what-you-use (IWYU) mapping file
This makes it possible for programmers to run IWYU and get more accurate
standard library inclusions. Prior to this commit, the following program
would be transformed thusly:
```cpp
// Before
#include <algorithm>
#include <vector>
void f() {
auto v = std::vector{0, 1};
std::find(std::ranges::begin(v), std::ranges::end(v), 0);
}
```
```cpp
// After
#include <__algorithm/find.h>
#include <__ranges/access.h>
#include <vector>
...
```
There are two ways to fix this issue: to use [comment pragmas](https://github.com/include-what-you-use/include-what-you-use/blob/master/docs/IWYUPragmas.md)
on every private include, or to write a canonical [mapping file](https://github.com/include-what-you-use/include-what-you-use/blob/master/docs/IWYUMappings.md)
that provides the tool with a manual on how libc++ is laid out. Due to
the complexity of libc++, this commit opts for the latter, to maximise
correctness and minimise developer burden.
To mimimise developer updates to the file, it makes use of wildcards
that match everything within listed subdirectories. A script has also
been added to ensure that the mapping is always fresh in CI, and makes
the process a single step.
Finally, documentation has been added to inform users that IWYU is
supported, and what they need to do in order to leverage the mapping
file.
Closes #56937.
Differential Revision: https://reviews.llvm.org/D138189
2022-11-17 15:36:37 +08:00
|
|
|
{ include: [ "@<__filesystem/.*>", "private", "<filesystem>", "public" ] },
|
|
|
|
|
{ include: [ "@<__format/.*>", "private", "<format>", "public" ] },
|
|
|
|
|
{ include: [ "@<__functional/.*>", "private", "<functional>", "public" ] },
|
|
|
|
|
{ include: [ "@<__fwd/.*>", "private", "<fwd>", "public" ] },
|
|
|
|
|
{ include: [ "@<__ios/.*>", "private", "<ios>", "public" ] },
|
|
|
|
|
{ include: [ "@<__iterator/.*>", "private", "<iterator>", "public" ] },
|
|
|
|
|
{ include: [ "@<__memory/.*>", "private", "<memory>", "public" ] },
|
|
|
|
|
{ include: [ "@<__memory_resource/.*>", "private", "<memory_resource>", "public" ] },
|
|
|
|
|
{ include: [ "@<__numeric/.*>", "private", "<numeric>", "public" ] },
|
|
|
|
|
{ include: [ "@<__random/.*>", "private", "<random>", "public" ] },
|
|
|
|
|
{ include: [ "@<__ranges/.*>", "private", "<ranges>", "public" ] },
|
|
|
|
|
{ include: [ "@<__string/.*>", "private", "<string>", "public" ] },
|
|
|
|
|
{ include: [ "@<__support/.*>", "private", "<support>", "public" ] },
|
|
|
|
|
{ include: [ "@<__thread/.*>", "private", "<thread>", "public" ] },
|
2022-12-04 14:39:41 +08:00
|
|
|
{ include: [ "@<__tuple_dir/.*>", "private", "<tuple>", "public" ] },
|
[libcxx] adds an include-what-you-use (IWYU) mapping file
This makes it possible for programmers to run IWYU and get more accurate
standard library inclusions. Prior to this commit, the following program
would be transformed thusly:
```cpp
// Before
#include <algorithm>
#include <vector>
void f() {
auto v = std::vector{0, 1};
std::find(std::ranges::begin(v), std::ranges::end(v), 0);
}
```
```cpp
// After
#include <__algorithm/find.h>
#include <__ranges/access.h>
#include <vector>
...
```
There are two ways to fix this issue: to use [comment pragmas](https://github.com/include-what-you-use/include-what-you-use/blob/master/docs/IWYUPragmas.md)
on every private include, or to write a canonical [mapping file](https://github.com/include-what-you-use/include-what-you-use/blob/master/docs/IWYUMappings.md)
that provides the tool with a manual on how libc++ is laid out. Due to
the complexity of libc++, this commit opts for the latter, to maximise
correctness and minimise developer burden.
To mimimise developer updates to the file, it makes use of wildcards
that match everything within listed subdirectories. A script has also
been added to ensure that the mapping is always fresh in CI, and makes
the process a single step.
Finally, documentation has been added to inform users that IWYU is
supported, and what they need to do in order to leverage the mapping
file.
Closes #56937.
Differential Revision: https://reviews.llvm.org/D138189
2022-11-17 15:36:37 +08:00
|
|
|
{ include: [ "@<__type_traits/.*>", "private", "<type_traits>", "public" ] },
|
|
|
|
|
{ include: [ "@<__utility/.*>", "private", "<utility>", "public" ] },
|
|
|
|
|
{ include: [ "@<__variant/.*>", "private", "<variant>", "public" ] },
|
|
|
|
|
]
|