Update std symbol mapping to v20230810; Move assertion to detect all ungrouped mappings

Author: vvd170501

clang/lib/Tooling/Inclusions/Stdlib/StandardLibrary.cpp

@@ -115,15 +115,17 @@ static int initialize(Lang Language) {
       NSLen = 0;
     }
 
-    if (SymIndex >= 0 &&
-        Mapping->SymbolNames[SymIndex].qualifiedName() == QName) {
-      // Not a new symbol, use the same index.
+    if (SymIndex > 0) {
       assert(llvm::none_of(llvm::ArrayRef(Mapping->SymbolNames, SymIndex),
                            [&QName](const SymbolHeaderMapping::SymbolName &S) {
                              return S.qualifiedName() == QName;
                            }) &&
              "The symbol has been added before, make sure entries in the .inc "
              "file are grouped by symbol name!");
+    }
+    if (SymIndex >= 0 &&
+        Mapping->SymbolNames[SymIndex].qualifiedName() == QName) {
+      // Not a new symbol, use the same index.
     } else {
       // First symbol or new symbol, increment next available index.
       ++SymIndex;

clang/lib/Tooling/Inclusions/Stdlib/StdSpecialSymbolMap.inc

@@ -233,6 +233,23 @@ SYMBOL(ssize, std::, <unordered_map>)
 SYMBOL(ssize, std::, <unordered_set>)
 SYMBOL(ssize, std::, <vector>)
 
+// Overloads for different containers, actual header depends on function arg.
+// Probably should use a special handler, like with std::move.
+SYMBOL(erase, std::, <vector>)
+SYMBOL(erase, std::, <deque>)
+SYMBOL(erase, std::, <string>)
+SYMBOL(erase, std::, <list>)
+SYMBOL(erase, std::, <forward_list>)
+SYMBOL(erase_if, std::, <vector>)
+SYMBOL(erase_if, std::, <string>)
+SYMBOL(erase_if, std::, <list>)
+SYMBOL(erase_if, std::, <forward_list>)
+SYMBOL(erase_if, std::, <map>)
+SYMBOL(erase_if, std::, <unordered_map>)
+SYMBOL(erase_if, std::, <set>)
+SYMBOL(erase_if, std::, <deque>)
+SYMBOL(erase_if, std::, <unordered_set>)
+
 // Add headers for generic integer-type abs.
 // Ignore other variants (std::complex, std::valarray, std::intmax_t)
 SYMBOL(abs, std::, <cstdlib>)
@@ -242,9 +259,78 @@ SYMBOL(abs, None, <stdlib.h>)
 SYMBOL(abs, None, <cmath>)
 SYMBOL(abs, None, <math.h>)
 
-// Only add headers for the generic atomic template.
+// Same as abs - ignore variants (std::complex, std::valarray)
+SYMBOL(acos, std::, <cmath>)
+SYMBOL(acos, None, <cmath>)
+SYMBOL(acos, None, <math.h>)
+SYMBOL(acosh, std::, <cmath>)
+SYMBOL(acosh, None, <cmath>)
+SYMBOL(acosh, None, <math.h>)
+SYMBOL(asin, std::, <cmath>)
+SYMBOL(asin, None, <cmath>)
+SYMBOL(asin, None, <math.h>)
+SYMBOL(asinh, std::, <cmath>)
+SYMBOL(asinh, None, <cmath>)
+SYMBOL(asinh, None, <math.h>)
+SYMBOL(atan, std::, <cmath>)
+SYMBOL(atan, None, <cmath>)
+SYMBOL(atan, None, <math.h>)
+SYMBOL(atan2, std::, <cmath>)
+SYMBOL(atan2, None, <cmath>)
+SYMBOL(atan2, None, <math.h>)
+SYMBOL(atanh, std::, <cmath>)
+SYMBOL(atanh, None, <cmath>)
+SYMBOL(atanh, None, <math.h>)
+SYMBOL(cos, std::, <cmath>)
+SYMBOL(cos, None, <cmath>)
+SYMBOL(cos, None, <math.h>)
+SYMBOL(cosh, std::, <cmath>)
+SYMBOL(cosh, None, <cmath>)
+SYMBOL(cosh, None, <math.h>)
+SYMBOL(exp, std::, <cmath>)
+SYMBOL(exp, None, <cmath>)
+SYMBOL(exp, None, <math.h>)
+SYMBOL(log, std::, <cmath>)
+SYMBOL(log, None, <cmath>)
+SYMBOL(log, None, <math.h>)
+SYMBOL(log10, std::, <cmath>)
+SYMBOL(log10, None, <cmath>)
+SYMBOL(log10, None, <math.h>)
+SYMBOL(pow, std::, <cmath>)
+SYMBOL(pow, None, <cmath>)
+SYMBOL(pow, None, <math.h>)
+SYMBOL(sin, std::, <cmath>)
+SYMBOL(sin, None, <cmath>)
+SYMBOL(sin, None, <math.h>)
+SYMBOL(sinh, std::, <cmath>)
+SYMBOL(sinh, None, <cmath>)
+SYMBOL(sinh, None, <math.h>)
+SYMBOL(sqrt, std::, <cmath>)
+SYMBOL(sqrt, None, <cmath>)
+SYMBOL(sqrt, None, <math.h>)
+SYMBOL(tan, std::, <cmath>)
+SYMBOL(tan, None, <cmath>)
+SYMBOL(tan, None, <math.h>)
+SYMBOL(tanh, std::, <cmath>)
+SYMBOL(tanh, None, <cmath>)
+SYMBOL(tanh, None, <math.h>)
+
+// Only add headers for the generic atomic template
+// and atomic_* template functions.
 // Ignore variants (std::weak_ptr, std::shared_ptr).
 SYMBOL(atomic, std::, <atomic>)
+SYMBOL(atomic_compare_exchange_strong, std::, <atomic>)
+SYMBOL(atomic_compare_exchange_strong_explicit, std::, <atomic>)
+SYMBOL(atomic_compare_exchange_weak, std::, <atomic>)
+SYMBOL(atomic_compare_exchange_weak_explicit, std::, <atomic>)
+SYMBOL(atomic_exchange, std::, <atomic>)
+SYMBOL(atomic_exchange_explicit, std::, <atomic>)
+SYMBOL(atomic_is_lock_free, std::, <atomic>)
+SYMBOL(atomic_load, std::, <atomic>)
+SYMBOL(atomic_load_explicit, std::, <atomic>)
+SYMBOL(atomic_store, std::, <atomic>)
+SYMBOL(atomic_store_explicit, std::, <atomic>)
+
 // atomic_* family symbols. <stdatomic.h> is for C compatibility.
 SYMBOL(atomic_bool, std::, <atomic>)
 SYMBOL(atomic_bool, None, <stdatomic.h>)
@@ -355,18 +441,49 @@ SYMBOL(make_error_condition, std::, /*no headers*/)
 
 // cppreference symbol index page was missing these symbols.
 // Remove them when the cppreference offline archive catches up.
-SYMBOL(index_sequence, std::, <utility>)
-SYMBOL(index_sequence_for, std::, <utility>)
-SYMBOL(make_index_sequence, std::, <utility>)
-SYMBOL(make_integer_sequence, std::, <utility>)
+SYMBOL(add_pointer_t, std::, <type_traits>)
+SYMBOL(regular_invocable, std::, <concepts>)
 
 // Symbols missing from the generated symbol map as reported by users.
 // Remove when the generator starts producing them.
-SYMBOL(make_any, std::, <any>)
-SYMBOL(any_cast, std::, <any>)
 SYMBOL(div, std::, <cstdlib>)
 SYMBOL(abort, std::, <cstdlib>)
 
+// Class declaration was broken, header wasn't rendered.
+// Remove when the cppreference offline archive catches up.
+SYMBOL(month_weekday, std::chrono::, <chrono>)
+
+// FIXME Ambiguous symbols
+// Not sure if they should be updated, this is copied from v20220730
+SYMBOL(filebuf, std::, <streambuf>)
+SYMBOL(filebuf, std::, <iostream>)
+SYMBOL(filebuf, std::, <iosfwd>)
+SYMBOL(istream, std::, <istream>)
+SYMBOL(istream, std::, <iostream>)
+SYMBOL(istream, std::, <iosfwd>)
+SYMBOL(ostream, std::, <ostream>)
+SYMBOL(ostream, std::, <iostream>)
+SYMBOL(ostream, std::, <iosfwd>)
+SYMBOL(streampos, std::, <iosfwd>)
+SYMBOL(streampos, std::, <iosfwd>)
+SYMBOL(u16streampos, std::, <iosfwd>)
+SYMBOL(u16streampos, std::, <iosfwd>)
+SYMBOL(u32streampos, std::, <iosfwd>)
+SYMBOL(u32streampos, std::, <iosfwd>)
+SYMBOL(u8streampos, std::, <iosfwd>)
+SYMBOL(u8streampos, std::, <iosfwd>)
+SYMBOL(wfilebuf, std::, <streambuf>)
+SYMBOL(wfilebuf, std::, <iostream>)
+SYMBOL(wfilebuf, std::, <iosfwd>)
+SYMBOL(wistream, std::, <istream>)
+SYMBOL(wistream, std::, <iostream>)
+SYMBOL(wistream, std::, <iosfwd>)
+SYMBOL(wostream, std::, <ostream>)
+SYMBOL(wostream, std::, <iostream>)
+SYMBOL(wostream, std::, <iosfwd>)
+SYMBOL(wstreampos, std::, <iosfwd>)
+SYMBOL(wstreampos, std::, <iosfwd>)
+
 // These are C symbols that are not under std namespace.
 SYMBOL(localtime_r, None, <ctime>)
 SYMBOL(localtime_r, None, <time.h>)