[include-mapping] Better #includes support for std input/output symbols

[kadircet]

clang/tools/include-mapping/gen_std.py

160

i think putting iostream before iosfwd in the alternative list makes more sense. WDYT?

215–218

what about changing this to:

symbol.headers.extend(AdditionalHeadersForIOSymbols(symbol))
for header in symbol.headers:
  ....

(and also changing AdditionalHeadersForIOSymbols to only return additional headers and an empty list if there's none)

that way it'll be easier to augment symbol headers later on.

[hokein]

address review comments.

clang/tools/include-mapping/gen_std.py

160

sounds good.

[kadircet]

thanks, lgtm! as discussed offline, let's first move the raw header mappings to a private location first though and make sure all users are going through stdlib apis to ensure we don't see weird behaviour after such changes (since we're breaking the invariant of a qualified symbol name occurring only once)

[hokein]

add a unittest

clang/include/clang/Tooling/Inclusions/StdSymbolMap.inc

 SYMBOL(bad_function_call, std::, <functional>)
 SYMBOL(bad_optional_access, std::, <optional>)
 SYMBOL(bad_typeid, std::, <typeinfo>)
 SYMBOL(bad_variant_access, std::, <variant>)
 SYMBOL(bad_weak_ptr, std::, <memory>)
 SYMBOL(barrier, std::, <barrier>)
 SYMBOL(basic_common_reference, std::, <type_traits>)
 SYMBOL(basic_filebuf, std::, <fstream>)
+SYMBOL(basic_filebuf, std::, <iosfwd>)
 SYMBOL(basic_format_arg, std::, <format>)
 SYMBOL(basic_format_args, std::, <format>)
 SYMBOL(basic_format_context, std::, <format>)
 SYMBOL(basic_format_parse_context, std::, <format>)
 SYMBOL(basic_fstream, std::, <fstream>)
+SYMBOL(basic_fstream, std::, <iosfwd>)
 SYMBOL(basic_ifstream, std::, <fstream>)
+SYMBOL(basic_ifstream, std::, <iosfwd>)
 SYMBOL(basic_ios, std::, <ios>)
+SYMBOL(basic_ios, std::, <iostream>)
+SYMBOL(basic_ios, std::, <iosfwd>)
 SYMBOL(basic_iostream, std::, <istream>)
+SYMBOL(basic_iostream, std::, <iostream>)
+SYMBOL(basic_iostream, std::, <iosfwd>)
 SYMBOL(basic_ispanstream, std::, <spanstream>)
+SYMBOL(basic_ispanstream, std::, <iosfwd>)
 SYMBOL(basic_istream, std::, <istream>)
+SYMBOL(basic_istream, std::, <iostream>)
+SYMBOL(basic_istream, std::, <iosfwd>)
 SYMBOL(basic_istringstream, std::, <sstream>)
+SYMBOL(basic_istringstream, std::, <iosfwd>)
 SYMBOL(basic_ofstream, std::, <fstream>)
+SYMBOL(basic_ofstream, std::, <iosfwd>)
 SYMBOL(basic_ospanstream, std::, <spanstream>)
+SYMBOL(basic_ospanstream, std::, <iosfwd>)
 SYMBOL(basic_ostream, std::, <ostream>)
+SYMBOL(basic_ostream, std::, <iostream>)
+SYMBOL(basic_ostream, std::, <iosfwd>)
 SYMBOL(basic_ostringstream, std::, <sstream>)
+SYMBOL(basic_ostringstream, std::, <iosfwd>)
 SYMBOL(basic_osyncstream, std::, <syncstream>)
+SYMBOL(basic_osyncstream, std::, <iosfwd>)
 SYMBOL(basic_regex, std::, <regex>)
 SYMBOL(basic_spanbuf, std::, <spanstream>)
+SYMBOL(basic_spanbuf, std::, <iosfwd>)
 SYMBOL(basic_spanstream, std::, <spanstream>)
+SYMBOL(basic_spanstream, std::, <iosfwd>)
 SYMBOL(basic_stacktrace, std::, <stacktrace>)
 SYMBOL(basic_streambuf, std::, <streambuf>)
+SYMBOL(basic_streambuf, std::, <iostream>)
+SYMBOL(basic_streambuf, std::, <iosfwd>)
 SYMBOL(basic_string, std::, <string>)
 SYMBOL(basic_string_view, std::, <string_view>)
 SYMBOL(basic_stringbuf, std::, <sstream>)
+SYMBOL(basic_stringbuf, std::, <iosfwd>)
 SYMBOL(basic_stringstream, std::, <sstream>)
+SYMBOL(basic_stringstream, std::, <iosfwd>)
 SYMBOL(basic_syncbuf, std::, <syncstream>)
+SYMBOL(basic_syncbuf, std::, <iosfwd>)
 SYMBOL(bernoulli_distribution, std::, <random>)
 SYMBOL(beta, std::, <cmath>)
 SYMBOL(betaf, std::, <cmath>)
 SYMBOL(betal, std::, <cmath>)
 SYMBOL(bidirectional_iterator, std::, <iterator>)
 SYMBOL(bidirectional_iterator_tag, std::, <iterator>)
 SYMBOL(binary_search, std::, <algorithm>)
 SYMBOL(binary_semaphore, std::, <semaphore>)
 SYMBOL(bind, std::, <functional>)
 SYMBOL(bind_back, std::, <functional>)
 SYMBOL(bind_front, std::, <functional>)
 SYMBOL(binomial_distribution, std::, <random>)
 SYMBOL(bit_and, std::, <functional>)
 SYMBOL(bit_cast, std::, <bit>)
 SYMBOL(bit_ceil, std::, <bit>)
 SYMBOL(bit_floor, std::, <bit>)
 SYMBOL(bit_not, std::, <functional>)
 SYMBOL(bit_or, std::, <functional>)
 SYMBOL(bit_width, std::, <bit>)
 SYMBOL(bit_xor, std::, <functional>)
 SYMBOL(bitset, std::, <bitset>)
 SYMBOL(bool_constant, std::, <type_traits>)
 SYMBOL(boolalpha, std::, <ios>)
+SYMBOL(boolalpha, std::, <iostream>)
 SYMBOL(boyer_moore_horspool_searcher, std::, <functional>)
 SYMBOL(boyer_moore_searcher, std::, <functional>)
 SYMBOL(bsearch, std::, <cstdlib>)
 SYMBOL(btowc, std::, <cwchar>)
 SYMBOL(byte, std::, <cstddef>)
 SYMBOL(byteswap, std::, <bit>)
 SYMBOL(c16rtomb, std::, <cuchar>)
 SYMBOL(c32rtomb, std::, <cuchar>)

 SYMBOL(cyl_bessel_jl, std::, <cmath>)
 SYMBOL(cyl_bessel_k, std::, <cmath>)
 SYMBOL(cyl_bessel_kf, std::, <cmath>)
 SYMBOL(cyl_bessel_kl, std::, <cmath>)
 SYMBOL(cyl_neumann, std::, <cmath>)
 SYMBOL(cyl_neumannf, std::, <cmath>)
 SYMBOL(cyl_neumannl, std::, <cmath>)
 SYMBOL(dec, std::, <ios>)
+SYMBOL(dec, std::, <iostream>)
 SYMBOL(deca, std::, <ratio>)
 SYMBOL(decay, std::, <type_traits>)
 SYMBOL(decay_t, std::, <type_traits>)
 SYMBOL(deci, std::, <ratio>)
 SYMBOL(declval, std::, <utility>)
 SYMBOL(default_delete, std::, <memory>)
 SYMBOL(default_initializable, std::, <concepts>)
 SYMBOL(default_random_engine, std::, <random>)
 SYMBOL(default_searcher, std::, <functional>)
 SYMBOL(default_sentinel, std::, <iterator>)
 SYMBOL(default_sentinel_t, std::, <iterator>)
 SYMBOL(defaultfloat, std::, <ios>)
+SYMBOL(defaultfloat, std::, <iostream>)
 SYMBOL(defer_lock, std::, <mutex>)
 SYMBOL(defer_lock_t, std::, <mutex>)
 SYMBOL(denorm_absent, std::, <limits>)
 SYMBOL(denorm_indeterminate, std::, <limits>)
 SYMBOL(denorm_present, std::, <limits>)
 SYMBOL(deque, std::, <deque>)
 SYMBOL(derived_from, std::, <concepts>)
 SYMBOL(destroy, std::, <memory>)

 SYMBOL(ellint_1l, std::, <cmath>)
 SYMBOL(ellint_2, std::, <cmath>)
 SYMBOL(ellint_2f, std::, <cmath>)
 SYMBOL(ellint_2l, std::, <cmath>)
 SYMBOL(ellint_3, std::, <cmath>)
 SYMBOL(ellint_3f, std::, <cmath>)
 SYMBOL(ellint_3l, std::, <cmath>)
 SYMBOL(emit_on_flush, std::, <ostream>)
+SYMBOL(emit_on_flush, std::, <iostream>)
 SYMBOL(enable_if, std::, <type_traits>)
 SYMBOL(enable_if_t, std::, <type_traits>)
 SYMBOL(enable_shared_from_this, std::, <memory>)
 SYMBOL(endian, std::, <bit>)
 SYMBOL(endl, std::, <ostream>)
+SYMBOL(endl, std::, <iostream>)
 SYMBOL(ends, std::, <ostream>)
+SYMBOL(ends, std::, <iostream>)
 SYMBOL(equal, std::, <algorithm>)
 SYMBOL(equal_range, std::, <algorithm>)
 SYMBOL(equal_to, std::, <functional>)
 SYMBOL(equality_comparable, std::, <concepts>)
 SYMBOL(equality_comparable_with, std::, <concepts>)
 SYMBOL(equivalence_relation, std::, <concepts>)
 SYMBOL(erase, std::, <vector>)
 SYMBOL(erase_if, std::, <vector>)

 SYMBOL(fexcept_t, std::, <cfenv>)
 SYMBOL(fflush, std::, <cstdio>)
 SYMBOL(fgetc, std::, <cstdio>)
 SYMBOL(fgetpos, std::, <cstdio>)
 SYMBOL(fgets, std::, <cstdio>)
 SYMBOL(fgetwc, std::, <cwchar>)
 SYMBOL(fgetws, std::, <cwchar>)
 SYMBOL(filebuf, std::, <streambuf>)
+SYMBOL(filebuf, std::, <iostream>)
+SYMBOL(filebuf, std::, <iosfwd>)
 SYMBOL(fill, std::, <algorithm>)
 SYMBOL(fill_n, std::, <algorithm>)
 SYMBOL(find, std::, <algorithm>)
 SYMBOL(find_end, std::, <algorithm>)
 SYMBOL(find_first_of, std::, <algorithm>)
 SYMBOL(find_if, std::, <algorithm>)
 SYMBOL(find_if_not, std::, <algorithm>)
 SYMBOL(fisher_f_distribution, std::, <random>)
 SYMBOL(fixed, std::, <ios>)
+SYMBOL(fixed, std::, <iostream>)
 SYMBOL(float_denorm_style, std::, <limits>)
 SYMBOL(float_round_style, std::, <limits>)
 SYMBOL(float_t, std::, <cmath>)
 SYMBOL(floating_point, std::, <concepts>)
 SYMBOL(floor, std::, <cmath>)
 SYMBOL(floorf, std::, <cmath>)
 SYMBOL(floorl, std::, <cmath>)
 SYMBOL(flush, std::, <ostream>)
+SYMBOL(flush, std::, <iostream>)
 SYMBOL(flush_emit, std::, <ostream>)
+SYMBOL(flush_emit, std::, <iostream>)
 SYMBOL(fma, std::, <cmath>)
 SYMBOL(fmaf, std::, <cmath>)
 SYMBOL(fmal, std::, <cmath>)
 SYMBOL(fmax, std::, <cmath>)
 SYMBOL(fmaxf, std::, <cmath>)
 SYMBOL(fmaxl, std::, <cmath>)
 SYMBOL(fmin, std::, <cmath>)
 SYMBOL(fminf, std::, <cmath>)

 SYMBOL(forward, std::, <utility>)
 SYMBOL(forward_as_tuple, std::, <tuple>)
 SYMBOL(forward_iterator, std::, <iterator>)
 SYMBOL(forward_iterator_tag, std::, <iterator>)
 SYMBOL(forward_like, std::, <utility>)
 SYMBOL(forward_list, std::, <forward_list>)
 SYMBOL(fpclassify, std::, <cmath>)
 SYMBOL(fpos, std::, <ios>)
+SYMBOL(fpos, std::, <iostream>)
+SYMBOL(fpos, std::, <iosfwd>)
 SYMBOL(fpos_t, std::, <cstdio>)
 SYMBOL(fprintf, std::, <cstdio>)
 SYMBOL(fputc, std::, <cstdio>)
 SYMBOL(fputs, std::, <cstdio>)
 SYMBOL(fputwc, std::, <cwchar>)
 SYMBOL(fputws, std::, <cwchar>)
 SYMBOL(fread, std::, <cstdio>)
 SYMBOL(free, std::, <cstdlib>)
 SYMBOL(freopen, std::, <cstdio>)
 SYMBOL(frexp, std::, <cmath>)
 SYMBOL(frexpf, std::, <cmath>)
 SYMBOL(frexpl, std::, <cmath>)
 SYMBOL(from_chars, std::, <charconv>)
 SYMBOL(from_chars_result, std::, <charconv>)
 SYMBOL(from_range, std::, <ranges>)
 SYMBOL(from_range_t, std::, <ranges>)
 SYMBOL(front_insert_iterator, std::, <iterator>)
 SYMBOL(front_inserter, std::, <iterator>)
 SYMBOL(fscanf, std::, <cstdio>)
 SYMBOL(fseek, std::, <cstdio>)
 SYMBOL(fsetpos, std::, <cstdio>)
 SYMBOL(fstream, std::, <fstream>)
+SYMBOL(fstream, std::, <iosfwd>)
 SYMBOL(ftell, std::, <cstdio>)
 SYMBOL(function, std::, <functional>)
 SYMBOL(future, std::, <future>)
 SYMBOL(future_category, std::, <future>)
 SYMBOL(future_errc, std::, <future>)
 SYMBOL(future_error, std::, <future>)
 SYMBOL(future_status, std::, <future>)
 SYMBOL(fwide, std::, <cwchar>)

 SYMBOL(has_virtual_destructor, std::, <type_traits>)
 SYMBOL(has_virtual_destructor_v, std::, <type_traits>)
 SYMBOL(hash, std::, <functional>)
 SYMBOL(hecto, std::, <ratio>)
 SYMBOL(hermite, std::, <cmath>)
 SYMBOL(hermitef, std::, <cmath>)
 SYMBOL(hermitel, std::, <cmath>)
 SYMBOL(hex, std::, <ios>)
+SYMBOL(hex, std::, <iostream>)
 SYMBOL(hexfloat, std::, <ios>)
+SYMBOL(hexfloat, std::, <iostream>)
 SYMBOL(holds_alternative, std::, <variant>)
 SYMBOL(hypot, std::, <cmath>)
 SYMBOL(hypotf, std::, <cmath>)
 SYMBOL(hypotl, std::, <cmath>)
 SYMBOL(identity, std::, <functional>)
 SYMBOL(ifstream, std::, <fstream>)
+SYMBOL(ifstream, std::, <iosfwd>)
 SYMBOL(ignore, std::, <tuple>)
 SYMBOL(ilogb, std::, <cmath>)
 SYMBOL(ilogbf, std::, <cmath>)
 SYMBOL(ilogbl, std::, <cmath>)
 SYMBOL(imag, std::, <complex>)
 SYMBOL(imaxabs, std::, <cinttypes>)
 SYMBOL(imaxdiv, std::, <cinttypes>)
 SYMBOL(imaxdiv_t, std::, <cinttypes>)

 SYMBOL(int_least16_t, std::, <cstdint>)
 SYMBOL(int_least32_t, std::, <cstdint>)
 SYMBOL(int_least64_t, std::, <cstdint>)
 SYMBOL(int_least8_t, std::, <cstdint>)
 SYMBOL(integer_sequence, std::, <utility>)
 SYMBOL(integral, std::, <concepts>)
 SYMBOL(integral_constant, std::, <type_traits>)
 SYMBOL(internal, std::, <ios>)
+SYMBOL(internal, std::, <iostream>)
 SYMBOL(intmax_t, std::, <cstdint>)
 SYMBOL(intptr_t, std::, <cstdint>)
 SYMBOL(invalid_argument, std::, <stdexcept>)
 SYMBOL(invocable, std::, <concepts>)
 SYMBOL(invoke, std::, <functional>)
 SYMBOL(invoke_r, std::, <functional>)
 SYMBOL(invoke_result, std::, <type_traits>)
 SYMBOL(invoke_result_t, std::, <type_traits>)
 SYMBOL(io_errc, std::, <ios>)
+SYMBOL(io_errc, std::, <iostream>)
 SYMBOL(ios, std::, <ios>)
+SYMBOL(ios, std::, <iostream>)
+SYMBOL(ios, std::, <iosfwd>)
 SYMBOL(ios_base, std::, <ios>)
+SYMBOL(ios_base, std::, <iostream>)
 SYMBOL(iostream, std::, <istream>)
+SYMBOL(iostream, std::, <iostream>)
+SYMBOL(iostream, std::, <iosfwd>)
 SYMBOL(iostream_category, std::, <ios>)
+SYMBOL(iostream_category, std::, <iostream>)
 SYMBOL(iota, std::, <numeric>)
 SYMBOL(is_abstract, std::, <type_traits>)
 SYMBOL(is_abstract_v, std::, <type_traits>)
 SYMBOL(is_aggregate, std::, <type_traits>)
 SYMBOL(is_aggregate_v, std::, <type_traits>)
 SYMBOL(is_arithmetic, std::, <type_traits>)
 SYMBOL(is_arithmetic_v, std::, <type_traits>)
 SYMBOL(is_array, std::, <type_traits>)

 SYMBOL(isinf, std::, <cmath>)
 SYMBOL(isless, std::, <cmath>)
 SYMBOL(islessequal, std::, <cmath>)
 SYMBOL(islessgreater, std::, <cmath>)
 SYMBOL(islower, std::, <cctype>)
 SYMBOL(isnan, std::, <cmath>)
 SYMBOL(isnormal, std::, <cmath>)
 SYMBOL(ispanstream, std::, <spanstream>)
+SYMBOL(ispanstream, std::, <iosfwd>)
 SYMBOL(isprint, std::, <cctype>)
 SYMBOL(ispunct, std::, <cctype>)
 SYMBOL(isspace, std::, <cctype>)
 SYMBOL(istream, std::, <istream>)
+SYMBOL(istream, std::, <iostream>)
+SYMBOL(istream, std::, <iosfwd>)
 SYMBOL(istream_iterator, std::, <iterator>)
 SYMBOL(istreambuf_iterator, std::, <iterator>)
+SYMBOL(istreambuf_iterator, std::, <iosfwd>)
 SYMBOL(istringstream, std::, <sstream>)
+SYMBOL(istringstream, std::, <iosfwd>)
 SYMBOL(istrstream, std::, <strstream>)
 SYMBOL(isunordered, std::, <cmath>)
 SYMBOL(isupper, std::, <cctype>)
 SYMBOL(iswalnum, std::, <cwctype>)
 SYMBOL(iswalpha, std::, <cwctype>)
 SYMBOL(iswblank, std::, <cwctype>)
 SYMBOL(iswcntrl, std::, <cwctype>)
 SYMBOL(iswctype, std::, <cwctype>)

 SYMBOL(lcm, std::, <numeric>)
 SYMBOL(lconv, std::, <clocale>)
 SYMBOL(ldexp, std::, <cmath>)
 SYMBOL(ldexpf, std::, <cmath>)
 SYMBOL(ldexpl, std::, <cmath>)
 SYMBOL(ldiv, std::, <cstdlib>)
 SYMBOL(ldiv_t, std::, <cstdlib>)
 SYMBOL(left, std::, <ios>)
+SYMBOL(left, std::, <iostream>)
 SYMBOL(legendre, std::, <cmath>)
 SYMBOL(legendref, std::, <cmath>)
 SYMBOL(legendrel, std::, <cmath>)
 SYMBOL(length_error, std::, <stdexcept>)
 SYMBOL(lerp, std::, <cmath>)
 SYMBOL(less, std::, <functional>)
 SYMBOL(less_equal, std::, <functional>)
 SYMBOL(lexicographical_compare, std::, <algorithm>)

 SYMBOL(next_permutation, std::, <algorithm>)
 SYMBOL(nextafter, std::, <cmath>)
 SYMBOL(nextafterf, std::, <cmath>)
 SYMBOL(nextafterl, std::, <cmath>)
 SYMBOL(nexttoward, std::, <cmath>)
 SYMBOL(nexttowardf, std::, <cmath>)
 SYMBOL(nexttowardl, std::, <cmath>)
 SYMBOL(noboolalpha, std::, <ios>)
+SYMBOL(noboolalpha, std::, <iostream>)
 SYMBOL(noemit_on_flush, std::, <ostream>)
+SYMBOL(noemit_on_flush, std::, <iostream>)
 SYMBOL(none_of, std::, <algorithm>)
 SYMBOL(noop_coroutine, std::, <coroutine>)
 SYMBOL(noop_coroutine_handle, std::, <coroutine>)
 SYMBOL(noop_coroutine_promise, std::, <coroutine>)
 SYMBOL(norm, std::, <complex>)
 SYMBOL(normal_distribution, std::, <random>)
 SYMBOL(noshowbase, std::, <ios>)
+SYMBOL(noshowbase, std::, <iostream>)
 SYMBOL(noshowpoint, std::, <ios>)
+SYMBOL(noshowpoint, std::, <iostream>)
 SYMBOL(noshowpos, std::, <ios>)
+SYMBOL(noshowpos, std::, <iostream>)
 SYMBOL(noskipws, std::, <ios>)
+SYMBOL(noskipws, std::, <iostream>)
 SYMBOL(nostopstate, std::, <stop_token>)
 SYMBOL(nostopstate_t, std::, <stop_token>)
 SYMBOL(not_equal_to, std::, <functional>)
 SYMBOL(not_fn, std::, <functional>)
 SYMBOL(nothrow, std::, <new>)
 SYMBOL(nothrow_t, std::, <new>)
 SYMBOL(notify_all_at_thread_exit, std::, <condition_variable>)
 SYMBOL(nounitbuf, std::, <ios>)
+SYMBOL(nounitbuf, std::, <iostream>)
 SYMBOL(nouppercase, std::, <ios>)
+SYMBOL(nouppercase, std::, <iostream>)
 SYMBOL(nth_element, std::, <algorithm>)
 SYMBOL(nullopt, std::, <optional>)
 SYMBOL(nullopt_t, std::, <optional>)
 SYMBOL(nullptr_t, std::, <cstddef>)
 SYMBOL(num_get, std::, <locale>)
 SYMBOL(num_put, std::, <locale>)
 SYMBOL(numeric_limits, std::, <limits>)
 SYMBOL(numpunct, std::, <locale>)
 SYMBOL(numpunct_byname, std::, <locale>)
 SYMBOL(oct, std::, <ios>)
+SYMBOL(oct, std::, <iostream>)
 SYMBOL(ofstream, std::, <fstream>)
+SYMBOL(ofstream, std::, <iosfwd>)
 SYMBOL(once_flag, std::, <mutex>)
 SYMBOL(optional, std::, <optional>)
 SYMBOL(ospanstream, std::, <spanstream>)
+SYMBOL(ospanstream, std::, <iosfwd>)
 SYMBOL(ostream, std::, <ostream>)
+SYMBOL(ostream, std::, <iostream>)
+SYMBOL(ostream, std::, <iosfwd>)
 SYMBOL(ostream_iterator, std::, <iterator>)
 SYMBOL(ostreambuf_iterator, std::, <iterator>)
+SYMBOL(ostreambuf_iterator, std::, <iosfwd>)
 SYMBOL(ostringstream, std::, <sstream>)
+SYMBOL(ostringstream, std::, <iosfwd>)
 SYMBOL(ostrstream, std::, <strstream>)
 SYMBOL(osyncstream, std::, <syncstream>)
+SYMBOL(osyncstream, std::, <iosfwd>)
 SYMBOL(out_of_range, std::, <stdexcept>)
 SYMBOL(out_ptr, std::, <memory>)
 SYMBOL(out_ptr_t, std::, <memory>)
 SYMBOL(output_iterator, std::, <iterator>)
 SYMBOL(output_iterator_tag, std::, <iterator>)
 SYMBOL(overflow_error, std::, <stdexcept>)
 SYMBOL(owner_less, std::, <memory>)
 SYMBOL(packaged_task, std::, <future>)

 SYMBOL(reverse, std::, <algorithm>)
 SYMBOL(reverse_copy, std::, <algorithm>)
 SYMBOL(reverse_iterator, std::, <iterator>)
 SYMBOL(rewind, std::, <cstdio>)
 SYMBOL(riemann_zeta, std::, <cmath>)
 SYMBOL(riemann_zetaf, std::, <cmath>)
 SYMBOL(riemann_zetal, std::, <cmath>)
 SYMBOL(right, std::, <ios>)
+SYMBOL(right, std::, <iostream>)
 SYMBOL(rint, std::, <cmath>)
 SYMBOL(rintf, std::, <cmath>)
 SYMBOL(rintl, std::, <cmath>)
 SYMBOL(rotate, std::, <algorithm>)
 SYMBOL(rotate_copy, std::, <algorithm>)
 SYMBOL(rotl, std::, <bit>)
 SYMBOL(rotr, std::, <bit>)
 SYMBOL(round, std::, <cmath>)

 SYMBOL(scalbln, std::, <cmath>)
 SYMBOL(scalblnf, std::, <cmath>)
 SYMBOL(scalblnl, std::, <cmath>)
 SYMBOL(scalbn, std::, <cmath>)
 SYMBOL(scalbnf, std::, <cmath>)
 SYMBOL(scalbnl, std::, <cmath>)
 SYMBOL(scanf, std::, <cstdio>)
 SYMBOL(scientific, std::, <ios>)
+SYMBOL(scientific, std::, <iostream>)
 SYMBOL(scoped_allocator_adaptor, std::, <scoped_allocator>)
 SYMBOL(scoped_lock, std::, <mutex>)
 SYMBOL(search, std::, <algorithm>)
 SYMBOL(search_n, std::, <algorithm>)
 SYMBOL(seed_seq, std::, <random>)
 SYMBOL(semiregular, std::, <concepts>)
 SYMBOL(sentinel_for, std::, <iterator>)
 SYMBOL(set, std::, <set>)

 SYMBOL(shared_future, std::, <future>)
 SYMBOL(shared_lock, std::, <shared_mutex>)
 SYMBOL(shared_mutex, std::, <shared_mutex>)
 SYMBOL(shared_ptr, std::, <memory>)
 SYMBOL(shared_timed_mutex, std::, <shared_mutex>)
 SYMBOL(shift_left, std::, <algorithm>)
 SYMBOL(shift_right, std::, <algorithm>)
 SYMBOL(showbase, std::, <ios>)
+SYMBOL(showbase, std::, <iostream>)
 SYMBOL(showpoint, std::, <ios>)
+SYMBOL(showpoint, std::, <iostream>)
 SYMBOL(showpos, std::, <ios>)
+SYMBOL(showpos, std::, <iostream>)
 SYMBOL(shuffle, std::, <algorithm>)
 SYMBOL(shuffle_order_engine, std::, <random>)
 SYMBOL(sig_atomic_t, std::, <csignal>)
 SYMBOL(signal, std::, <csignal>)
 SYMBOL(signbit, std::, <cmath>)
 SYMBOL(signed_integral, std::, <concepts>)
 SYMBOL(sin, std::, <cmath>)
 SYMBOL(sinf, std::, <cmath>)
 SYMBOL(sinh, std::, <cmath>)
 SYMBOL(sinhf, std::, <cmath>)
 SYMBOL(sinhl, std::, <cmath>)
 SYMBOL(sinl, std::, <cmath>)
 SYMBOL(sized_sentinel_for, std::, <iterator>)
 SYMBOL(skipws, std::, <ios>)
+SYMBOL(skipws, std::, <iostream>)
 SYMBOL(slice, std::, <valarray>)
 SYMBOL(slice_array, std::, <valarray>)
 SYMBOL(smatch, std::, <regex>)
 SYMBOL(snprintf, std::, <cstdio>)
 SYMBOL(sort, std::, <algorithm>)
 SYMBOL(sort_heap, std::, <algorithm>)
 SYMBOL(sortable, std::, <iterator>)
 SYMBOL(source_location, std::, <source_location>)
 SYMBOL(span, std::, <span>)
 SYMBOL(spanbuf, std::, <spanstream>)
+SYMBOL(spanbuf, std::, <iosfwd>)
 SYMBOL(spanstream, std::, <spanstream>)
+SYMBOL(spanstream, std::, <iosfwd>)
 SYMBOL(sph_bessel, std::, <cmath>)
 SYMBOL(sph_besself, std::, <cmath>)
 SYMBOL(sph_bessell, std::, <cmath>)
 SYMBOL(sph_legendre, std::, <cmath>)
 SYMBOL(sph_legendref, std::, <cmath>)
 SYMBOL(sph_legendrel, std::, <cmath>)
 SYMBOL(sph_neumann, std::, <cmath>)
 SYMBOL(sph_neumannf, std::, <cmath>)

 SYMBOL(stoull, std::, <string>)
 SYMBOL(strcat, std::, <cstring>)
 SYMBOL(strchr, std::, <cstring>)
 SYMBOL(strcmp, std::, <cstring>)
 SYMBOL(strcoll, std::, <cstring>)
 SYMBOL(strcpy, std::, <cstring>)
 SYMBOL(strcspn, std::, <cstring>)
 SYMBOL(streambuf, std::, <streambuf>)
+SYMBOL(streambuf, std::, <iostream>)
+SYMBOL(streambuf, std::, <iosfwd>)
 SYMBOL(streamoff, std::, <ios>)
+SYMBOL(streamoff, std::, <iostream>)
+SYMBOL(streampos, std::, <iosfwd>)
 SYMBOL(streampos, std::, <iosfwd>)
 SYMBOL(streamsize, std::, <ios>)
+SYMBOL(streamsize, std::, <iostream>)
 SYMBOL(strerror, std::, <cstring>)
 SYMBOL(strftime, std::, <ctime>)
 SYMBOL(strict_weak_order, std::, <concepts>)
 SYMBOL(string, std::, <string>)
 SYMBOL(string_view, std::, <string_view>)
 SYMBOL(stringbuf, std::, <sstream>)
+SYMBOL(stringbuf, std::, <iosfwd>)
 SYMBOL(stringstream, std::, <sstream>)
+SYMBOL(stringstream, std::, <iosfwd>)
 SYMBOL(strlen, std::, <cstring>)
 SYMBOL(strncat, std::, <cstring>)
 SYMBOL(strncmp, std::, <cstring>)
 SYMBOL(strncpy, std::, <cstring>)
 SYMBOL(strong_order, std::, <compare>)
 SYMBOL(strong_ordering, std::, <compare>)
 SYMBOL(strpbrk, std::, <cstring>)
 SYMBOL(strrchr, std::, <cstring>)

 SYMBOL(suspend_always, std::, <coroutine>)
 SYMBOL(suspend_never, std::, <coroutine>)
 SYMBOL(swap_ranges, std::, <algorithm>)
 SYMBOL(swappable, std::, <concepts>)
 SYMBOL(swappable_with, std::, <concepts>)
 SYMBOL(swprintf, std::, <cwchar>)
 SYMBOL(swscanf, std::, <cwchar>)
 SYMBOL(syncbuf, std::, <syncstream>)
+SYMBOL(syncbuf, std::, <iosfwd>)
 SYMBOL(system, std::, <cstdlib>)
 SYMBOL(system_category, std::, <system_error>)
 SYMBOL(system_error, std::, <system_error>)
 SYMBOL(tan, std::, <cmath>)
 SYMBOL(tanf, std::, <cmath>)
 SYMBOL(tanh, std::, <cmath>)
 SYMBOL(tanhf, std::, <cmath>)
 SYMBOL(tanhl, std::, <cmath>)

 SYMBOL(tuple_cat, std::, <tuple>)
 SYMBOL(tuple_element_t, std::, <tuple>)
 SYMBOL(tuple_size_v, std::, <tuple>)
 SYMBOL(type_identity, std::, <type_traits>)
 SYMBOL(type_identity_t, std::, <type_traits>)
 SYMBOL(type_index, std::, <typeindex>)
 SYMBOL(type_info, std::, <typeinfo>)
 SYMBOL(u16streampos, std::, <iosfwd>)
+SYMBOL(u16streampos, std::, <iosfwd>)
 SYMBOL(u16string, std::, <string>)
 SYMBOL(u16string_view, std::, <string_view>)
 SYMBOL(u32streampos, std::, <iosfwd>)
+SYMBOL(u32streampos, std::, <iosfwd>)
 SYMBOL(u32string, std::, <string>)
 SYMBOL(u32string_view, std::, <string_view>)
 SYMBOL(u8streampos, std::, <iosfwd>)
+SYMBOL(u8streampos, std::, <iosfwd>)
 SYMBOL(u8string, std::, <string>)
 SYMBOL(u8string_view, std::, <string_view>)
 SYMBOL(uint16_t, std::, <cstdint>)
 SYMBOL(uint32_t, std::, <cstdint>)
 SYMBOL(uint64_t, std::, <cstdint>)
 SYMBOL(uint8_t, std::, <cstdint>)
 SYMBOL(uint_fast16_t, std::, <cstdint>)
 SYMBOL(uint_fast32_t, std::, <cstdint>)

 SYMBOL(uninitialized_move_n, std::, <memory>)
 SYMBOL(uninitialized_value_construct, std::, <memory>)
 SYMBOL(uninitialized_value_construct_n, std::, <memory>)
 SYMBOL(unique, std::, <algorithm>)
 SYMBOL(unique_copy, std::, <algorithm>)
 SYMBOL(unique_lock, std::, <mutex>)
 SYMBOL(unique_ptr, std::, <memory>)
 SYMBOL(unitbuf, std::, <ios>)
+SYMBOL(unitbuf, std::, <iostream>)
 SYMBOL(unordered_map, std::, <unordered_map>)
 SYMBOL(unordered_multimap, std::, <unordered_map>)
 SYMBOL(unordered_multiset, std::, <unordered_set>)
 SYMBOL(unordered_set, std::, <unordered_set>)
 SYMBOL(unreachable, std::, <utility>)
 SYMBOL(unreachable_sentinel, std::, <iterator>)
 SYMBOL(unreachable_sentinel_t, std::, <iterator>)
 SYMBOL(unsigned_integral, std::, <concepts>)
 SYMBOL(upper_bound, std::, <algorithm>)
 SYMBOL(uppercase, std::, <ios>)
+SYMBOL(uppercase, std::, <iostream>)
 SYMBOL(use_facet, std::, <locale>)
 SYMBOL(uses_allocator, std::, <memory>)
 SYMBOL(uses_allocator_construction_args, std::, <memory>)
 SYMBOL(uses_allocator_v, std::, <memory>)
 SYMBOL(va_list, std::, <cstdarg>)
 SYMBOL(valarray, std::, <valarray>)
 SYMBOL(variant, std::, <variant>)
 SYMBOL(variant_alternative, std::, <variant>)

 SYMBOL(wctype, std::, <cwctype>)
 SYMBOL(wctype_t, std::, <cwctype>)
 SYMBOL(weak_order, std::, <compare>)
 SYMBOL(weak_ordering, std::, <compare>)
 SYMBOL(weak_ptr, std::, <memory>)
 SYMBOL(weakly_incrementable, std::, <iterator>)
 SYMBOL(weibull_distribution, std::, <random>)
 SYMBOL(wfilebuf, std::, <streambuf>)
+SYMBOL(wfilebuf, std::, <iostream>)
+SYMBOL(wfilebuf, std::, <iosfwd>)
 SYMBOL(wformat_args, std::, <format>)
 SYMBOL(wformat_context, std::, <format>)
 SYMBOL(wformat_parse_context, std::, <format>)
 SYMBOL(wfstream, std::, <fstream>)
+SYMBOL(wfstream, std::, <iosfwd>)
 SYMBOL(wifstream, std::, <fstream>)
+SYMBOL(wifstream, std::, <iosfwd>)
 SYMBOL(wios, std::, <ios>)
+SYMBOL(wios, std::, <iostream>)
+SYMBOL(wios, std::, <iosfwd>)
 SYMBOL(wiostream, std::, <istream>)
+SYMBOL(wiostream, std::, <iostream>)
+SYMBOL(wiostream, std::, <iosfwd>)
 SYMBOL(wispanstream, std::, <spanstream>)
+SYMBOL(wispanstream, std::, <iosfwd>)
 SYMBOL(wistream, std::, <istream>)
+SYMBOL(wistream, std::, <iostream>)
+SYMBOL(wistream, std::, <iosfwd>)
 SYMBOL(wistringstream, std::, <sstream>)
+SYMBOL(wistringstream, std::, <iosfwd>)
 SYMBOL(wmemchr, std::, <cwchar>)
 SYMBOL(wmemcmp, std::, <cwchar>)
 SYMBOL(wmemcpy, std::, <cwchar>)
 SYMBOL(wmemmove, std::, <cwchar>)
 SYMBOL(wmemset, std::, <cwchar>)
 SYMBOL(wofstream, std::, <fstream>)
+SYMBOL(wofstream, std::, <iosfwd>)
 SYMBOL(wospanstream, std::, <spanstream>)
+SYMBOL(wospanstream, std::, <iosfwd>)
 SYMBOL(wostream, std::, <ostream>)
+SYMBOL(wostream, std::, <iostream>)
+SYMBOL(wostream, std::, <iosfwd>)
 SYMBOL(wostringstream, std::, <sstream>)
+SYMBOL(wostringstream, std::, <iosfwd>)
 SYMBOL(wosyncstream, std::, <syncstream>)
+SYMBOL(wosyncstream, std::, <iosfwd>)
 SYMBOL(wprintf, std::, <cwchar>)
 SYMBOL(wregex, std::, <regex>)
 SYMBOL(ws, std::, <istream>)
+SYMBOL(ws, std::, <iostream>)
 SYMBOL(wscanf, std::, <cwchar>)
 SYMBOL(wsmatch, std::, <regex>)
 SYMBOL(wspanbuf, std::, <spanstream>)
+SYMBOL(wspanbuf, std::, <iosfwd>)
 SYMBOL(wspanstream, std::, <spanstream>)
+SYMBOL(wspanstream, std::, <iosfwd>)
 SYMBOL(wsregex_iterator, std::, <regex>)
 SYMBOL(wsregex_token_iterator, std::, <regex>)
 SYMBOL(wssub_match, std::, <regex>)
 SYMBOL(wstreambuf, std::, <streambuf>)
+SYMBOL(wstreambuf, std::, <iostream>)
+SYMBOL(wstreambuf, std::, <iosfwd>)
+SYMBOL(wstreampos, std::, <iosfwd>)
 SYMBOL(wstreampos, std::, <iosfwd>)
 SYMBOL(wstring, std::, <string>)
 SYMBOL(wstring_convert, std::, <locale>)
 SYMBOL(wstring_view, std::, <string_view>)
 SYMBOL(wstringbuf, std::, <sstream>)
+SYMBOL(wstringbuf, std::, <iosfwd>)
 SYMBOL(wstringstream, std::, <sstream>)
+SYMBOL(wstringstream, std::, <iosfwd>)
 SYMBOL(wsyncbuf, std::, <syncstream>)
+SYMBOL(wsyncbuf, std::, <iosfwd>)
 SYMBOL(yocto, std::, <ratio>)
 SYMBOL(yotta, std::, <ratio>)
 SYMBOL(zepto, std::, <ratio>)
 SYMBOL(zetta, std::, <ratio>)
 SYMBOL(April, std::chrono::, <chrono>)
 SYMBOL(August, std::chrono::, <chrono>)
 SYMBOL(December, std::chrono::, <chrono>)
 SYMBOL(February, std::chrono::, <chrono>)

 SYMBOL(const_mem_fun_t, std::, <functional>)
 SYMBOL(declare_no_pointers, std::, <memory>)
 SYMBOL(declare_reachable, std::, <memory>)
 SYMBOL(get_pointer_safety, std::, <memory>)
 SYMBOL(get_temporary_buffer, std::, <memory>)
 SYMBOL(get_unexpected, std::, <exception>)
 SYMBOL(gets, std::, <cstdio>)
 SYMBOL(io_state, std::, <ios>)
+SYMBOL(io_state, std::, <iostream>)
 SYMBOL(is_literal_type, std::, <type_traits>)
 SYMBOL(is_literal_type_v, std::, <type_traits>)
 SYMBOL(mem_fun, std::, <functional>)
 SYMBOL(mem_fun1_ref_t, std::, <functional>)
 SYMBOL(mem_fun1_t, std::, <functional>)
 SYMBOL(mem_fun_ref, std::, <functional>)
 SYMBOL(mem_fun_ref_t, std::, <functional>)
 SYMBOL(mem_fun_t, std::, <functional>)
 SYMBOL(not1, std::, <functional>)
 SYMBOL(not2, std::, <functional>)
 SYMBOL(open_mode, std::, <ios>)
+SYMBOL(open_mode, std::, <iostream>)
 SYMBOL(pointer_safety, std::, <memory>)
 SYMBOL(preferred, std::, <memory>)
 SYMBOL(ptr_fun, std::, <functional>)
 SYMBOL(random_shuffle, std::, <algorithm>)
 SYMBOL(raw_storage_iterator, std::, <memory>)
 SYMBOL(result_of, std::, <type_traits>)
 SYMBOL(result_of_t, std::, <type_traits>)
 SYMBOL(return_temporary_buffer, std::, <memory>)
 SYMBOL(seek_dir, std::, <ios>)
+SYMBOL(seek_dir, std::, <iostream>)
 SYMBOL(set_unexpected, std::, <exception>)
 SYMBOL(strict, std::, <memory>)
 SYMBOL(unary_function, std::, <functional>)
 SYMBOL(unary_negate, std::, <functional>)
 SYMBOL(uncaught_exception, std::, <exception>)
 SYMBOL(undeclare_no_pointers, std::, <memory>)
 SYMBOL(undeclare_reachable, std::, <memory>)
 SYMBOL(unexpected_handler, std::, <exception>)

clang/tools/include-mapping/gen_std.py

 
 
 import cppreference_parser
 import argparse
 import datetime
 import os
 import sys
 
+
 CODE_PREFIX = """\
 //===-- gen_std.py generated file -------------------------------*- C++ -*-===//
 //
 // Used to build a lookup table (qualified names => include headers) for %s
 // Standard Library symbols.
 //
 // This file was generated automatically by
 // clang/tools/include-mapping/gen_std.py, DO NOT EDIT!
parser.add_argument('-cppreference', metavar='PATH',
                       required=True
                      )
   parser.add_argument('-symbols',
                       default='cpp',
                       help='Generate c or cpp (removed) symbols. One of {cpp, c, cpp_removed}.',
                       required=True) 
   return parser.parse_args()
 
+def AdditionalHeadersForIOSymbols(symbol):
+  # IO-related symbols declared in the <iosfwd> header, per C++
+  # [iosfwd.syn 31.3.1]:
+  iosfwd_symbols = [
+      'basic_ios',
+      'basic_streambuf',
+      'basic_istream',
+      'basic_ostream',
+      'basic_iostream',
+
+      'basic_stringbuf',
+      'basic_istringstream',
+      'basic_ostringstream',
+      'basic_stringstream',
+
+      'basic_spanbuf',
+      'basic_ispanstream',
+      'basic_ospanstream',
+      'basic_spanstream',
+
+      'basic_filebuf',
+      'basic_ifstream',
+      'basic_ofstream',
+      'basic_fstream',
+
+      'basic_syncbuf',
+      'basic_osyncstream',
+
+      'istreambuf_iterator',
+      'ostreambuf_iterator',
+
+      'ios',
+      'wios',
+
+      'streambuf',
+      'istream',
+      'ostream',
+      'iostream',
+
+      'stringbuf',
+      'istringstream',
+      'ostringstream',
+      'stringstream',
+
+      'spanbuf',
+      'ispanstream',
+      'ospanstream',
+      'spanstream',
+
+      'filebuf',
+      'ifstream',
+      'ofstream',
+      'fstream',
+
+      'syncbuf',
+      'osyncstream',
+
+      'wstreambuf',
+      'wistream',
+      'wostream',
+      'wiostream',
+
+      'wstringbuf',
+      'wistringstream',
+      'wostringstream',
+      'wstringstream',
+
+      'wspanbuf',
+      'wispanstream',
+      'wospanstream',
+      'wspanstream',
+
+      'wfilebuf',
+      'wifstream',
+      'wofstream',
+      'wfstream',
+
+      'wsyncbuf',
+      'wosyncstream',
+
+      'fpos',
+      'streampos',
+      'wstreampos',
+      'u8streampos',
+      'u16streampos',
+      'u32streampos',
+  ]
+  assert(len(symbol.headers) == 1)
+  sym_header = symbol.headers[0]
+  headers = []
+  # <iostream> is preferred than <iosfwd>
+
+  # <iostream> is an alternative of <streambuf>, <istream>, <ostream>, <ios>.
+  # per C++ [iostream.syn 31.4.1]
+  if sym_header in ["<ios>", "<istream>", "<ostream>", "<streambuf>"]:
+    headers.append("<iostream>")
+
+  if symbol.name in iosfwd_symbols:
+    headers.append("<iosfwd>")
+
+  return headers
+
 
 def main():
   args = ParseArg()
   if args.symbols == 'cpp':
     page_root = os.path.join(args.cppreference, "en", "cpp")
     symbol_index_root = os.path.join(page_root, "symbol_index")
     parse_pages =  [
       (page_root, "symbol_index.html", "std::"),
def main():
   # so we use the modified time of the symbol_index.html as the version.
   index_page_path = os.path.join(page_root, "index.html")
   cppreference_modified_date = datetime.datetime.fromtimestamp(
     os.stat(index_page_path).st_mtime).strftime('%Y-%m-%d')
   print(CODE_PREFIX % (args.symbols.upper(), cppreference_modified_date))
   for symbol in symbols:
     if len(symbol.headers) == 1:
       # SYMBOL(unqualified_name, namespace, header)
+      symbol.headers.extend(AdditionalHeadersForIOSymbols(symbol))
+      for header in symbol.headers:
         print("SYMBOL(%s, %s, %s)" % (symbol.name, symbol.namespace,
-                                    symbol.headers[0]))
+                                      header))
     elif len(symbol.headers) == 0:
       sys.stderr.write("No header found for symbol %s\n" % symbol.name)
     else:
       # FIXME: support symbols with multiple headers (e.g. std::move).
       sys.stderr.write("Ambiguous header for symbol %s: %s\n" % (
           symbol.name, ', '.join(symbol.headers)))
 
 
 if __name__ == '__main__':
   main()