[clang] 586e497 - [Tooling/Inclusion] Index more sub std namespace symbols.

Haojian Wu via cfe-commits cfe-commits at lists.llvm.org
Tue Mar 14 05:08:58 PDT 2023 

Author: Haojian Wu
Date: 2023-03-14T13:08:44+01:00
New Revision: 586e497f7985ddb0ca481b45f82e202d3b6f23ea

URL: https://github.com/llvm/llvm-project/commit/586e497f7985ddb0ca481b45f82e202d3b6f23ea
DIFF: https://github.com/llvm/llvm-project/commit/586e497f7985ddb0ca481b45f82e202d3b6f23ea.diff

LOG: [Tooling/Inclusion] Index more sub std namespace symbols.

Fixes https://github.com/llvm/llvm-project/issues/61373

Differential Revision: https://reviews.llvm.org/D146021

Added: 
    

Modified: 
    clang/lib/Tooling/Inclusions/Stdlib/StdSymbolMap.inc
    clang/tools/include-mapping/gen_std.py

Removed: 
    


################################################################################
diff  --git a/clang/lib/Tooling/Inclusions/Stdlib/StdSymbolMap.inc b/clang/lib/Tooling/Inclusions/Stdlib/StdSymbolMap.inc
index 1712c06c78704..a08ec11e77a4a 100644
--- a/clang/lib/Tooling/Inclusions/Stdlib/StdSymbolMap.inc
+++ b/clang/lib/Tooling/Inclusions/Stdlib/StdSymbolMap.inc
@@ -3416,6 +3416,14 @@ SYMBOL(year_month_weekday_last, std::chrono::, <chrono>)
 SYMBOL(zoned_seconds, std::chrono::, <chrono>)
 SYMBOL(zoned_time, std::chrono::, <chrono>)
 SYMBOL(zoned_traits, std::chrono::, <chrono>)
+SYMBOL(par, std::execution::, <execution>)
+SYMBOL(par_unseq, std::execution::, <execution>)
+SYMBOL(parallel_policy, std::execution::, <execution>)
+SYMBOL(parallel_unsequenced_policy, std::execution::, <execution>)
+SYMBOL(seq, std::execution::, <execution>)
+SYMBOL(sequenced_policy, std::execution::, <execution>)
+SYMBOL(unseq, std::execution::, <execution>)
+SYMBOL(unsequenced_policy, std::execution::, <execution>)
 SYMBOL(absolute, std::filesystem::, <filesystem>)
 SYMBOL(canonical, std::filesystem::, <filesystem>)
 SYMBOL(copy, std::filesystem::, <filesystem>)
@@ -3470,6 +3478,32 @@ SYMBOL(symlink_status, std::filesystem::, <filesystem>)
 SYMBOL(temp_directory_path, std::filesystem::, <filesystem>)
 SYMBOL(u8path, std::filesystem::, <filesystem>)
 SYMBOL(weakly_canonical, std::filesystem::, <filesystem>)
+SYMBOL(e, std::numbers::, <numbers>)
+SYMBOL(e_v, std::numbers::, <numbers>)
+SYMBOL(egamma, std::numbers::, <numbers>)
+SYMBOL(egamma_v, std::numbers::, <numbers>)
+SYMBOL(inv_pi, std::numbers::, <numbers>)
+SYMBOL(inv_pi_v, std::numbers::, <numbers>)
+SYMBOL(inv_sqrt3, std::numbers::, <numbers>)
+SYMBOL(inv_sqrt3_v, std::numbers::, <numbers>)
+SYMBOL(inv_sqrtpi, std::numbers::, <numbers>)
+SYMBOL(inv_sqrtpi_v, std::numbers::, <numbers>)
+SYMBOL(ln10, std::numbers::, <numbers>)
+SYMBOL(ln10_v, std::numbers::, <numbers>)
+SYMBOL(ln2, std::numbers::, <numbers>)
+SYMBOL(ln2_v, std::numbers::, <numbers>)
+SYMBOL(log10e, std::numbers::, <numbers>)
+SYMBOL(log10e_v, std::numbers::, <numbers>)
+SYMBOL(log2e, std::numbers::, <numbers>)
+SYMBOL(log2e_v, std::numbers::, <numbers>)
+SYMBOL(phi, std::numbers::, <numbers>)
+SYMBOL(phi_v, std::numbers::, <numbers>)
+SYMBOL(pi, std::numbers::, <numbers>)
+SYMBOL(pi_v, std::numbers::, <numbers>)
+SYMBOL(sqrt2, std::numbers::, <numbers>)
+SYMBOL(sqrt2_v, std::numbers::, <numbers>)
+SYMBOL(sqrt3, std::numbers::, <numbers>)
+SYMBOL(sqrt3_v, std::numbers::, <numbers>)
 SYMBOL(basic_string, std::pmr::, <string>)
 SYMBOL(cmatch, std::pmr::, <regex>)
 SYMBOL(deque, std::pmr::, <deque>)
@@ -3504,6 +3538,241 @@ SYMBOL(vector, std::pmr::, <vector>)
 SYMBOL(wcmatch, std::pmr::, <regex>)
 SYMBOL(wsmatch, std::pmr::, <regex>)
 SYMBOL(wstring, std::pmr::, <string>)
+SYMBOL(adjacent_find, std::ranges::, <algorithm>)
+SYMBOL(advance, std::ranges::, <iterator>)
+SYMBOL(all_of, std::ranges::, <algorithm>)
+SYMBOL(any_of, std::ranges::, <algorithm>)
+SYMBOL(as_const_view, std::ranges::, <ranges>)
+SYMBOL(as_rvalue_view, std::ranges::, <ranges>)
+SYMBOL(basic_istream_view, std::ranges::, <ranges>)
+SYMBOL(begin, std::ranges::, <ranges>)
+SYMBOL(bidirectional_range, std::ranges::, <ranges>)
+SYMBOL(binary_transform_result, std::ranges::, <algorithm>)
+SYMBOL(borrowed_iterator_t, std::ranges::, <ranges>)
+SYMBOL(borrowed_range, std::ranges::, <ranges>)
+SYMBOL(borrowed_subrange_t, std::ranges::, <ranges>)
+SYMBOL(cbegin, std::ranges::, <ranges>)
+SYMBOL(cdata, std::ranges::, <ranges>)
+SYMBOL(cend, std::ranges::, <ranges>)
+SYMBOL(clamp, std::ranges::, <algorithm>)
+SYMBOL(common_range, std::ranges::, <ranges>)
+SYMBOL(common_view, std::ranges::, <ranges>)
+SYMBOL(const_iterator_t, std::ranges::, <ranges>)
+SYMBOL(constant_range, std::ranges::, <ranges>)
+SYMBOL(construct_at, std::ranges::, <memory>)
+SYMBOL(contains, std::ranges::, <algorithm>)
+SYMBOL(contains_subrange, std::ranges::, <algorithm>)
+SYMBOL(contiguous_range, std::ranges::, <ranges>)
+SYMBOL(copy, std::ranges::, <algorithm>)
+SYMBOL(copy_backward, std::ranges::, <algorithm>)
+SYMBOL(copy_backward_result, std::ranges::, <algorithm>)
+SYMBOL(copy_if, std::ranges::, <algorithm>)
+SYMBOL(copy_if_result, std::ranges::, <algorithm>)
+SYMBOL(copy_n, std::ranges::, <algorithm>)
+SYMBOL(copy_n_result, std::ranges::, <algorithm>)
+SYMBOL(copy_result, std::ranges::, <algorithm>)
+SYMBOL(count, std::ranges::, <algorithm>)
+SYMBOL(count_if, std::ranges::, <algorithm>)
+SYMBOL(crbegin, std::ranges::, <ranges>)
+SYMBOL(crend, std::ranges::, <ranges>)
+SYMBOL(dangling, std::ranges::, <ranges>)
+SYMBOL(data, std::ranges::, <ranges>)
+SYMBOL(destroy, std::ranges::, <memory>)
+SYMBOL(destroy_at, std::ranges::, <memory>)
+SYMBOL(destroy_n, std::ranges::, <memory>)
+SYMBOL(disable_sized_range, std::ranges::, <ranges>)
+SYMBOL(distance, std::ranges::, <iterator>)
+SYMBOL(drop_view, std::ranges::, <ranges>)
+SYMBOL(drop_while_view, std::ranges::, <ranges>)
+SYMBOL(elements_view, std::ranges::, <ranges>)
+SYMBOL(empty, std::ranges::, <ranges>)
+SYMBOL(empty_view, std::ranges::, <ranges>)
+SYMBOL(enable_borrowed_range, std::ranges::, <ranges>)
+SYMBOL(enable_view, std::ranges::, <ranges>)
+SYMBOL(end, std::ranges::, <ranges>)
+SYMBOL(ends_with, std::ranges::, <algorithm>)
+SYMBOL(equal, std::ranges::, <algorithm>)
+SYMBOL(equal_to, std::ranges::, <functional>)
+SYMBOL(fill, std::ranges::, <algorithm>)
+SYMBOL(fill_n, std::ranges::, <algorithm>)
+SYMBOL(filter_view, std::ranges::, <ranges>)
+SYMBOL(find, std::ranges::, <algorithm>)
+SYMBOL(find_end, std::ranges::, <algorithm>)
+SYMBOL(find_first_of, std::ranges::, <algorithm>)
+SYMBOL(find_if, std::ranges::, <algorithm>)
+SYMBOL(find_if_not, std::ranges::, <algorithm>)
+SYMBOL(find_last, std::ranges::, <algorithm>)
+SYMBOL(find_last_if, std::ranges::, <algorithm>)
+SYMBOL(find_last_if_not, std::ranges::, <algorithm>)
+SYMBOL(for_each, std::ranges::, <algorithm>)
+SYMBOL(for_each_n, std::ranges::, <algorithm>)
+SYMBOL(for_each_n_result, std::ranges::, <algorithm>)
+SYMBOL(for_each_result, std::ranges::, <algorithm>)
+SYMBOL(forward_range, std::ranges::, <ranges>)
+SYMBOL(generate, std::ranges::, <algorithm>)
+SYMBOL(generate_n, std::ranges::, <algorithm>)
+SYMBOL(greater, std::ranges::, <functional>)
+SYMBOL(greater_equal, std::ranges::, <functional>)
+SYMBOL(in_found_result, std::ranges::, <algorithm>)
+SYMBOL(in_fun_result, std::ranges::, <algorithm>)
+SYMBOL(in_in_out_result, std::ranges::, <algorithm>)
+SYMBOL(in_in_result, std::ranges::, <algorithm>)
+SYMBOL(in_out_out_result, std::ranges::, <algorithm>)
+SYMBOL(in_out_result, std::ranges::, <algorithm>)
+SYMBOL(in_value_result, std::ranges::, <algorithm>)
+SYMBOL(includes, std::ranges::, <algorithm>)
+SYMBOL(inplace_merge, std::ranges::, <algorithm>)
+SYMBOL(input_range, std::ranges::, <ranges>)
+SYMBOL(iota, std::ranges::, <numeric>)
+SYMBOL(iota_result, std::ranges::, <numeric>)
+SYMBOL(iota_view, std::ranges::, <ranges>)
+SYMBOL(is_heap, std::ranges::, <algorithm>)
+SYMBOL(is_heap_until, std::ranges::, <algorithm>)
+SYMBOL(is_partitioned, std::ranges::, <algorithm>)
+SYMBOL(is_permutation, std::ranges::, <algorithm>)
+SYMBOL(is_sorted, std::ranges::, <algorithm>)
+SYMBOL(is_sorted_until, std::ranges::, <algorithm>)
+SYMBOL(istream_view, std::ranges::, <ranges>)
+SYMBOL(iter_move, std::ranges::, <iterator>)
+SYMBOL(iter_swap, std::ranges::, <iterator>)
+SYMBOL(iterator_t, std::ranges::, <ranges>)
+SYMBOL(join_view, std::ranges::, <ranges>)
+SYMBOL(join_with_view, std::ranges::, <ranges>)
+SYMBOL(keys_view, std::ranges::, <ranges>)
+SYMBOL(lazy_split_view, std::ranges::, <ranges>)
+SYMBOL(less, std::ranges::, <functional>)
+SYMBOL(less_equal, std::ranges::, <functional>)
+SYMBOL(lexicographical_compare, std::ranges::, <algorithm>)
+SYMBOL(make_heap, std::ranges::, <algorithm>)
+SYMBOL(max, std::ranges::, <algorithm>)
+SYMBOL(max_element, std::ranges::, <algorithm>)
+SYMBOL(merge, std::ranges::, <algorithm>)
+SYMBOL(merge_result, std::ranges::, <algorithm>)
+SYMBOL(min, std::ranges::, <algorithm>)
+SYMBOL(min_element, std::ranges::, <algorithm>)
+SYMBOL(min_max_result, std::ranges::, <algorithm>)
+SYMBOL(minmax, std::ranges::, <algorithm>)
+SYMBOL(minmax_element, std::ranges::, <algorithm>)
+SYMBOL(minmax_element_result, std::ranges::, <algorithm>)
+SYMBOL(minmax_result, std::ranges::, <algorithm>)
+SYMBOL(mismatch, std::ranges::, <algorithm>)
+SYMBOL(mismatch_result, std::ranges::, <algorithm>)
+SYMBOL(move, std::ranges::, <algorithm>)
+SYMBOL(move_backward, std::ranges::, <algorithm>)
+SYMBOL(move_backward_result, std::ranges::, <algorithm>)
+SYMBOL(move_result, std::ranges::, <algorithm>)
+SYMBOL(next, std::ranges::, <iterator>)
+SYMBOL(next_permutation, std::ranges::, <algorithm>)
+SYMBOL(next_permutation_result, std::ranges::, <algorithm>)
+SYMBOL(none_of, std::ranges::, <algorithm>)
+SYMBOL(not_equal_to, std::ranges::, <functional>)
+SYMBOL(nth_element, std::ranges::, <algorithm>)
+SYMBOL(out_value_result, std::ranges::, <algorithm>)
+SYMBOL(output_range, std::ranges::, <ranges>)
+SYMBOL(owning_view, std::ranges::, <ranges>)
+SYMBOL(partial_sort, std::ranges::, <algorithm>)
+SYMBOL(partial_sort_copy, std::ranges::, <algorithm>)
+SYMBOL(partial_sort_copy_result, std::ranges::, <algorithm>)
+SYMBOL(partition, std::ranges::, <algorithm>)
+SYMBOL(partition_copy, std::ranges::, <algorithm>)
+SYMBOL(partition_copy_result, std::ranges::, <algorithm>)
+SYMBOL(partition_point, std::ranges::, <algorithm>)
+SYMBOL(pop_heap, std::ranges::, <algorithm>)
+SYMBOL(prev, std::ranges::, <iterator>)
+SYMBOL(prev_permutation, std::ranges::, <algorithm>)
+SYMBOL(prev_permutation_result, std::ranges::, <algorithm>)
+SYMBOL(push_heap, std::ranges::, <algorithm>)
+SYMBOL(random_access_range, std::ranges::, <ranges>)
+SYMBOL(range, std::ranges::, <ranges>)
+SYMBOL(range_const_reference_t, std::ranges::, <ranges>)
+SYMBOL(range_
diff erence_t, std::ranges::, <ranges>)
+SYMBOL(range_reference_t, std::ranges::, <ranges>)
+SYMBOL(range_rvalue_reference_t, std::ranges::, <ranges>)
+SYMBOL(range_size_t, std::ranges::, <ranges>)
+SYMBOL(range_value_t, std::ranges::, <ranges>)
+SYMBOL(rbegin, std::ranges::, <ranges>)
+SYMBOL(ref_view, std::ranges::, <ranges>)
+SYMBOL(remove, std::ranges::, <algorithm>)
+SYMBOL(remove_copy, std::ranges::, <algorithm>)
+SYMBOL(remove_copy_if, std::ranges::, <algorithm>)
+SYMBOL(remove_copy_if_result, std::ranges::, <algorithm>)
+SYMBOL(remove_copy_result, std::ranges::, <algorithm>)
+SYMBOL(remove_if, std::ranges::, <algorithm>)
+SYMBOL(rend, std::ranges::, <ranges>)
+SYMBOL(replace, std::ranges::, <algorithm>)
+SYMBOL(replace_copy, std::ranges::, <algorithm>)
+SYMBOL(replace_copy_if, std::ranges::, <algorithm>)
+SYMBOL(replace_copy_if_result, std::ranges::, <algorithm>)
+SYMBOL(replace_copy_result, std::ranges::, <algorithm>)
+SYMBOL(replace_if, std::ranges::, <algorithm>)
+SYMBOL(reverse, std::ranges::, <algorithm>)
+SYMBOL(reverse_copy, std::ranges::, <algorithm>)
+SYMBOL(reverse_copy_result, std::ranges::, <algorithm>)
+SYMBOL(reverse_view, std::ranges::, <ranges>)
+SYMBOL(rotate, std::ranges::, <algorithm>)
+SYMBOL(rotate_copy, std::ranges::, <algorithm>)
+SYMBOL(rotate_copy_result, std::ranges::, <algorithm>)
+SYMBOL(sample, std::ranges::, <algorithm>)
+SYMBOL(search, std::ranges::, <algorithm>)
+SYMBOL(search_n, std::ranges::, <algorithm>)
+SYMBOL(sentinel_t, std::ranges::, <ranges>)
+SYMBOL(set_
diff erence, std::ranges::, <algorithm>)
+SYMBOL(set_
diff erence_result, std::ranges::, <algorithm>)
+SYMBOL(set_intersection, std::ranges::, <algorithm>)
+SYMBOL(set_intersection_result, std::ranges::, <algorithm>)
+SYMBOL(set_symmetric_
diff erence, std::ranges::, <algorithm>)
+SYMBOL(set_symmetric_
diff erence_result, std::ranges::, <algorithm>)
+SYMBOL(set_union, std::ranges::, <algorithm>)
+SYMBOL(set_union_result, std::ranges::, <algorithm>)
+SYMBOL(shift_left, std::ranges::, <algorithm>)
+SYMBOL(shift_right, std::ranges::, <algorithm>)
+SYMBOL(shuffle, std::ranges::, <algorithm>)
+SYMBOL(single_view, std::ranges::, <ranges>)
+SYMBOL(size, std::ranges::, <ranges>)
+SYMBOL(sized_range, std::ranges::, <ranges>)
+SYMBOL(sort, std::ranges::, <algorithm>)
+SYMBOL(sort_heap, std::ranges::, <algorithm>)
+SYMBOL(split_view, std::ranges::, <ranges>)
+SYMBOL(ssize, std::ranges::, <ranges>)
+SYMBOL(stable_partition, std::ranges::, <algorithm>)
+SYMBOL(stable_sort, std::ranges::, <algorithm>)
+SYMBOL(starts_with, std::ranges::, <algorithm>)
+SYMBOL(subrange, std::ranges::, <ranges>)
+SYMBOL(subrange_kind, std::ranges::, <ranges>)
+SYMBOL(swap, std::ranges::, <concepts>)
+SYMBOL(swap_ranges, std::ranges::, <algorithm>)
+SYMBOL(swap_ranges_result, std::ranges::, <algorithm>)
+SYMBOL(take_view, std::ranges::, <ranges>)
+SYMBOL(take_while_view, std::ranges::, <ranges>)
+SYMBOL(to, std::ranges::, <ranges>)
+SYMBOL(transform, std::ranges::, <algorithm>)
+SYMBOL(transform_view, std::ranges::, <ranges>)
+SYMBOL(unary_transform_result, std::ranges::, <algorithm>)
+SYMBOL(uninitialized_copy, std::ranges::, <memory>)
+SYMBOL(uninitialized_copy_n, std::ranges::, <memory>)
+SYMBOL(uninitialized_copy_n_result, std::ranges::, <memory>)
+SYMBOL(uninitialized_copy_result, std::ranges::, <memory>)
+SYMBOL(uninitialized_default_construct, std::ranges::, <memory>)
+SYMBOL(uninitialized_default_construct_n, std::ranges::, <memory>)
+SYMBOL(uninitialized_fill, std::ranges::, <memory>)
+SYMBOL(uninitialized_fill_n, std::ranges::, <memory>)
+SYMBOL(uninitialized_move, std::ranges::, <memory>)
+SYMBOL(uninitialized_move_n, std::ranges::, <memory>)
+SYMBOL(uninitialized_move_n_result, std::ranges::, <memory>)
+SYMBOL(uninitialized_move_result, std::ranges::, <memory>)
+SYMBOL(uninitialized_value_construct, std::ranges::, <memory>)
+SYMBOL(uninitialized_value_construct_n, std::ranges::, <memory>)
+SYMBOL(unique, std::ranges::, <algorithm>)
+SYMBOL(unique_copy, std::ranges::, <algorithm>)
+SYMBOL(unique_copy_result, std::ranges::, <algorithm>)
+SYMBOL(values_view, std::ranges::, <ranges>)
+SYMBOL(view, std::ranges::, <ranges>)
+SYMBOL(view_base, std::ranges::, <ranges>)
+SYMBOL(view_interface, std::ranges::, <ranges>)
+SYMBOL(viewable_range, std::ranges::, <ranges>)
+SYMBOL(wistream_view, std::ranges::, <ranges>)
+SYMBOL(zip_transform_view, std::ranges::, <ranges>)
+SYMBOL(zip_view, std::ranges::, <ranges>)
 SYMBOL(ECMAScript, std::regex_constants::, <regex>)
 SYMBOL(awk, std::regex_constants::, <regex>)
 SYMBOL(basic, std::regex_constants::, <regex>)

diff  --git a/clang/tools/include-mapping/gen_std.py b/clang/tools/include-mapping/gen_std.py
index 45ae60fc6f000..944fd17263700 100755
--- a/clang/tools/include-mapping/gen_std.py
+++ b/clang/tools/include-mapping/gen_std.py
@@ -248,8 +248,11 @@ def main():
       #
       # std::placeholders symbols are handled manually in StdSpecialSymbolMap.inc
       (symbol_index_root, "chrono.html", "std::chrono::"),
+      (symbol_index_root, "execution.html", "std::execution::"),
+      (symbol_index_root, "numbers.html", "std::numbers::"),
       (symbol_index_root, "filesystem.html", "std::filesystem::"),
       (symbol_index_root, "pmr.html", "std::pmr::"),
+      (symbol_index_root, "ranges.html", "std::ranges::"),
       (symbol_index_root, "regex_constants.html", "std::regex_constants::"),
       (symbol_index_root, "this_thread.html", "std::this_thread::"),
       # Zombie symbols that were available from the Standard Library, but are

More information about the cfe-commits mailing list