[clang] [clang][Sema] Suggest/Hint Standard Library Include File (PR #146227)
via cfe-commits
cfe-commits at lists.llvm.org
Sat Jul 5 03:11:29 PDT 2025
https://github.com/Mr-Anyone updated https://github.com/llvm/llvm-project/pull/146227
>From a2b221035936d4f63c2a6b556f108dab9e191a05 Mon Sep 17 00:00:00 2001
From: Vincent <llvm at viceroygroup.ca>
Date: Sun, 29 Jun 2025 00:03:19 +0800
Subject: [PATCH 1/2] [clang][Sema] Suggest/Hint Standard Library Include File
Clang now tries to suggest and hint standard library include file by emitting
the following.
```
4 | std::unordered_map<std::string, std::string> map;
| ^~~~~~~~~~~~~
main.cpp:4:10: note: maybe try to include <unordered_map>; 'std::unordered_map' is defined in <unordered_map>
main.cpp:4:10: note: 'std::unordered_map' is a c++11 feature
main.cpp:4:42: note: maybe try to include <string>; 'std::string' is defined in <string>
```
This works for both C and C++.
fixes #120388
---
clang/docs/ReleaseNotes.rst | 1 +
.../clang/Basic/DiagnosticSemaKinds.td | 4 +
clang/include/clang/Sema/Sema.h | 10 +
.../Tooling/Inclusions/StandardLibrary.h | 22 +
clang/lib/Parse/ParseExprCXX.cpp | 14 +
clang/lib/Sema/CMakeLists.txt | 1 +
clang/lib/Sema/SemaDecl.cpp | 50 +
clang/lib/Sema/SemaExpr.cpp | 6 +
.../Tooling/Inclusions/Stdlib/CSymbolMap.inc | 1129 ++---
.../Inclusions/Stdlib/StandardLibrary.cpp | 60 +-
.../Inclusions/Stdlib/StdSpecialSymbolMap.inc | 5 -
.../Inclusions/Stdlib/StdSymbolMap.inc | 4155 ++++++++---------
clang/test/Headers/stddef.c | 46 +-
clang/test/Headers/stddefneeds.c | 80 +-
clang/test/Headers/stddefneeds.cpp | 20 +-
...mplicit-declared-allocation-functions.cppm | 18 +-
clang/test/Modules/macro-reexport.cpp | 6 +-
clang/test/Modules/stddef.cpp | 4 +-
clang/test/Sema/MicrosoftCompatibility.c | 2 +-
clang/test/Sema/builtin-setjmp.c | 8 +-
.../c23-delayed-typo-correction-crashes.c | 3 +-
clang/test/Sema/implicit-builtin-decl.c | 3 +-
clang/test/Sema/include-suggestion.c | 5 +
.../test/SemaCXX/constructor-initializer.cpp | 2 +-
.../test/SemaCXX/include-suggestions-cxx.cpp | 2458 ++++++++++
.../SemaCXX/no-implicit-builtin-decls.cpp | 2 +-
26 files changed, 5219 insertions(+), 2895 deletions(-)
create mode 100644 clang/test/Sema/include-suggestion.c
create mode 100644 clang/test/SemaCXX/include-suggestions-cxx.cpp
diff --git a/clang/docs/ReleaseNotes.rst b/clang/docs/ReleaseNotes.rst
index bee71cf296ac3..73bf23887b412 100644
--- a/clang/docs/ReleaseNotes.rst
+++ b/clang/docs/ReleaseNotes.rst
@@ -478,6 +478,7 @@ Improvements to Clang's diagnostics
diagnostics. This fixes a bunch of `bool` being printed as `_Bool`, and also
a bunch of HLSL types being printed as their C++ equivalents.
- Clang now consistently quotes expressions in diagnostics.
+- Clang now suggest standard library include path and its associated C++ or C language version.
- When printing types for diagnostics, clang now doesn't suppress the scopes of
template arguments contained within nested names.
- The ``-Wshift-bool`` warning has been added to warn about shifting a boolean. (#GH28334)
diff --git a/clang/include/clang/Basic/DiagnosticSemaKinds.td b/clang/include/clang/Basic/DiagnosticSemaKinds.td
index 5062505cf3c01..1ef776f8d82c5 100644
--- a/clang/include/clang/Basic/DiagnosticSemaKinds.td
+++ b/clang/include/clang/Basic/DiagnosticSemaKinds.td
@@ -5990,6 +5990,10 @@ def err_template_expansion_into_fixed_list : Error<
"template|concept}0">;
def note_parameter_type : Note<
"parameter of type %0 is declared here">;
+def note_standard_lib_include_suggestion : Note<
+ "maybe try to include %0; '%1' is defined in %0">;
+def note_standard_lib_version : Note<
+ "'%0' is a %1 feature">;
// C++11 Variadic Templates
def err_template_param_pack_default_arg : Error<
diff --git a/clang/include/clang/Sema/Sema.h b/clang/include/clang/Sema/Sema.h
index 3fe26f950ad51..644484d076a58 100644
--- a/clang/include/clang/Sema/Sema.h
+++ b/clang/include/clang/Sema/Sema.h
@@ -3613,6 +3613,16 @@ class Sema final : public SemaBase {
ParsedType &SuggestedType,
bool IsTemplateName = false);
+ // Try to suggest the missing standard library include files
+ //
+ // \param SymbolName the symbol name like 'cout'
+ // \param SourceLocation the location of the note being emitted
+ // \param Namespace the namespace that must end with ::, so like 'std::'
+ void NoteStandardIncludes(StringRef SymbolName, SourceLocation IILoc,
+ StringRef Namespace);
+ void NoteStandardIncludes(StringRef SymbolName, SourceLocation IILoc,
+ const CXXScopeSpec *SS);
+
/// Attempt to behave like MSVC in situations where lookup of an unqualified
/// type name has failed in a dependent context. In these situations, we
/// automatically form a DependentTypeName that will retry lookup in a related
diff --git a/clang/include/clang/Tooling/Inclusions/StandardLibrary.h b/clang/include/clang/Tooling/Inclusions/StandardLibrary.h
index 147f505ade058..42bbb5b3f0d8c 100644
--- a/clang/include/clang/Tooling/Inclusions/StandardLibrary.h
+++ b/clang/include/clang/Tooling/Inclusions/StandardLibrary.h
@@ -29,6 +29,27 @@ class NamespaceDecl;
class DeclContext;
namespace tooling {
namespace stdlib {
+enum Version {
+ Unknown,
+
+ // c++ versions
+ CPlusPlusStart,
+ CPlusPlus11,
+ CPlusPlus14,
+ CPlusPlus17,
+ CPlusPlus20,
+ CPlusPlus23,
+ CPlusPlus26,
+ CPlusPlusEnd,
+
+ // c version
+ CStart,
+ C99,
+ C11,
+ CEnd
+};
+
+llvm::StringRef GetAsString(Version Ver);
class Symbol;
enum class Lang { C = 0, CXX, LastValue = CXX };
@@ -85,6 +106,7 @@ class Symbol {
std::optional<Header> header() const;
// Some symbols may be provided by multiple headers.
llvm::SmallVector<Header> headers() const;
+ Version version() const;
private:
Symbol(unsigned ID, Lang Language) : ID(ID), Language(Language) {}
diff --git a/clang/lib/Parse/ParseExprCXX.cpp b/clang/lib/Parse/ParseExprCXX.cpp
index 1ea0cf52933f6..9de0e9ca74c6f 100644
--- a/clang/lib/Parse/ParseExprCXX.cpp
+++ b/clang/lib/Parse/ParseExprCXX.cpp
@@ -226,6 +226,11 @@ bool Parser::ParseOptionalCXXScopeSpecifier(
HasScopeSpecifier = true;
}
+ // If `FailedNestedNameBuilding` is true, attempt to suggest the standard
+ // include file corresponding to the current `FullNamespace` and symbol.
+ std::string FullNamespace = "";
+ bool FailedNesatedNameBuilding = false;
+
// Preferred type might change when parsing qualifiers, we need the original.
auto SavedType = PreferredType;
while (true) {
@@ -454,6 +459,9 @@ bool Parser::ParseOptionalCXXScopeSpecifier(
// We have an identifier followed by a '::'. Lookup this name
// as the name in a nested-name-specifier.
Token Identifier = Tok;
+ FullNamespace += Identifier.getIdentifierInfo()->getName();
+ FullNamespace += "::";
+
SourceLocation IdLoc = ConsumeToken();
assert(Tok.isOneOf(tok::coloncolon, tok::colon) &&
"NextToken() not working properly!");
@@ -465,6 +473,7 @@ bool Parser::ParseOptionalCXXScopeSpecifier(
if (Actions.ActOnCXXNestedNameSpecifier(
getCurScope(), IdInfo, EnteringContext, SS, CorrectionFlagPtr,
OnlyNamespace)) {
+ FailedNesatedNameBuilding = true;
// Identifier is not recognized as a nested name, but we can have
// mistyped '::' instead of ':'.
if (CorrectionFlagPtr && IsCorrectedToColon) {
@@ -554,6 +563,11 @@ bool Parser::ParseOptionalCXXScopeSpecifier(
break;
}
+ if (FailedNesatedNameBuilding && Tok.getKind() == tok::identifier) {
+ Actions.NoteStandardIncludes(Tok.getIdentifierInfo()->getName(),
+ Tok.getLocation(), FullNamespace);
+ }
+
// Even if we didn't see any pieces of a nested-name-specifier, we
// still check whether there is a tilde in this position, which
// indicates a potential pseudo-destructor.
diff --git a/clang/lib/Sema/CMakeLists.txt b/clang/lib/Sema/CMakeLists.txt
index 51e0ee10b080b..ff4f583bdd9bf 100644
--- a/clang/lib/Sema/CMakeLists.txt
+++ b/clang/lib/Sema/CMakeLists.txt
@@ -115,4 +115,5 @@ add_clang_library(clangSema
clangEdit
clangLex
clangSupport
+ clangToolingInclusionsStdlib
)
diff --git a/clang/lib/Sema/SemaDecl.cpp b/clang/lib/Sema/SemaDecl.cpp
index 58b475929cc4f..caf162a3e79c0 100644
--- a/clang/lib/Sema/SemaDecl.cpp
+++ b/clang/lib/Sema/SemaDecl.cpp
@@ -58,10 +58,13 @@
#include "clang/Sema/SemaSwift.h"
#include "clang/Sema/SemaWasm.h"
#include "clang/Sema/Template.h"
+#include "clang/Tooling/Inclusions/StandardLibrary.h"
#include "llvm/ADT/STLForwardCompat.h"
#include "llvm/ADT/SmallPtrSet.h"
#include "llvm/ADT/SmallString.h"
#include "llvm/ADT/StringExtras.h"
+#include "llvm/ADT/StringSwitch.h"
+#include "llvm/Frontend/HLSL/HLSLRootSignature.h"
#include "llvm/Support/SaveAndRestore.h"
#include "llvm/TargetParser/Triple.h"
#include <algorithm>
@@ -804,6 +807,52 @@ void Sema::DiagnoseUnknownTypeName(IdentifierInfo *&II,
assert(SS && SS->isInvalid() &&
"Invalid scope specifier has already been diagnosed");
}
+
+ // don't note standard include files for OpenCL and Objective C
+ if ((getLangOpts().CPlusPlus || getLangOpts().C99) && !getLangOpts().OpenCL &&
+ !getLangOpts().ObjC)
+ NoteStandardIncludes(II->getName(), IILoc, SS);
+}
+
+void Sema::NoteStandardIncludes(StringRef SymbolName, SourceLocation IILoc,
+ StringRef Namespace) {
+ using clang::tooling::stdlib::Lang;
+
+ llvm::StringRef HeaderName = "";
+ tooling::stdlib::Lang LangOption = tooling::stdlib::Lang::C;
+ if (getLangOpts().CPlusPlus)
+ LangOption = clang::tooling::stdlib::Lang::CXX;
+
+ if (auto StdSym =
+ tooling::stdlib::Symbol::named(Namespace, SymbolName, LangOption)) {
+ if (auto Header = StdSym->header()) {
+ HeaderName = Header->name();
+ Diag(IILoc, diag::note_standard_lib_include_suggestion)
+ << HeaderName << (Namespace + SymbolName).str();
+
+ // Noting the C/C++ version as well
+ if (StdSym->version() != tooling::stdlib::Unknown) {
+ llvm::StringRef CPlusPlusVersion =
+ tooling::stdlib::GetAsString(StdSym->version());
+
+ Diag(IILoc, diag::note_standard_lib_version)
+ << (Namespace + SymbolName).str() << CPlusPlusVersion;
+ }
+ }
+ }
+}
+
+void Sema::NoteStandardIncludes(StringRef SymbolName, SourceLocation IILoc,
+ const CXXScopeSpec *SS) {
+ std::string Namespace = "";
+ if (SS) {
+ llvm::raw_string_ostream Stream(Namespace);
+ if (SS->isValid())
+ SS->getScopeRep()->dump(Stream);
+ Stream.flush();
+ }
+
+ NoteStandardIncludes(SymbolName, IILoc, Namespace);
}
/// Determine whether the given result set contains either a type name
@@ -16783,6 +16832,7 @@ NamedDecl *Sema::ImplicitlyDefineFunction(SourceLocation Loc,
}
Diag(Loc, diag_id) << &II;
+ NoteStandardIncludes(II.getName(), Loc, "");
if (Corrected) {
// If the correction is going to suggest an implicitly defined function,
// skip the correction as not being a particularly good idea.
diff --git a/clang/lib/Sema/SemaExpr.cpp b/clang/lib/Sema/SemaExpr.cpp
index 437df742d572b..974d6e00cbf96 100644
--- a/clang/lib/Sema/SemaExpr.cpp
+++ b/clang/lib/Sema/SemaExpr.cpp
@@ -2658,11 +2658,17 @@ bool Sema::DiagnoseEmptyLookup(Scope *S, CXXScopeSpec &SS, LookupResult &R,
if (!SS.isEmpty()) {
Diag(R.getNameLoc(), diag::err_no_member)
<< Name << computeDeclContext(SS, false) << NameRange;
+ NoteStandardIncludes(Name.getAsString(), R.getNameLoc(), &SS);
return true;
}
// Give up, we can't recover.
Diag(R.getNameLoc(), diagnostic) << Name << NameRange;
+
+ // don't note standard include files for OpenCL and Objective C
+ if ((getLangOpts().CPlusPlus || getLangOpts().C99) && !getLangOpts().OpenCL &&
+ !getLangOpts().ObjC)
+ NoteStandardIncludes(Name.getAsString(), R.getNameLoc(), /*Namespace=*/"");
return true;
}
diff --git a/clang/lib/Tooling/Inclusions/Stdlib/CSymbolMap.inc b/clang/lib/Tooling/Inclusions/Stdlib/CSymbolMap.inc
index 463ce921f0672..e3ac30aea8c7b 100644
--- a/clang/lib/Tooling/Inclusions/Stdlib/CSymbolMap.inc
+++ b/clang/lib/Tooling/Inclusions/Stdlib/CSymbolMap.inc
@@ -6,246 +6,46 @@
// This file was generated automatically by
// clang/tools/include-mapping/gen_std.py, DO NOT EDIT!
//
-// Generated from cppreference offline HTML book (modified on 2018-10-28).
+// Generated from cppreference offline HTML book (modified on 2025-02-10).
//===----------------------------------------------------------------------===//
-SYMBOL(ATOMIC_BOOL_LOCK_FREE, None, <stdatomic.h>)
-SYMBOL(ATOMIC_CHAR16_T_LOCK_FREE, None, <stdatomic.h>)
-SYMBOL(ATOMIC_CHAR32_T_LOCK_FREE, None, <stdatomic.h>)
-SYMBOL(ATOMIC_CHAR_LOCK_FREE, None, <stdatomic.h>)
-SYMBOL(ATOMIC_FLAG_INIT, None, <stdatomic.h>)
-SYMBOL(ATOMIC_INT_LOCK_FREE, None, <stdatomic.h>)
-SYMBOL(ATOMIC_LLONG_LOCK_FREE, None, <stdatomic.h>)
-SYMBOL(ATOMIC_LONG_LOGK_FREE, None, <stdatomic.h>)
-SYMBOL(ATOMIC_POINTER_LOCK_FREE, None, <stdatomic.h>)
-SYMBOL(ATOMIC_SHORT_LOCK_FREE, None, <stdatomic.h>)
-SYMBOL(ATOMIC_VAR_INIT, None, <stdatomic.h>)
-SYMBOL(ATOMIC_WCHAR_T_LOCK_FREE, None, <stdatomic.h>)
-SYMBOL(BUFSIZ, None, <stdio.h>)
-SYMBOL(CHAR_BIT, None, <limits.h>)
-SYMBOL(CHAR_MAX, None, <limits.h>)
-SYMBOL(CHAR_MIN, None, <limits.h>)
-SYMBOL(CLOCKS_PER_SEC, None, <time.h>)
-SYMBOL(CMPLX, None, <complex.h>)
-SYMBOL(CMPLXF, None, <complex.h>)
-SYMBOL(CMPLXL, None, <complex.h>)
-SYMBOL(DBL_DECIMAL_DIG, None, <float.h>)
-SYMBOL(DBL_DIG, None, <float.h>)
-SYMBOL(DBL_EPSILON, None, <float.h>)
-SYMBOL(DBL_HAS_SUBNORM, None, <float.h>)
-SYMBOL(DBL_MANT_DIG, None, <float.h>)
-SYMBOL(DBL_MAX, None, <float.h>)
-SYMBOL(DBL_MAX_10_EXP, None, <float.h>)
-SYMBOL(DBL_MAX_EXP, None, <float.h>)
-SYMBOL(DBL_MIN, None, <float.h>)
-SYMBOL(DBL_MIN_10_EXP, None, <float.h>)
-SYMBOL(DBL_MIN_EXP, None, <float.h>)
-SYMBOL(DBL_TRUE_MIN, None, <float.h>)
-SYMBOL(DECIMAL_DIG, None, <float.h>)
-SYMBOL(EDOM, None, <errno.h>)
-SYMBOL(EILSEQ, None, <errno.h>)
-SYMBOL(EOF, None, <stdio.h>)
-SYMBOL(ERANGE, None, <errno.h>)
-SYMBOL(EXIT_FAILURE, None, <stdlib.h>)
-SYMBOL(EXIT_SUCCESS, None, <stdlib.h>)
-SYMBOL(FE_ALL_EXCEPT, None, <fenv.h>)
-SYMBOL(FE_DFL_ENV, None, <fenv.h>)
-SYMBOL(FE_DIVBYZERO, None, <fenv.h>)
-SYMBOL(FE_DOWNWARD, None, <fenv.h>)
-SYMBOL(FE_INEXACT, None, <fenv.h>)
-SYMBOL(FE_INVALID, None, <fenv.h>)
-SYMBOL(FE_OVERFLOW, None, <fenv.h>)
-SYMBOL(FE_TONEAREST, None, <fenv.h>)
-SYMBOL(FE_TOWARDZERO, None, <fenv.h>)
-SYMBOL(FE_UNDERFLOW, None, <fenv.h>)
-SYMBOL(FE_UPWARD, None, <fenv.h>)
+// clang-format off
SYMBOL(FILE, None, <stdio.h>)
-SYMBOL(FILENAME_MAX, None, <stdio.h>)
-SYMBOL(FLT_DECIMAL_DIG, None, <float.h>)
-SYMBOL(FLT_DIG, None, <float.h>)
-SYMBOL(FLT_EPSILON, None, <float.h>)
-SYMBOL(FLT_EVAL_METHOD, None, <float.h>)
-SYMBOL(FLT_HAS_SUBNORM, None, <float.h>)
-SYMBOL(FLT_MANT_DIG, None, <float.h>)
-SYMBOL(FLT_MAX, None, <float.h>)
-SYMBOL(FLT_MAX_10_EXP, None, <float.h>)
-SYMBOL(FLT_MAX_EXP, None, <float.h>)
-SYMBOL(FLT_MIN, None, <float.h>)
-SYMBOL(FLT_MIN_10_EXP, None, <float.h>)
-SYMBOL(FLT_MIN_EXP, None, <float.h>)
-SYMBOL(FLT_RADIX, None, <float.h>)
-SYMBOL(FLT_ROUNDS, None, <float.h>)
-SYMBOL(FLT_TRUE_MIN, None, <float.h>)
-SYMBOL(FOPEN_MAX, None, <stdio.h>)
-SYMBOL(FP_INFINITE, None, <math.h>)
-SYMBOL(FP_NAN, None, <math.h>)
-SYMBOL(FP_NORNAL, None, <math.h>)
-SYMBOL(FP_SUBNORMAL, None, <math.h>)
-SYMBOL(FP_ZERO, None, <math.h>)
-SYMBOL(HUGE_VAL, None, <math.h>)
-SYMBOL(HUGE_VALF, None, <math.h>)
-SYMBOL(HUGE_VALL, None, <math.h>)
-SYMBOL(I, None, <complex.h>)
-SYMBOL(INFINITY, None, <math.h>)
-SYMBOL(INT16_MAX, None, <stdint.h>)
-SYMBOL(INT16_MIN, None, <stdint.h>)
-SYMBOL(INT32_MAX, None, <stdint.h>)
-SYMBOL(INT32_MIN, None, <stdint.h>)
-SYMBOL(INT64_MAX, None, <stdint.h>)
-SYMBOL(INT64_MIN, None, <stdint.h>)
-SYMBOL(INT8_MAX, None, <stdint.h>)
-SYMBOL(INT8_MIN, None, <stdint.h>)
-SYMBOL(INTMAX_MAX, None, <stdint.h>)
-SYMBOL(INTMAX_MIN, None, <stdint.h>)
-SYMBOL(INTPTR_MAX, None, <stdint.h>)
-SYMBOL(INTPTR_MIN, None, <stdint.h>)
-SYMBOL(INT_FAST16_MAX, None, <stdint.h>)
-SYMBOL(INT_FAST16_MIN, None, <stdint.h>)
-SYMBOL(INT_FAST32_MAX, None, <stdint.h>)
-SYMBOL(INT_FAST32_MIN, None, <stdint.h>)
-SYMBOL(INT_FAST64_MAX, None, <stdint.h>)
-SYMBOL(INT_FAST64_MIN, None, <stdint.h>)
-SYMBOL(INT_FAST8_MAX, None, <stdint.h>)
-SYMBOL(INT_FAST8_MIN, None, <stdint.h>)
-SYMBOL(INT_LEAST16_MAX, None, <stdint.h>)
-SYMBOL(INT_LEAST16_MIN, None, <stdint.h>)
-SYMBOL(INT_LEAST32_MAX, None, <stdint.h>)
-SYMBOL(INT_LEAST32_MIN, None, <stdint.h>)
-SYMBOL(INT_LEAST64_MAX, None, <stdint.h>)
-SYMBOL(INT_LEAST64_MIN, None, <stdint.h>)
-SYMBOL(INT_LEAST8_MAX, None, <stdint.h>)
-SYMBOL(INT_LEAST8_MIN, None, <stdint.h>)
-SYMBOL(INT_MAX, None, <limits.h>)
-SYMBOL(INT_MIN, None, <limits.h>)
-SYMBOL(LC_ALL, None, <locale.h>)
-SYMBOL(LC_COLLATE, None, <locale.h>)
-SYMBOL(LC_CTYPE, None, <locale.h>)
-SYMBOL(LC_MONETARY, None, <locale.h>)
-SYMBOL(LC_NUMERIC, None, <locale.h>)
-SYMBOL(LC_TIME, None, <locale.h>)
-SYMBOL(LDBL_DECIMAL_DIG, None, <float.h>)
-SYMBOL(LDBL_DIG, None, <float.h>)
-SYMBOL(LDBL_EPSILON, None, <float.h>)
-SYMBOL(LDBL_HAS_SUBNORM, None, <float.h>)
-SYMBOL(LDBL_MANT_DIG, None, <float.h>)
-SYMBOL(LDBL_MAX, None, <float.h>)
-SYMBOL(LDBL_MAX_10_EXP, None, <float.h>)
-SYMBOL(LDBL_MAX_EXP, None, <float.h>)
-SYMBOL(LDBL_MIN, None, <float.h>)
-SYMBOL(LDBL_MIN_10_EXP, None, <float.h>)
-SYMBOL(LDBL_MIN_EXP, None, <float.h>)
-SYMBOL(LDBL_TRUE_MIN, None, <float.h>)
-SYMBOL(LLONG_MAX, None, <limits.h>)
-SYMBOL(LLONG_MIN, None, <limits.h>)
-SYMBOL(LONG_MAX, None, <limits.h>)
-SYMBOL(LONG_MIN, None, <limits.h>)
-SYMBOL(L_tmpnam, None, <stdio.h>)
-SYMBOL(L_tmpnam_s, None, <stdio.h>)
-SYMBOL(MATH_ERREXCEPT, None, <math.h>)
-SYMBOL(MATH_ERRNO, None, <math.h>)
-SYMBOL(MB_CUR_MAX, None, <stdlib.h>)
-SYMBOL(MB_LEN_MAX, None, <limits.h>)
-SYMBOL(NAN, None, <math.h>)
-SYMBOL(ONCE_FLAG_INIT, None, <threads.h>)
-SYMBOL(PTRDIFF_MAX, None, <stdint.h>)
-SYMBOL(PTRDIFF_MIN, None, <stdint.h>)
-SYMBOL(RAND_MAX, None, <stdlib.h>)
-SYMBOL(RSIZE_MAX, None, <stdint.h>)
-SYMBOL(SCHAR_MAX, None, <limits.h>)
-SYMBOL(SCHAR_MIN, None, <limits.h>)
-SYMBOL(SEEK_CUR, None, <stdio.h>)
-SYMBOL(SEEK_END, None, <stdio.h>)
-SYMBOL(SEEK_SET, None, <stdio.h>)
-SYMBOL(SHRT_MAX, None, <limits.h>)
-SYMBOL(SHRT_MIN, None, <limits.h>)
-SYMBOL(SIGABRT, None, <signal.h>)
-SYMBOL(SIGFPE, None, <signal.h>)
-SYMBOL(SIGILL, None, <signal.h>)
-SYMBOL(SIGINT, None, <signal.h>)
-SYMBOL(SIGSEGV, None, <signal.h>)
-SYMBOL(SIGTERM, None, <signal.h>)
-SYMBOL(SIG_ATOMIC_MAX, None, <stdint.h>)
-SYMBOL(SIG_ATOMIC_MIN, None, <stdint.h>)
-SYMBOL(SIG_DFL, None, <signal.h>)
-SYMBOL(SIG_ERR, None, <signal.h>)
-SYMBOL(SIG_IGN, None, <signal.h>)
-SYMBOL(SIZE_MAX, None, <stdint.h>)
-SYMBOL(TIME_UTC, None, <time.h>)
-SYMBOL(TMP_MAX, None, <stdio.h>)
-SYMBOL(TMP_MAX_S, None, <stdio.h>)
-SYMBOL(TSS_DTOR_ITERATIONS, None, <threads.h>)
-SYMBOL(UCHAR_MAX, None, <limits.h>)
-SYMBOL(UINT16_MAX, None, <stdint.h>)
-SYMBOL(UINT32_MAX, None, <stdint.h>)
-SYMBOL(UINT64_MAX, None, <stdint.h>)
-SYMBOL(UINT8_MAX, None, <stdint.h>)
-SYMBOL(UINTMAX_MAX, None, <stdint.h>)
-SYMBOL(UINTPTR_MAX, None, <stdint.h>)
-SYMBOL(UINT_FAST16_MAX, None, <stdint.h>)
-SYMBOL(UINT_FAST32_MAX, None, <stdint.h>)
-SYMBOL(UINT_FAST64_MAX, None, <stdint.h>)
-SYMBOL(UINT_FAST8_MAX, None, <stdint.h>)
-SYMBOL(UINT_LEAST16_MAX, None, <stdint.h>)
-SYMBOL(UINT_LEAST32_MAX, None, <stdint.h>)
-SYMBOL(UINT_LEAST64_MAX, None, <stdint.h>)
-SYMBOL(UINT_LEAST8_MAX, None, <stdint.h>)
-SYMBOL(UINT_MAX, None, <limits.h>)
-SYMBOL(ULLONG_MAX, None, <limits.h>)
-SYMBOL(ULONG_MAX, None, <limits.h>)
-SYMBOL(USHRT_MAX, None, <limits.h>)
-SYMBOL(WCHAR_MAX, None, <wchar.h>)
-SYMBOL(WCHAR_MIN, None, <wchar.h>)
-SYMBOL(WEOF, None, <wchar.h>)
-SYMBOL(WINT_MAX, None, <stdint.h>)
-SYMBOL(WINT_MIN, None, <stdint.h>)
-SYMBOL(_Complex_I, None, <complex.h>)
-SYMBOL(_IOFBF, None, <stdio.h>)
-SYMBOL(_IOLBF, None, <stdio.h>)
-SYMBOL(_IONBF, None, <stdio.h>)
-SYMBOL(_Imaginary_I, None, <complex.h>)
-SYMBOL(__alignas_is_defined, None, <stdalign.h>)
-SYMBOL(__alignof_is_defined, None, <stdalign.h>)
-SYMBOL(abort_handler_s, None, <stdlib.h>)
+SYMBOL(EOF, None, <stdio.h>)
+SYMBOL_VERSION(_Exit, None, <stdlib.h>, "c99")
+SYMBOL(abort, None, <stdlib.h>)
+SYMBOL_VERSION(abort_handler_s, None, <stdlib.h>, "c11")
SYMBOL(abs, None, <stdlib.h>)
SYMBOL(acos, None, <math.h>)
-SYMBOL(acosf, None, <math.h>)
-SYMBOL(acosh, None, <math.h>)
-SYMBOL(acoshf, None, <math.h>)
-SYMBOL(acoshl, None, <math.h>)
-SYMBOL(acosl, None, <math.h>)
-SYMBOL(alignas, None, <stdalign.h>)
-SYMBOL(aligned_alloc, None, <stdlib.h>)
-SYMBOL(alignof, None, <stdalign.h>)
-SYMBOL(and, None, <iso646.h>)
-SYMBOL(and_eq, None, <iso646.h>)
+SYMBOL_VERSION(acosf, None, <math.h>, "c99")
+SYMBOL_VERSION(acosh, None, <math.h>, "c99")
+SYMBOL_VERSION(acoshf, None, <math.h>, "c99")
+SYMBOL_VERSION(acoshl, None, <math.h>, "c99")
+SYMBOL_VERSION(acosl, None, <math.h>, "c99")
+SYMBOL_VERSION(aligned_alloc, None, <stdlib.h>, "c11")
SYMBOL(asctime, None, <time.h>)
-SYMBOL(asctime_s, None, <time.h>)
+SYMBOL_VERSION(asctime_s, None, <time.h>, "c11")
SYMBOL(asin, None, <math.h>)
-SYMBOL(asinf, None, <math.h>)
-SYMBOL(asinh, None, <math.h>)
-SYMBOL(asinhf, None, <math.h>)
-SYMBOL(asinhl, None, <math.h>)
-SYMBOL(asinl, None, <math.h>)
-SYMBOL(assert, None, <assert.h>)
-SYMBOL(at_quick_exit, None, <stdlib.h>)
+SYMBOL_VERSION(asinf, None, <math.h>, "c99")
+SYMBOL_VERSION(asinh, None, <math.h>, "c99")
+SYMBOL_VERSION(asinhf, None, <math.h>, "c99")
+SYMBOL_VERSION(asinhl, None, <math.h>, "c99")
+SYMBOL_VERSION(asinl, None, <math.h>, "c99")
+SYMBOL_VERSION(at_quick_exit, None, <stdlib.h>, "c11")
SYMBOL(atan, None, <math.h>)
SYMBOL(atan2, None, <math.h>)
-SYMBOL(atan2f, None, <math.h>)
-SYMBOL(atan2l, None, <math.h>)
-SYMBOL(atanf, None, <math.h>)
-SYMBOL(atanh, None, <math.h>)
-SYMBOL(atanhf, None, <math.h>)
-SYMBOL(atanhl, None, <math.h>)
-SYMBOL(atanl, None, <math.h>)
+SYMBOL_VERSION(atan2f, None, <math.h>, "c99")
+SYMBOL_VERSION(atan2l, None, <math.h>, "c99")
+SYMBOL_VERSION(atanf, None, <math.h>, "c99")
+SYMBOL_VERSION(atanh, None, <math.h>, "c99")
+SYMBOL_VERSION(atanhf, None, <math.h>, "c99")
+SYMBOL_VERSION(atanhl, None, <math.h>, "c99")
+SYMBOL_VERSION(atanl, None, <math.h>, "c99")
SYMBOL(atexit, None, <stdlib.h>)
SYMBOL(atof, None, <stdlib.h>)
SYMBOL(atoi, None, <stdlib.h>)
SYMBOL(atol, None, <stdlib.h>)
-SYMBOL(atoll, None, <stdlib.h>)
-SYMBOL(atomic_bool, None, <stdatomic.h>)
-SYMBOL(atomic_char, None, <stdatomic.h>)
-SYMBOL(atomic_char16_t, None, <stdatomic.h>)
-SYMBOL(atomic_char32_t, None, <stdatomic.h>)
+SYMBOL_VERSION(atoll, None, <stdlib.h>, "c99")
SYMBOL(atomic_compare_exchange_strong, None, <stdatomic.h>)
SYMBOL(atomic_compare_exchange_strong_explicit, None, <stdatomic.h>)
SYMBOL(atomic_compare_exchange_weak, None, <stdatomic.h>)
@@ -262,228 +62,189 @@ SYMBOL(atomic_fetch_sub, None, <stdatomic.h>)
SYMBOL(atomic_fetch_sub_explicit, None, <stdatomic.h>)
SYMBOL(atomic_fetch_xor, None, <stdatomic.h>)
SYMBOL(atomic_fetch_xor_explicit, None, <stdatomic.h>)
-SYMBOL(atomic_flag, None, <stdatomic.h>)
-SYMBOL(atomic_flag_clear, None, <stdatomic.h>)
-SYMBOL(atomic_flag_clear_explicit, None, <stdatomic.h>)
-SYMBOL(atomic_flag_test_and_set, None, <stdatomic.h>)
-SYMBOL(atomic_flag_test_and_set_explicit, None, <stdatomic.h>)
+SYMBOL_VERSION(atomic_flag, None, <stdatomic.h>, "c11")
+SYMBOL_VERSION(atomic_flag_clear, None, <stdatomic.h>, "c11")
+SYMBOL_VERSION(atomic_flag_clear_explicit, None, <stdatomic.h>, "c11")
+SYMBOL_VERSION(atomic_flag_test_and_set, None, <stdatomic.h>, "c11")
+SYMBOL_VERSION(atomic_flag_test_and_set_explicit, None, <stdatomic.h>, "c11")
SYMBOL(atomic_init, None, <stdatomic.h>)
-SYMBOL(atomic_int, None, <stdatomic.h>)
-SYMBOL(atomic_int_fast16_t, None, <stdatomic.h>)
-SYMBOL(atomic_int_fast32_t, None, <stdatomic.h>)
-SYMBOL(atomic_int_fast64_t, None, <stdatomic.h>)
-SYMBOL(atomic_int_fast8_t, None, <stdatomic.h>)
-SYMBOL(atomic_int_least16_t, None, <stdatomic.h>)
-SYMBOL(atomic_int_least32_t, None, <stdatomic.h>)
-SYMBOL(atomic_int_least64_t, None, <stdatomic.h>)
-SYMBOL(atomic_int_least8_t, None, <stdatomic.h>)
-SYMBOL(atomic_intmax_t, None, <stdatomic.h>)
-SYMBOL(atomic_intptr_t, None, <stdatomic.h>)
SYMBOL(atomic_is_lock_free, None, <stdatomic.h>)
-SYMBOL(atomic_llong, None, <stdatomic.h>)
SYMBOL(atomic_load, None, <stdatomic.h>)
SYMBOL(atomic_load_explicit, None, <stdatomic.h>)
-SYMBOL(atomic_long, None, <stdatomic.h>)
-SYMBOL(atomic_ptrdiff_t, None, <stdatomic.h>)
-SYMBOL(atomic_schar, None, <stdatomic.h>)
-SYMBOL(atomic_short, None, <stdatomic.h>)
-SYMBOL(atomic_signal_fence, None, <stdatomic.h>)
-SYMBOL(atomic_size_t, None, <stdatomic.h>)
+SYMBOL_VERSION(atomic_signal_fence, None, <stdatomic.h>, "c11")
SYMBOL(atomic_store, None, <stdatomic.h>)
SYMBOL(atomic_store_explicit, None, <stdatomic.h>)
-SYMBOL(atomic_thread_fence, None, <stdatomic.h>)
-SYMBOL(atomic_uchar, None, <stdatomic.h>)
-SYMBOL(atomic_uint, None, <stdatomic.h>)
-SYMBOL(atomic_uint_fast16_t, None, <stdatomic.h>)
-SYMBOL(atomic_uint_fast32_t, None, <stdatomic.h>)
-SYMBOL(atomic_uint_fast64_t, None, <stdatomic.h>)
-SYMBOL(atomic_uint_fast8_t, None, <stdatomic.h>)
-SYMBOL(atomic_uint_least16_t, None, <stdatomic.h>)
-SYMBOL(atomic_uint_least32_t, None, <stdatomic.h>)
-SYMBOL(atomic_uint_least64_t, None, <stdatomic.h>)
-SYMBOL(atomic_uint_least8_t, None, <stdatomic.h>)
-SYMBOL(atomic_uintmax_t, None, <stdatomic.h>)
-SYMBOL(atomic_uintptr_t, None, <stdatomic.h>)
-SYMBOL(atomic_ullong, None, <stdatomic.h>)
-SYMBOL(atomic_ulong, None, <stdatomic.h>)
-SYMBOL(atomic_ushort, None, <stdatomic.h>)
-SYMBOL(atomic_wchar_t, None, <stdatomic.h>)
-SYMBOL(bitand, None, <iso646.h>)
-SYMBOL(bitor, None, <iso646.h>)
+SYMBOL_VERSION(atomic_thread_fence, None, <stdatomic.h>, "c11")
SYMBOL(bsearch, None, <stdlib.h>)
-SYMBOL(bsearch_s, None, <stdlib.h>)
+SYMBOL_VERSION(bsearch_s, None, <stdlib.h>, "c11")
SYMBOL(btowc, None, <wchar.h>)
-SYMBOL(c16rtomb, None, <uchar.h>)
-SYMBOL(c32rtomb, None, <uchar.h>)
-SYMBOL(cabs, None, <complex.h>)
-SYMBOL(cabsf, None, <complex.h>)
-SYMBOL(cabsl, None, <complex.h>)
-SYMBOL(cacos, None, <complex.h>)
-SYMBOL(cacosf, None, <complex.h>)
-SYMBOL(cacosh, None, <complex.h>)
-SYMBOL(cacoshf, None, <complex.h>)
-SYMBOL(cacoshl, None, <complex.h>)
-SYMBOL(cacosl, None, <complex.h>)
-SYMBOL(call_once, None, <threads.h>)
+SYMBOL_VERSION(c16rtomb, None, <uchar.h>, "c11")
+SYMBOL_VERSION(c32rtomb, None, <uchar.h>, "c11")
+SYMBOL_VERSION(cabs, None, <complex.h>, "c99")
+SYMBOL_VERSION(cabsf, None, <complex.h>, "c99")
+SYMBOL_VERSION(cabsl, None, <complex.h>, "c99")
+SYMBOL_VERSION(cacos, None, <complex.h>, "c99")
+SYMBOL_VERSION(cacosf, None, <complex.h>, "c99")
+SYMBOL_VERSION(cacosh, None, <complex.h>, "c99")
+SYMBOL_VERSION(cacoshf, None, <complex.h>, "c99")
+SYMBOL_VERSION(cacoshl, None, <complex.h>, "c99")
+SYMBOL_VERSION(cacosl, None, <complex.h>, "c99")
+SYMBOL_VERSION(call_once, None, <threads.h>, "c11")
SYMBOL(calloc, None, <stdlib.h>)
-SYMBOL(carg, None, <complex.h>)
-SYMBOL(cargf, None, <complex.h>)
-SYMBOL(cargl, None, <complex.h>)
-SYMBOL(casin, None, <complex.h>)
-SYMBOL(casinf, None, <complex.h>)
-SYMBOL(casinh, None, <complex.h>)
-SYMBOL(casinhf, None, <complex.h>)
-SYMBOL(casinhl, None, <complex.h>)
-SYMBOL(casinl, None, <complex.h>)
-SYMBOL(catan, None, <complex.h>)
-SYMBOL(catanf, None, <complex.h>)
-SYMBOL(catanh, None, <complex.h>)
-SYMBOL(catanhf, None, <complex.h>)
-SYMBOL(catanhl, None, <complex.h>)
-SYMBOL(catanl, None, <complex.h>)
-SYMBOL(cbrt, None, <math.h>)
-SYMBOL(cbrtf, None, <math.h>)
-SYMBOL(cbrtl, None, <math.h>)
-SYMBOL(ccos, None, <complex.h>)
-SYMBOL(ccosf, None, <complex.h>)
-SYMBOL(ccosh, None, <complex.h>)
-SYMBOL(ccoshf, None, <complex.h>)
-SYMBOL(ccoshl, None, <complex.h>)
-SYMBOL(ccosl, None, <complex.h>)
+SYMBOL_VERSION(carg, None, <complex.h>, "c99")
+SYMBOL_VERSION(cargf, None, <complex.h>, "c99")
+SYMBOL_VERSION(cargl, None, <complex.h>, "c99")
+SYMBOL_VERSION(casin, None, <complex.h>, "c99")
+SYMBOL_VERSION(casinf, None, <complex.h>, "c99")
+SYMBOL_VERSION(casinh, None, <complex.h>, "c99")
+SYMBOL_VERSION(casinhf, None, <complex.h>, "c99")
+SYMBOL_VERSION(casinhl, None, <complex.h>, "c99")
+SYMBOL_VERSION(casinl, None, <complex.h>, "c99")
+SYMBOL_VERSION(catan, None, <complex.h>, "c99")
+SYMBOL_VERSION(catanf, None, <complex.h>, "c99")
+SYMBOL_VERSION(catanh, None, <complex.h>, "c99")
+SYMBOL_VERSION(catanhf, None, <complex.h>, "c99")
+SYMBOL_VERSION(catanhl, None, <complex.h>, "c99")
+SYMBOL_VERSION(catanl, None, <complex.h>, "c99")
+SYMBOL_VERSION(cbrt, None, <math.h>, "c99")
+SYMBOL_VERSION(cbrtf, None, <math.h>, "c99")
+SYMBOL_VERSION(cbrtl, None, <math.h>, "c99")
+SYMBOL_VERSION(ccos, None, <complex.h>, "c99")
+SYMBOL_VERSION(ccosf, None, <complex.h>, "c99")
+SYMBOL_VERSION(ccosh, None, <complex.h>, "c99")
+SYMBOL_VERSION(ccoshf, None, <complex.h>, "c99")
+SYMBOL_VERSION(ccoshl, None, <complex.h>, "c99")
+SYMBOL_VERSION(ccosl, None, <complex.h>, "c99")
SYMBOL(ceil, None, <math.h>)
-SYMBOL(ceilf, None, <math.h>)
-SYMBOL(ceill, None, <math.h>)
-SYMBOL(cexp, None, <complex.h>)
-SYMBOL(cexpf, None, <complex.h>)
-SYMBOL(cexpl, None, <complex.h>)
-SYMBOL(char16_t, None, <uchar.h>)
-SYMBOL(char32_t, None, <uchar.h>)
-SYMBOL(cimag, None, <complex.h>)
-SYMBOL(cimagf, None, <complex.h>)
-SYMBOL(cimagl, None, <complex.h>)
+SYMBOL_VERSION(ceilf, None, <math.h>, "c99")
+SYMBOL_VERSION(ceill, None, <math.h>, "c99")
+SYMBOL_VERSION(cexp, None, <complex.h>, "c99")
+SYMBOL_VERSION(cexpf, None, <complex.h>, "c99")
+SYMBOL_VERSION(cexpl, None, <complex.h>, "c99")
+SYMBOL_VERSION(char16_t, None, <uchar.h>, "c11")
+SYMBOL_VERSION(char32_t, None, <uchar.h>, "c11")
+SYMBOL_VERSION(cimag, None, <complex.h>, "c99")
+SYMBOL_VERSION(cimagf, None, <complex.h>, "c99")
+SYMBOL_VERSION(cimagl, None, <complex.h>, "c99")
SYMBOL(clearerr, None, <stdio.h>)
SYMBOL(clock, None, <time.h>)
SYMBOL(clock_t, None, <time.h>)
-SYMBOL(clog, None, <complex.h>)
-SYMBOL(clogf, None, <complex.h>)
-SYMBOL(clogl, None, <complex.h>)
-SYMBOL(cnd_broadcast, None, <threads.h>)
-SYMBOL(cnd_destroy, None, <threads.h>)
-SYMBOL(cnd_init, None, <threads.h>)
-SYMBOL(cnd_signal, None, <threads.h>)
-SYMBOL(cnd_t, None, <threads.h>)
-SYMBOL(cnd_timedwait, None, <threads.h>)
-SYMBOL(cnd_wait, None, <threads.h>)
-SYMBOL(compl, None, <iso646.h>)
-SYMBOL(complex, None, <complex.h>)
-SYMBOL(conj, None, <complex.h>)
-SYMBOL(conjf, None, <complex.h>)
-SYMBOL(conjl, None, <complex.h>)
-SYMBOL(constraint_handler_t, None, <stdlib.h>)
-SYMBOL(copysign, None, <math.h>)
-SYMBOL(copysignf, None, <math.h>)
-SYMBOL(copysignl, None, <math.h>)
+SYMBOL_VERSION(clog, None, <complex.h>, "c99")
+SYMBOL_VERSION(clogf, None, <complex.h>, "c99")
+SYMBOL_VERSION(clogl, None, <complex.h>, "c99")
+SYMBOL_VERSION(cnd_broadcast, None, <threads.h>, "c11")
+SYMBOL_VERSION(cnd_destroy, None, <threads.h>, "c11")
+SYMBOL_VERSION(cnd_init, None, <threads.h>, "c11")
+SYMBOL_VERSION(cnd_signal, None, <threads.h>, "c11")
+SYMBOL_VERSION(cnd_t, None, <threads.h>, "c11")
+SYMBOL_VERSION(cnd_timedwait, None, <threads.h>, "c11")
+SYMBOL_VERSION(cnd_wait, None, <threads.h>, "c11")
+SYMBOL_VERSION(conj, None, <complex.h>, "c99")
+SYMBOL_VERSION(conjf, None, <complex.h>, "c99")
+SYMBOL_VERSION(conjl, None, <complex.h>, "c99")
+SYMBOL_VERSION(constraint_handler_t, None, <stdlib.h>, "c11")
+SYMBOL_VERSION(copysign, None, <math.h>, "c99")
+SYMBOL_VERSION(copysignf, None, <math.h>, "c99")
+SYMBOL_VERSION(copysignl, None, <math.h>, "c99")
SYMBOL(cos, None, <math.h>)
-SYMBOL(cosf, None, <math.h>)
+SYMBOL_VERSION(cosf, None, <math.h>, "c99")
SYMBOL(cosh, None, <math.h>)
-SYMBOL(coshf, None, <math.h>)
-SYMBOL(coshl, None, <math.h>)
-SYMBOL(cosl, None, <math.h>)
-SYMBOL(cpow, None, <complex.h>)
-SYMBOL(cpowf, None, <complex.h>)
-SYMBOL(cpowl, None, <complex.h>)
-SYMBOL(cproj, None, <complex.h>)
-SYMBOL(cprojf, None, <complex.h>)
-SYMBOL(cprojl, None, <complex.h>)
-SYMBOL(creal, None, <complex.h>)
-SYMBOL(crealf, None, <complex.h>)
-SYMBOL(creall, None, <complex.h>)
-SYMBOL(csin, None, <complex.h>)
-SYMBOL(csinf, None, <complex.h>)
-SYMBOL(csinh, None, <complex.h>)
-SYMBOL(csinhf, None, <complex.h>)
-SYMBOL(csinhl, None, <complex.h>)
-SYMBOL(csinl, None, <complex.h>)
-SYMBOL(csqrt, None, <complex.h>)
-SYMBOL(csqrtf, None, <complex.h>)
-SYMBOL(csqrtl, None, <complex.h>)
-SYMBOL(ctan, None, <complex.h>)
-SYMBOL(ctanf, None, <complex.h>)
-SYMBOL(ctanh, None, <complex.h>)
-SYMBOL(ctanhf, None, <complex.h>)
-SYMBOL(ctanhl, None, <complex.h>)
-SYMBOL(ctanl, None, <complex.h>)
+SYMBOL_VERSION(coshf, None, <math.h>, "c99")
+SYMBOL_VERSION(coshl, None, <math.h>, "c99")
+SYMBOL_VERSION(cosl, None, <math.h>, "c99")
+SYMBOL_VERSION(cpow, None, <complex.h>, "c99")
+SYMBOL_VERSION(cpowf, None, <complex.h>, "c99")
+SYMBOL_VERSION(cpowl, None, <complex.h>, "c99")
+SYMBOL_VERSION(cproj, None, <complex.h>, "c99")
+SYMBOL_VERSION(cprojf, None, <complex.h>, "c99")
+SYMBOL_VERSION(cprojl, None, <complex.h>, "c99")
+SYMBOL_VERSION(creal, None, <complex.h>, "c99")
+SYMBOL_VERSION(crealf, None, <complex.h>, "c99")
+SYMBOL_VERSION(creall, None, <complex.h>, "c99")
+SYMBOL_VERSION(csin, None, <complex.h>, "c99")
+SYMBOL_VERSION(csinf, None, <complex.h>, "c99")
+SYMBOL_VERSION(csinh, None, <complex.h>, "c99")
+SYMBOL_VERSION(csinhf, None, <complex.h>, "c99")
+SYMBOL_VERSION(csinhl, None, <complex.h>, "c99")
+SYMBOL_VERSION(csinl, None, <complex.h>, "c99")
+SYMBOL_VERSION(csqrt, None, <complex.h>, "c99")
+SYMBOL_VERSION(csqrtf, None, <complex.h>, "c99")
+SYMBOL_VERSION(csqrtl, None, <complex.h>, "c99")
+SYMBOL_VERSION(ctan, None, <complex.h>, "c99")
+SYMBOL_VERSION(ctanf, None, <complex.h>, "c99")
+SYMBOL_VERSION(ctanh, None, <complex.h>, "c99")
+SYMBOL_VERSION(ctanhf, None, <complex.h>, "c99")
+SYMBOL_VERSION(ctanhl, None, <complex.h>, "c99")
+SYMBOL_VERSION(ctanl, None, <complex.h>, "c99")
SYMBOL(ctime, None, <time.h>)
-SYMBOL(ctime_s, None, <time.h>)
+SYMBOL_VERSION(ctime_s, None, <time.h>, "c11")
SYMBOL(difftime, None, <time.h>)
-SYMBOL(double_t, None, <math.h>)
-SYMBOL(erf, None, <math.h>)
-SYMBOL(erfc, None, <math.h>)
-SYMBOL(erfcf, None, <math.h>)
-SYMBOL(erfcl, None, <math.h>)
-SYMBOL(erff, None, <math.h>)
-SYMBOL(erfl, None, <math.h>)
-SYMBOL(errno, None, <errno.h>)
+SYMBOL_VERSION(double_t, None, <math.h>, "c99")
+SYMBOL_VERSION(erf, None, <math.h>, "c99")
+SYMBOL_VERSION(erfc, None, <math.h>, "c99")
+SYMBOL_VERSION(erfcf, None, <math.h>, "c99")
+SYMBOL_VERSION(erfcl, None, <math.h>, "c99")
+SYMBOL_VERSION(erff, None, <math.h>, "c99")
+SYMBOL_VERSION(erfl, None, <math.h>, "c99")
SYMBOL(exit, None, <stdlib.h>)
SYMBOL(exp, None, <math.h>)
-SYMBOL(exp2, None, <math.h>)
-SYMBOL(exp2f, None, <math.h>)
-SYMBOL(exp2l, None, <math.h>)
-SYMBOL(expf, None, <math.h>)
-SYMBOL(expl, None, <math.h>)
-SYMBOL(expm1, None, <math.h>)
-SYMBOL(expm1f, None, <math.h>)
-SYMBOL(expm1l, None, <math.h>)
+SYMBOL_VERSION(exp2, None, <math.h>, "c99")
+SYMBOL_VERSION(exp2f, None, <math.h>, "c99")
+SYMBOL_VERSION(exp2l, None, <math.h>, "c99")
+SYMBOL_VERSION(expf, None, <math.h>, "c99")
+SYMBOL_VERSION(expl, None, <math.h>, "c99")
+SYMBOL_VERSION(expm1, None, <math.h>, "c99")
+SYMBOL_VERSION(expm1f, None, <math.h>, "c99")
+SYMBOL_VERSION(expm1l, None, <math.h>, "c99")
SYMBOL(fabs, None, <math.h>)
-SYMBOL(fabsf, None, <math.h>)
-SYMBOL(fabsl, None, <math.h>)
+SYMBOL_VERSION(fabsf, None, <math.h>, "c99")
+SYMBOL_VERSION(fabsl, None, <math.h>, "c99")
SYMBOL(fclose, None, <stdio.h>)
-SYMBOL(fdim, None, <math.h>)
-SYMBOL(fdimf, None, <math.h>)
-SYMBOL(fdiml, None, <math.h>)
-SYMBOL(feclearexcept, None, <fenv.h>)
-SYMBOL(fegetenv, None, <fenv.h>)
-SYMBOL(fegetexceptflag, None, <fenv.h>)
-SYMBOL(fegetround, None, <fenv.h>)
-SYMBOL(feholdexcept, None, <fenv.h>)
-SYMBOL(fenv_t, None, <fenv.h>)
+SYMBOL_VERSION(fdim, None, <math.h>, "c99")
+SYMBOL_VERSION(fdimf, None, <math.h>, "c99")
+SYMBOL_VERSION(fdiml, None, <math.h>, "c99")
+SYMBOL_VERSION(feclearexcept, None, <fenv.h>, "c99")
+SYMBOL_VERSION(fegetenv, None, <fenv.h>, "c99")
+SYMBOL_VERSION(fegetexceptflag, None, <fenv.h>, "c99")
+SYMBOL_VERSION(fegetround, None, <fenv.h>, "c99")
+SYMBOL_VERSION(feholdexcept, None, <fenv.h>, "c99")
+SYMBOL_VERSION(fenv_t, None, <fenv.h>, "c99")
SYMBOL(feof, None, <stdio.h>)
-SYMBOL(feraiseexcept, None, <fenv.h>)
+SYMBOL_VERSION(feraiseexcept, None, <fenv.h>, "c99")
SYMBOL(ferror, None, <stdio.h>)
-SYMBOL(fesetenv, None, <fenv.h>)
-SYMBOL(fesetexceptflag, None, <fenv.h>)
-SYMBOL(fesetround, None, <fenv.h>)
-SYMBOL(fetestexcept, None, <fenv.h>)
-SYMBOL(feupdateenv, None, <fenv.h>)
-SYMBOL(fexcept_t, None, <fenv.h>)
+SYMBOL_VERSION(fesetenv, None, <fenv.h>, "c99")
+SYMBOL_VERSION(fesetexceptflag, None, <fenv.h>, "c99")
+SYMBOL_VERSION(fesetround, None, <fenv.h>, "c99")
+SYMBOL_VERSION(fetestexcept, None, <fenv.h>, "c99")
+SYMBOL_VERSION(feupdateenv, None, <fenv.h>, "c99")
+SYMBOL_VERSION(fexcept_t, None, <fenv.h>, "c99")
SYMBOL(fflush, None, <stdio.h>)
SYMBOL(fgetc, None, <stdio.h>)
SYMBOL(fgetpos, None, <stdio.h>)
SYMBOL(fgets, None, <stdio.h>)
SYMBOL(fgetwc, None, <wchar.h>)
SYMBOL(fgetws, None, <wchar.h>)
-SYMBOL(float_t, None, <math.h>)
+SYMBOL_VERSION(float_t, None, <math.h>, "c99")
SYMBOL(floor, None, <math.h>)
-SYMBOL(floorf, None, <math.h>)
-SYMBOL(floorl, None, <math.h>)
-SYMBOL(fma, None, <math.h>)
-SYMBOL(fmaf, None, <math.h>)
-SYMBOL(fmal, None, <math.h>)
-SYMBOL(fmax, None, <math.h>)
-SYMBOL(fmaxf, None, <math.h>)
-SYMBOL(fmaxl, None, <math.h>)
-SYMBOL(fmin, None, <math.h>)
-SYMBOL(fminf, None, <math.h>)
-SYMBOL(fminl, None, <math.h>)
+SYMBOL_VERSION(floorf, None, <math.h>, "c99")
+SYMBOL_VERSION(floorl, None, <math.h>, "c99")
+SYMBOL_VERSION(fma, None, <math.h>, "c99")
+SYMBOL_VERSION(fmaf, None, <math.h>, "c99")
+SYMBOL_VERSION(fmal, None, <math.h>, "c99")
+SYMBOL_VERSION(fmax, None, <math.h>, "c99")
+SYMBOL_VERSION(fmaxf, None, <math.h>, "c99")
+SYMBOL_VERSION(fmaxl, None, <math.h>, "c99")
+SYMBOL_VERSION(fmin, None, <math.h>, "c99")
+SYMBOL_VERSION(fminf, None, <math.h>, "c99")
+SYMBOL_VERSION(fminl, None, <math.h>, "c99")
SYMBOL(fmod, None, <math.h>)
-SYMBOL(fmodf, None, <math.h>)
-SYMBOL(fmodl, None, <math.h>)
+SYMBOL_VERSION(fmodf, None, <math.h>, "c99")
+SYMBOL_VERSION(fmodl, None, <math.h>, "c99")
SYMBOL(fopen, None, <stdio.h>)
-SYMBOL(fopen_s, None, <stdio.h>)
-SYMBOL(fpclassify, None, <math.h>)
+SYMBOL_VERSION(fopen_s, None, <stdio.h>, "c11")
SYMBOL(fpos_t, None, <stdio.h>)
SYMBOL(fprintf, None, <stdio.h>)
-SYMBOL(fprintf_s, None, <stdio.h>)
+SYMBOL_VERSION(fprintf_s, None, <stdio.h>, "c11")
SYMBOL(fputc, None, <stdio.h>)
SYMBOL(fputs, None, <stdio.h>)
SYMBOL(fputwc, None, <wchar.h>)
@@ -491,78 +252,68 @@ SYMBOL(fputws, None, <wchar.h>)
SYMBOL(fread, None, <stdio.h>)
SYMBOL(free, None, <stdlib.h>)
SYMBOL(freopen, None, <stdio.h>)
-SYMBOL(freopen_s, None, <stdio.h>)
+SYMBOL_VERSION(freopen_s, None, <stdio.h>, "c11")
SYMBOL(frexp, None, <math.h>)
-SYMBOL(frexpf, None, <math.h>)
-SYMBOL(frexpl, None, <math.h>)
+SYMBOL_VERSION(frexpf, None, <math.h>, "c99")
+SYMBOL_VERSION(frexpl, None, <math.h>, "c99")
SYMBOL(fscanf, None, <stdio.h>)
-SYMBOL(fscanf_s, None, <stdio.h>)
+SYMBOL_VERSION(fscanf_s, None, <stdio.h>, "c11")
SYMBOL(fseek, None, <stdio.h>)
SYMBOL(fsetpos, None, <stdio.h>)
SYMBOL(ftell, None, <stdio.h>)
SYMBOL(fwide, None, <wchar.h>)
SYMBOL(fwprintf, None, <wchar.h>)
-SYMBOL(fwprintf_s, None, <wchar.h>)
+SYMBOL_VERSION(fwprintf_s, None, <wchar.h>, "c11")
SYMBOL(fwrite, None, <stdio.h>)
SYMBOL(fwscanf, None, <wchar.h>)
-SYMBOL(fwscanf_s, None, <wchar.h>)
+SYMBOL_VERSION(fwscanf_s, None, <wchar.h>, "c11")
SYMBOL(getc, None, <stdio.h>)
SYMBOL(getchar, None, <stdio.h>)
SYMBOL(getenv, None, <stdlib.h>)
-SYMBOL(getenv_s, None, <stdlib.h>)
+SYMBOL_VERSION(getenv_s, None, <stdlib.h>, "c11")
SYMBOL(gets, None, <stdio.h>)
-SYMBOL(gets_s, None, <stdio.h>)
+SYMBOL_VERSION(gets_s, None, <stdio.h>, "c11")
SYMBOL(getwc, None, <wchar.h>)
SYMBOL(getwchar, None, <wchar.h>)
SYMBOL(gmtime, None, <time.h>)
-SYMBOL(gmtime_s, None, <time.h>)
-SYMBOL(hypot, None, <math.h>)
-SYMBOL(hypotf, None, <math.h>)
-SYMBOL(hypotl, None, <math.h>)
-SYMBOL(ignore_handler_s, None, <stdlib.h>)
-SYMBOL(ilogb, None, <math.h>)
-SYMBOL(ilogbf, None, <math.h>)
-SYMBOL(ilogbl, None, <math.h>)
-SYMBOL(imaginary, None, <complex.h>)
-SYMBOL(imaxabs, None, <inttypes.h>)
-SYMBOL(int16_t, None, <stdint.h>)
-SYMBOL(int32_t, None, <stdint.h>)
-SYMBOL(int64_t, None, <stdint.h>)
-SYMBOL(int8_t, None, <stdint.h>)
-SYMBOL(int_fast16_t, None, <stdint.h>)
-SYMBOL(int_fast32_t, None, <stdint.h>)
-SYMBOL(int_fast64_t, None, <stdint.h>)
-SYMBOL(int_fast8_t, None, <stdint.h>)
-SYMBOL(int_least16_t, None, <stdint.h>)
-SYMBOL(int_least32_t, None, <stdint.h>)
-SYMBOL(int_least64_t, None, <stdint.h>)
-SYMBOL(int_least8_t, None, <stdint.h>)
-SYMBOL(intmax_t, None, <stdint.h>)
-SYMBOL(intptr_t, None, <stdint.h>)
+SYMBOL(gmtime_r, None, <time.h>)
+SYMBOL_VERSION(gmtime_s, None, <time.h>, "c11")
+SYMBOL_VERSION(hypot, None, <math.h>, "c99")
+SYMBOL_VERSION(hypotf, None, <math.h>, "c99")
+SYMBOL_VERSION(hypotl, None, <math.h>, "c99")
+SYMBOL_VERSION(ignore_handler_s, None, <stdlib.h>, "c11")
+SYMBOL_VERSION(ilogb, None, <math.h>, "c99")
+SYMBOL_VERSION(ilogbf, None, <math.h>, "c99")
+SYMBOL_VERSION(ilogbl, None, <math.h>, "c99")
+SYMBOL_VERSION(imaxabs, None, <inttypes.h>, "c99")
+SYMBOL_VERSION(int16_t, None, <stdint.h>, "c99")
+SYMBOL_VERSION(int32_t, None, <stdint.h>, "c99")
+SYMBOL_VERSION(int64_t, None, <stdint.h>, "c99")
+SYMBOL_VERSION(int8_t, None, <stdint.h>, "c99")
+SYMBOL_VERSION(int_fast16_t, None, <stdint.h>, "c99")
+SYMBOL_VERSION(int_fast32_t, None, <stdint.h>, "c99")
+SYMBOL_VERSION(int_fast64_t, None, <stdint.h>, "c99")
+SYMBOL_VERSION(int_fast8_t, None, <stdint.h>, "c99")
+SYMBOL_VERSION(int_least16_t, None, <stdint.h>, "c99")
+SYMBOL_VERSION(int_least32_t, None, <stdint.h>, "c99")
+SYMBOL_VERSION(int_least64_t, None, <stdint.h>, "c99")
+SYMBOL_VERSION(int_least8_t, None, <stdint.h>, "c99")
+SYMBOL_VERSION(intmax_t, None, <stdint.h>, "c99")
+SYMBOL_VERSION(intptr_t, None, <stdint.h>, "c99")
SYMBOL(isalnum, None, <ctype.h>)
SYMBOL(isalpha, None, <ctype.h>)
-SYMBOL(isblank, None, <ctype.h>)
+SYMBOL_VERSION(isblank, None, <ctype.h>, "c99")
SYMBOL(iscntrl, None, <ctype.h>)
SYMBOL(isdigit, None, <ctype.h>)
-SYMBOL(isfinite, None, <math.h>)
SYMBOL(isgraph, None, <ctype.h>)
-SYMBOL(isgreater, None, <math.h>)
-SYMBOL(isgreaterequal, None, <math.h>)
-SYMBOL(isinf, None, <math.h>)
-SYMBOL(isless, None, <math.h>)
-SYMBOL(islessequal, None, <math.h>)
-SYMBOL(islessgreater, None, <math.h>)
SYMBOL(islower, None, <ctype.h>)
-SYMBOL(isnan, None, <math.h>)
-SYMBOL(isnormal, None, <math.h>)
SYMBOL(isprint, None, <ctype.h>)
SYMBOL(ispunct, None, <ctype.h>)
SYMBOL(isspace, None, <ctype.h>)
-SYMBOL(isunordered, None, <math.h>)
SYMBOL(isupper, None, <ctype.h>)
SYMBOL(iswalnum, None, <wctype.h>)
SYMBOL(iswalpha, None, <wctype.h>)
-SYMBOL(iswblank, None, <wctype.h>)
+SYMBOL_VERSION(iswblank, None, <wctype.h>, "c99")
SYMBOL(iswcntrl, None, <wctype.h>)
SYMBOL(iswctype, None, <wctype.h>)
SYMBOL(iswdigit, None, <wctype.h>)
@@ -575,115 +326,110 @@ SYMBOL(iswupper, None, <wctype.h>)
SYMBOL(iswxdigit, None, <wctype.h>)
SYMBOL(isxdigit, None, <ctype.h>)
SYMBOL(jmp_buf, None, <setjmp.h>)
-SYMBOL(kill_dependency, None, <stdatomic.h>)
SYMBOL(labs, None, <stdlib.h>)
SYMBOL(lconv, None, <locale.h>)
SYMBOL(ldexp, None, <math.h>)
-SYMBOL(ldexpf, None, <math.h>)
-SYMBOL(ldexpl, None, <math.h>)
-SYMBOL(lgamma, None, <math.h>)
-SYMBOL(lgammaf, None, <math.h>)
-SYMBOL(lgammal, None, <math.h>)
-SYMBOL(llabs, None, <stdlib.h>)
-SYMBOL(llrint, None, <math.h>)
-SYMBOL(llrintf, None, <math.h>)
-SYMBOL(llrintl, None, <math.h>)
-SYMBOL(llround, None, <math.h>)
-SYMBOL(llroundf, None, <math.h>)
-SYMBOL(llroundl, None, <math.h>)
+SYMBOL_VERSION(ldexpf, None, <math.h>, "c99")
+SYMBOL_VERSION(ldexpl, None, <math.h>, "c99")
+SYMBOL_VERSION(lgamma, None, <math.h>, "c99")
+SYMBOL_VERSION(lgammaf, None, <math.h>, "c99")
+SYMBOL_VERSION(lgammal, None, <math.h>, "c99")
+SYMBOL_VERSION(llabs, None, <stdlib.h>, "c99")
+SYMBOL_VERSION(llrint, None, <math.h>, "c99")
+SYMBOL_VERSION(llrintf, None, <math.h>, "c99")
+SYMBOL_VERSION(llrintl, None, <math.h>, "c99")
+SYMBOL_VERSION(llround, None, <math.h>, "c99")
+SYMBOL_VERSION(llroundf, None, <math.h>, "c99")
+SYMBOL_VERSION(llroundl, None, <math.h>, "c99")
SYMBOL(localeconv, None, <locale.h>)
SYMBOL(localtime, None, <time.h>)
-SYMBOL(localtime_s, None, <time.h>)
+SYMBOL(localtime_r, None, <time.h>)
+SYMBOL_VERSION(localtime_s, None, <time.h>, "c11")
SYMBOL(log, None, <math.h>)
SYMBOL(log10, None, <math.h>)
-SYMBOL(log10f, None, <math.h>)
-SYMBOL(log10l, None, <math.h>)
-SYMBOL(log1p, None, <math.h>)
-SYMBOL(log1pf, None, <math.h>)
-SYMBOL(log1pl, None, <math.h>)
-SYMBOL(log2, None, <math.h>)
-SYMBOL(log2f, None, <math.h>)
-SYMBOL(log2l, None, <math.h>)
-SYMBOL(logb, None, <math.h>)
-SYMBOL(logbf, None, <math.h>)
-SYMBOL(logbl, None, <math.h>)
-SYMBOL(logf, None, <math.h>)
-SYMBOL(logl, None, <math.h>)
+SYMBOL_VERSION(log10f, None, <math.h>, "c99")
+SYMBOL_VERSION(log10l, None, <math.h>, "c99")
+SYMBOL_VERSION(log1p, None, <math.h>, "c99")
+SYMBOL_VERSION(log1pf, None, <math.h>, "c99")
+SYMBOL_VERSION(log1pl, None, <math.h>, "c99")
+SYMBOL_VERSION(log2, None, <math.h>, "c99")
+SYMBOL_VERSION(log2f, None, <math.h>, "c99")
+SYMBOL_VERSION(log2l, None, <math.h>, "c99")
+SYMBOL_VERSION(logb, None, <math.h>, "c99")
+SYMBOL_VERSION(logbf, None, <math.h>, "c99")
+SYMBOL_VERSION(logbl, None, <math.h>, "c99")
+SYMBOL_VERSION(logf, None, <math.h>, "c99")
+SYMBOL_VERSION(logl, None, <math.h>, "c99")
SYMBOL(longjmp, None, <setjmp.h>)
-SYMBOL(lrint, None, <math.h>)
-SYMBOL(lrintf, None, <math.h>)
-SYMBOL(lrintl, None, <math.h>)
-SYMBOL(lround, None, <math.h>)
-SYMBOL(lroundf, None, <math.h>)
-SYMBOL(lroundl, None, <math.h>)
+SYMBOL_VERSION(lrint, None, <math.h>, "c99")
+SYMBOL_VERSION(lrintf, None, <math.h>, "c99")
+SYMBOL_VERSION(lrintl, None, <math.h>, "c99")
+SYMBOL_VERSION(lround, None, <math.h>, "c99")
+SYMBOL_VERSION(lroundf, None, <math.h>, "c99")
+SYMBOL_VERSION(lroundl, None, <math.h>, "c99")
SYMBOL(malloc, None, <stdlib.h>)
-SYMBOL(math_errhandling, None, <math.h>)
-SYMBOL(max_align_t, None, <stddef.h>)
+SYMBOL_VERSION(max_align_t, None, <stddef.h>, "c11")
SYMBOL(mblen, None, <stdlib.h>)
SYMBOL(mbrlen, None, <wchar.h>)
-SYMBOL(mbrtoc16, None, <uchar.h>)
-SYMBOL(mbrtoc32, None, <uchar.h>)
+SYMBOL_VERSION(mbrtoc16, None, <uchar.h>, "c11")
+SYMBOL_VERSION(mbrtoc32, None, <uchar.h>, "c11")
SYMBOL(mbrtowc, None, <wchar.h>)
SYMBOL(mbsinit, None, <wchar.h>)
SYMBOL(mbsrtowcs, None, <wchar.h>)
-SYMBOL(mbsrtowcs_s, None, <wchar.h>)
+SYMBOL_VERSION(mbsrtowcs_s, None, <wchar.h>, "c11")
SYMBOL(mbstowcs, None, <stdlib.h>)
-SYMBOL(mbstowcs_s, None, <stdlib.h>)
+SYMBOL_VERSION(mbstowcs_s, None, <stdlib.h>, "c11")
SYMBOL(mbtowc, None, <stdlib.h>)
+SYMBOL(memccpy, None, <string.h>)
SYMBOL(memchr, None, <string.h>)
SYMBOL(memcmp, None, <string.h>)
SYMBOL(memcpy, None, <string.h>)
-SYMBOL(memcpy_s, None, <string.h>)
+SYMBOL_VERSION(memcpy_s, None, <string.h>, "c11")
SYMBOL(memmove, None, <string.h>)
-SYMBOL(memmove_s, None, <string.h>)
-SYMBOL(memory_order, None, <stdatomic.h>)
-SYMBOL(memory_order_acq_rel, None, <stdatomic.h>)
-SYMBOL(memory_order_acquire, None, <stdatomic.h>)
-SYMBOL(memory_order_consume, None, <stdatomic.h>)
-SYMBOL(memory_order_relaxed, None, <stdatomic.h>)
-SYMBOL(memory_order_release, None, <stdatomic.h>)
-SYMBOL(memory_order_seq_cst, None, <stdatomic.h>)
+SYMBOL_VERSION(memmove_s, None, <string.h>, "c11")
+SYMBOL_VERSION(memory_order, None, <stdatomic.h>, "c11")
+SYMBOL_VERSION(memory_order_acq_rel, None, <stdatomic.h>, "c11")
+SYMBOL_VERSION(memory_order_acquire, None, <stdatomic.h>, "c11")
+SYMBOL_VERSION(memory_order_consume, None, <stdatomic.h>, "c11")
+SYMBOL_VERSION(memory_order_relaxed, None, <stdatomic.h>, "c11")
+SYMBOL_VERSION(memory_order_release, None, <stdatomic.h>, "c11")
+SYMBOL_VERSION(memory_order_seq_cst, None, <stdatomic.h>, "c11")
SYMBOL(memset, None, <string.h>)
-SYMBOL(memset_s, None, <string.h>)
+SYMBOL(memset_explicit, None, <string.h>)
+SYMBOL_VERSION(memset_s, None, <string.h>, "c11")
SYMBOL(mktime, None, <time.h>)
SYMBOL(modf, None, <math.h>)
-SYMBOL(modff, None, <math.h>)
-SYMBOL(modfl, None, <math.h>)
-SYMBOL(mtx_destroy, None, <threads.h>)
-SYMBOL(mtx_init, None, <threads.h>)
-SYMBOL(mtx_lock, None, <threads.h>)
-SYMBOL(mtx_plain, None, <threads.h>)
-SYMBOL(mtx_recursive, None, <threads.h>)
-SYMBOL(mtx_t, None, <threads.h>)
-SYMBOL(mtx_timed, None, <threads.h>)
-SYMBOL(mtx_timedlock, None, <threads.h>)
-SYMBOL(mtx_trylock, None, <threads.h>)
-SYMBOL(mtx_unlock, None, <threads.h>)
-SYMBOL(nan, None, <math.h>)
-SYMBOL(nanf, None, <math.h>)
-SYMBOL(nanl, None, <math.h>)
-SYMBOL(nearbyint, None, <math.h>)
-SYMBOL(nearbyintf, None, <math.h>)
-SYMBOL(nearbyintl, None, <math.h>)
-SYMBOL(nextafter, None, <math.h>)
-SYMBOL(nextafterf, None, <math.h>)
-SYMBOL(nextafterl, None, <math.h>)
-SYMBOL(nexttoward, None, <math.h>)
-SYMBOL(nexttowardf, None, <math.h>)
-SYMBOL(nexttowardl, None, <math.h>)
-SYMBOL(noreturn, None, <stdnoreturn.h>)
-SYMBOL(not, None, <iso646.h>)
-SYMBOL(not_eq, None, <iso646.h>)
-SYMBOL(offsetof, None, <stddef.h>)
-SYMBOL(once_flag, None, <threads.h>)
-SYMBOL(or, None, <iso646.h>)
-SYMBOL(or_eq, None, <iso646.h>)
+SYMBOL_VERSION(modff, None, <math.h>, "c99")
+SYMBOL_VERSION(modfl, None, <math.h>, "c99")
+SYMBOL_VERSION(mtx_destroy, None, <threads.h>, "c11")
+SYMBOL_VERSION(mtx_init, None, <threads.h>, "c11")
+SYMBOL_VERSION(mtx_lock, None, <threads.h>, "c11")
+SYMBOL_VERSION(mtx_plain, None, <threads.h>, "c11")
+SYMBOL_VERSION(mtx_recursive, None, <threads.h>, "c11")
+SYMBOL_VERSION(mtx_t, None, <threads.h>, "c11")
+SYMBOL_VERSION(mtx_timed, None, <threads.h>, "c11")
+SYMBOL_VERSION(mtx_timedlock, None, <threads.h>, "c11")
+SYMBOL_VERSION(mtx_trylock, None, <threads.h>, "c11")
+SYMBOL_VERSION(mtx_unlock, None, <threads.h>, "c11")
+SYMBOL_VERSION(nan, None, <math.h>, "c99")
+SYMBOL_VERSION(nanf, None, <math.h>, "c99")
+SYMBOL_VERSION(nanl, None, <math.h>, "c99")
+SYMBOL_VERSION(nearbyint, None, <math.h>, "c99")
+SYMBOL_VERSION(nearbyintf, None, <math.h>, "c99")
+SYMBOL_VERSION(nearbyintl, None, <math.h>, "c99")
+SYMBOL_VERSION(nextafter, None, <math.h>, "c99")
+SYMBOL_VERSION(nextafterf, None, <math.h>, "c99")
+SYMBOL_VERSION(nextafterl, None, <math.h>, "c99")
+SYMBOL_VERSION(nexttoward, None, <math.h>, "c99")
+SYMBOL_VERSION(nexttowardf, None, <math.h>, "c99")
+SYMBOL_VERSION(nexttowardl, None, <math.h>, "c99")
+SYMBOL_VERSION(once_flag, None, <threads.h>, "c11")
SYMBOL(perror, None, <stdio.h>)
SYMBOL(pow, None, <math.h>)
-SYMBOL(powf, None, <math.h>)
-SYMBOL(powl, None, <math.h>)
+SYMBOL_VERSION(powf, None, <math.h>, "c99")
+SYMBOL_VERSION(powl, None, <math.h>, "c99")
SYMBOL(printf, None, <stdio.h>)
-SYMBOL(printf_s, None, <stdio.h>)
+SYMBOL_VERSION(printf_s, None, <stdio.h>, "c11")
SYMBOL(ptrdiff_t, None, <stddef.h>)
SYMBOL(putc, None, <stdio.h>)
SYMBOL(putchar, None, <stdio.h>)
@@ -691,255 +437,244 @@ SYMBOL(puts, None, <stdio.h>)
SYMBOL(putwc, None, <wchar.h>)
SYMBOL(putwchar, None, <wchar.h>)
SYMBOL(qsort, None, <stdlib.h>)
-SYMBOL(qsort_s, None, <stdlib.h>)
-SYMBOL(quick_exit, None, <stdlib.h>)
+SYMBOL_VERSION(qsort_s, None, <stdlib.h>, "c11")
+SYMBOL_VERSION(quick_exit, None, <stdlib.h>, "c11")
SYMBOL(raise, None, <signal.h>)
SYMBOL(rand, None, <stdlib.h>)
SYMBOL(realloc, None, <stdlib.h>)
-SYMBOL(remainder, None, <math.h>)
-SYMBOL(remainderf, None, <math.h>)
-SYMBOL(remainderl, None, <math.h>)
+SYMBOL_VERSION(remainder, None, <math.h>, "c99")
+SYMBOL_VERSION(remainderf, None, <math.h>, "c99")
+SYMBOL_VERSION(remainderl, None, <math.h>, "c99")
SYMBOL(remove, None, <stdio.h>)
-SYMBOL(remquo, None, <math.h>)
-SYMBOL(remquof, None, <math.h>)
-SYMBOL(remquol, None, <math.h>)
+SYMBOL_VERSION(remquo, None, <math.h>, "c99")
+SYMBOL_VERSION(remquof, None, <math.h>, "c99")
+SYMBOL_VERSION(remquol, None, <math.h>, "c99")
SYMBOL(rename, None, <stdio.h>)
SYMBOL(rewind, None, <stdio.h>)
-SYMBOL(rint, None, <math.h>)
-SYMBOL(rintf, None, <math.h>)
-SYMBOL(rintl, None, <math.h>)
-SYMBOL(round, None, <math.h>)
-SYMBOL(roundf, None, <math.h>)
-SYMBOL(roundl, None, <math.h>)
-SYMBOL(rsize_t, None, <stddef.h>)
-SYMBOL(scalbln, None, <math.h>)
-SYMBOL(scalblnf, None, <math.h>)
-SYMBOL(scalblnl, None, <math.h>)
-SYMBOL(scalbn, None, <math.h>)
-SYMBOL(scalbnf, None, <math.h>)
-SYMBOL(scalbnl, None, <math.h>)
+SYMBOL_VERSION(rint, None, <math.h>, "c99")
+SYMBOL_VERSION(rintf, None, <math.h>, "c99")
+SYMBOL_VERSION(rintl, None, <math.h>, "c99")
+SYMBOL_VERSION(round, None, <math.h>, "c99")
+SYMBOL_VERSION(roundf, None, <math.h>, "c99")
+SYMBOL_VERSION(roundl, None, <math.h>, "c99")
+SYMBOL_VERSION(scalbln, None, <math.h>, "c99")
+SYMBOL_VERSION(scalblnf, None, <math.h>, "c99")
+SYMBOL_VERSION(scalblnl, None, <math.h>, "c99")
+SYMBOL_VERSION(scalbn, None, <math.h>, "c99")
+SYMBOL_VERSION(scalbnf, None, <math.h>, "c99")
+SYMBOL_VERSION(scalbnl, None, <math.h>, "c99")
SYMBOL(scanf, None, <stdio.h>)
-SYMBOL(scanf_s, None, <stdio.h>)
-SYMBOL(set_constraint_handler_s, None, <stdlib.h>)
+SYMBOL_VERSION(scanf_s, None, <stdio.h>, "c11")
+SYMBOL_VERSION(set_constraint_handler_s, None, <stdlib.h>, "c11")
SYMBOL(setbuf, None, <stdio.h>)
-SYMBOL(setjmp, None, <setjmp.h>)
SYMBOL(setlocale, None, <locale.h>)
SYMBOL(setvbuf, None, <stdio.h>)
SYMBOL(sig_atomic_t, None, <signal.h>)
SYMBOL(signal, None, <signal.h>)
-SYMBOL(signbit, None, <math.h>)
SYMBOL(sin, None, <math.h>)
-SYMBOL(sinf, None, <math.h>)
+SYMBOL_VERSION(sinf, None, <math.h>, "c99")
SYMBOL(sinh, None, <math.h>)
-SYMBOL(sinhf, None, <math.h>)
-SYMBOL(sinhl, None, <math.h>)
-SYMBOL(sinl, None, <math.h>)
-SYMBOL(snprintf, None, <stdio.h>)
-SYMBOL(snprintf_s, None, <stdio.h>)
-SYMBOL(snwprintf_s, None, <wchar.h>)
+SYMBOL_VERSION(sinhf, None, <math.h>, "c99")
+SYMBOL_VERSION(sinhl, None, <math.h>, "c99")
+SYMBOL_VERSION(sinl, None, <math.h>, "c99")
+SYMBOL_VERSION(snprintf, None, <stdio.h>, "c99")
+SYMBOL_VERSION(snprintf_s, None, <stdio.h>, "c11")
+SYMBOL_VERSION(snwprintf_s, None, <wchar.h>, "c11")
SYMBOL(sprintf, None, <stdio.h>)
-SYMBOL(sprintf_s, None, <stdio.h>)
+SYMBOL_VERSION(sprintf_s, None, <stdio.h>, "c11")
SYMBOL(sqrt, None, <math.h>)
-SYMBOL(sqrtf, None, <math.h>)
-SYMBOL(sqrtl, None, <math.h>)
+SYMBOL_VERSION(sqrtf, None, <math.h>, "c99")
+SYMBOL_VERSION(sqrtl, None, <math.h>, "c99")
SYMBOL(srand, None, <stdlib.h>)
SYMBOL(sscanf, None, <stdio.h>)
-SYMBOL(sscanf_s, None, <stdio.h>)
-SYMBOL(static_assert, None, <assert.h>)
-SYMBOL(stderr, None, <stdio.h>)
-SYMBOL(stdin, None, <stdio.h>)
-SYMBOL(stdout, None, <stdio.h>)
+SYMBOL_VERSION(sscanf_s, None, <stdio.h>, "c11")
SYMBOL(strcat, None, <string.h>)
-SYMBOL(strcat_s, None, <string.h>)
+SYMBOL_VERSION(strcat_s, None, <string.h>, "c11")
SYMBOL(strchr, None, <string.h>)
SYMBOL(strcmp, None, <string.h>)
SYMBOL(strcoll, None, <string.h>)
SYMBOL(strcpy, None, <string.h>)
-SYMBOL(strcpy_s, None, <string.h>)
+SYMBOL_VERSION(strcpy_s, None, <string.h>, "c11")
SYMBOL(strcspn, None, <string.h>)
+SYMBOL(strdup, None, <string.h>)
SYMBOL(strerror, None, <string.h>)
-SYMBOL(strerror_s, None, <string.h>)
-SYMBOL(strerrorlen_s, None, <string.h>)
+SYMBOL_VERSION(strerror_s, None, <string.h>, "c11")
+SYMBOL_VERSION(strerrorlen_s, None, <string.h>, "c11")
SYMBOL(strftime, None, <time.h>)
SYMBOL(strlen, None, <string.h>)
SYMBOL(strncat, None, <string.h>)
-SYMBOL(strncat_s, None, <string.h>)
+SYMBOL_VERSION(strncat_s, None, <string.h>, "c11")
SYMBOL(strncmp, None, <string.h>)
SYMBOL(strncpy, None, <string.h>)
-SYMBOL(strncpy_s, None, <string.h>)
-SYMBOL(strnlen_s, None, <string.h>)
+SYMBOL_VERSION(strncpy_s, None, <string.h>, "c11")
+SYMBOL(strndup, None, <string.h>)
+SYMBOL_VERSION(strnlen_s, None, <string.h>, "c11")
SYMBOL(strpbrk, None, <string.h>)
SYMBOL(strrchr, None, <string.h>)
SYMBOL(strspn, None, <string.h>)
SYMBOL(strstr, None, <string.h>)
SYMBOL(strtod, None, <stdlib.h>)
-SYMBOL(strtof, None, <stdlib.h>)
-SYMBOL(strtoimax, None, <inttypes.h>)
+SYMBOL_VERSION(strtof, None, <stdlib.h>, "c99")
+SYMBOL_VERSION(strtoimax, None, <inttypes.h>, "c99")
SYMBOL(strtok, None, <string.h>)
-SYMBOL(strtok_s, None, <string.h>)
+SYMBOL_VERSION(strtok_s, None, <string.h>, "c11")
SYMBOL(strtol, None, <stdlib.h>)
-SYMBOL(strtold, None, <stdlib.h>)
-SYMBOL(strtoll, None, <stdlib.h>)
+SYMBOL_VERSION(strtold, None, <stdlib.h>, "c99")
+SYMBOL_VERSION(strtoll, None, <stdlib.h>, "c99")
SYMBOL(strtoul, None, <stdlib.h>)
-SYMBOL(strtoull, None, <stdlib.h>)
-SYMBOL(strtoumax, None, <inttypes.h>)
+SYMBOL_VERSION(strtoull, None, <stdlib.h>, "c99")
+SYMBOL_VERSION(strtoumax, None, <inttypes.h>, "c99")
SYMBOL(strxfrm, None, <string.h>)
SYMBOL(swprintf, None, <wchar.h>)
-SYMBOL(swprintf_s, None, <wchar.h>)
+SYMBOL_VERSION(swprintf_s, None, <wchar.h>, "c11")
SYMBOL(swscanf, None, <wchar.h>)
-SYMBOL(swscanf_s, None, <wchar.h>)
+SYMBOL_VERSION(swscanf_s, None, <wchar.h>, "c11")
SYMBOL(system, None, <stdlib.h>)
SYMBOL(tan, None, <math.h>)
-SYMBOL(tanf, None, <math.h>)
-SYMBOL(tanh, None, <math.h>)
-SYMBOL(tanhf, None, <math.h>)
-SYMBOL(tanhl, None, <math.h>)
-SYMBOL(tanl, None, <math.h>)
-SYMBOL(tgamma, None, <math.h>)
-SYMBOL(tgammaf, None, <math.h>)
-SYMBOL(tgammal, None, <math.h>)
-SYMBOL(thrd_busy, None, <threads.h>)
-SYMBOL(thrd_create, None, <threads.h>)
-SYMBOL(thrd_current, None, <threads.h>)
-SYMBOL(thrd_detach, None, <threads.h>)
-SYMBOL(thrd_equal, None, <threads.h>)
-SYMBOL(thrd_error, None, <threads.h>)
-SYMBOL(thrd_join, None, <threads.h>)
-SYMBOL(thrd_nomem, None, <threads.h>)
-SYMBOL(thrd_sleep, None, <threads.h>)
-SYMBOL(thrd_start_t, None, <threads.h>)
-SYMBOL(thrd_success, None, <threads.h>)
-SYMBOL(thrd_t, None, <threads.h>)
-SYMBOL(thrd_timedout, None, <threads.h>)
-SYMBOL(thrd_yield, None, <threads.h>)
-SYMBOL(thread_local, None, <threads.h>)
+SYMBOL_VERSION(tanf, None, <math.h>, "c99")
+SYMBOL_VERSION(tanh, None, <math.h>, "c99")
+SYMBOL_VERSION(tanhf, None, <math.h>, "c99")
+SYMBOL_VERSION(tanhl, None, <math.h>, "c99")
+SYMBOL_VERSION(tanl, None, <math.h>, "c99")
+SYMBOL_VERSION(tgamma, None, <math.h>, "c99")
+SYMBOL_VERSION(tgammaf, None, <math.h>, "c99")
+SYMBOL_VERSION(tgammal, None, <math.h>, "c99")
+SYMBOL_VERSION(thrd_busy, None, <threads.h>, "c11")
+SYMBOL_VERSION(thrd_create, None, <threads.h>, "c11")
+SYMBOL_VERSION(thrd_current, None, <threads.h>, "c11")
+SYMBOL_VERSION(thrd_detach, None, <threads.h>, "c11")
+SYMBOL_VERSION(thrd_equal, None, <threads.h>, "c11")
+SYMBOL_VERSION(thrd_error, None, <threads.h>, "c11")
+SYMBOL_VERSION(thrd_exit, None, <threads.h>, "c11")
+SYMBOL_VERSION(thrd_join, None, <threads.h>, "c11")
+SYMBOL_VERSION(thrd_nomem, None, <threads.h>, "c11")
+SYMBOL_VERSION(thrd_sleep, None, <threads.h>, "c11")
+SYMBOL_VERSION(thrd_start_t, None, <threads.h>, "c11")
+SYMBOL_VERSION(thrd_success, None, <threads.h>, "c11")
+SYMBOL_VERSION(thrd_t, None, <threads.h>, "c11")
+SYMBOL_VERSION(thrd_timedout, None, <threads.h>, "c11")
+SYMBOL_VERSION(thrd_yield, None, <threads.h>, "c11")
SYMBOL(time, None, <time.h>)
SYMBOL(time_t, None, <time.h>)
-SYMBOL(timespec, None, <time.h>)
-SYMBOL(timespec_get, None, <time.h>)
+SYMBOL_VERSION(timespec, None, <time.h>, "c11")
+SYMBOL_VERSION(timespec_get, None, <time.h>, "c11")
+SYMBOL(timespec_getres, None, <time.h>)
SYMBOL(tm, None, <time.h>)
SYMBOL(tmpfile, None, <stdio.h>)
-SYMBOL(tmpfile_s, None, <stdio.h>)
+SYMBOL_VERSION(tmpfile_s, None, <stdio.h>, "c11")
SYMBOL(tmpnam, None, <stdio.h>)
-SYMBOL(tmpnam_s, None, <stdio.h>)
+SYMBOL_VERSION(tmpnam_s, None, <stdio.h>, "c11")
SYMBOL(tolower, None, <ctype.h>)
SYMBOL(toupper, None, <ctype.h>)
SYMBOL(towctrans, None, <wctype.h>)
SYMBOL(towlower, None, <wctype.h>)
SYMBOL(towupper, None, <wctype.h>)
-SYMBOL(trunc, None, <math.h>)
-SYMBOL(truncf, None, <math.h>)
-SYMBOL(truncl, None, <math.h>)
-SYMBOL(tss_create, None, <threads.h>)
-SYMBOL(tss_delete, None, <threads.h>)
-SYMBOL(tss_dtor_t, None, <threads.h>)
-SYMBOL(tss_get, None, <threads.h>)
-SYMBOL(tss_set, None, <threads.h>)
-SYMBOL(tss_t, None, <threads.h>)
-SYMBOL(uint16_t, None, <stdint.h>)
-SYMBOL(uint32_t, None, <stdint.h>)
-SYMBOL(uint64_t, None, <stdint.h>)
-SYMBOL(uint8_t, None, <stdint.h>)
-SYMBOL(uint_fast16_t, None, <stdint.h>)
-SYMBOL(uint_fast32_t, None, <stdint.h>)
-SYMBOL(uint_fast64_t, None, <stdint.h>)
-SYMBOL(uint_fast8_t, None, <stdint.h>)
-SYMBOL(uint_least16_t, None, <stdint.h>)
-SYMBOL(uint_least32_t, None, <stdint.h>)
-SYMBOL(uint_least64_t, None, <stdint.h>)
-SYMBOL(uint_least8_t, None, <stdint.h>)
-SYMBOL(uintmax_t, None, <stdint.h>)
-SYMBOL(uintptr_t, None, <stdint.h>)
+SYMBOL_VERSION(trunc, None, <math.h>, "c99")
+SYMBOL_VERSION(truncf, None, <math.h>, "c99")
+SYMBOL_VERSION(truncl, None, <math.h>, "c99")
+SYMBOL_VERSION(tss_create, None, <threads.h>, "c11")
+SYMBOL_VERSION(tss_delete, None, <threads.h>, "c11")
+SYMBOL_VERSION(tss_dtor_t, None, <threads.h>, "c11")
+SYMBOL_VERSION(tss_get, None, <threads.h>, "c11")
+SYMBOL_VERSION(tss_set, None, <threads.h>, "c11")
+SYMBOL_VERSION(tss_t, None, <threads.h>, "c11")
+SYMBOL_VERSION(uint16_t, None, <stdint.h>, "c99")
+SYMBOL_VERSION(uint32_t, None, <stdint.h>, "c99")
+SYMBOL_VERSION(uint64_t, None, <stdint.h>, "c99")
+SYMBOL_VERSION(uint8_t, None, <stdint.h>, "c99")
+SYMBOL_VERSION(uint_fast16_t, None, <stdint.h>, "c99")
+SYMBOL_VERSION(uint_fast32_t, None, <stdint.h>, "c99")
+SYMBOL_VERSION(uint_fast64_t, None, <stdint.h>, "c99")
+SYMBOL_VERSION(uint_fast8_t, None, <stdint.h>, "c99")
+SYMBOL_VERSION(uint_least16_t, None, <stdint.h>, "c99")
+SYMBOL_VERSION(uint_least32_t, None, <stdint.h>, "c99")
+SYMBOL_VERSION(uint_least64_t, None, <stdint.h>, "c99")
+SYMBOL_VERSION(uint_least8_t, None, <stdint.h>, "c99")
+SYMBOL_VERSION(uintmax_t, None, <stdint.h>, "c99")
+SYMBOL_VERSION(uintptr_t, None, <stdint.h>, "c99")
SYMBOL(ungetc, None, <stdio.h>)
SYMBOL(ungetwc, None, <wchar.h>)
-SYMBOL(va_arg, None, <stdarg.h>)
-SYMBOL(va_copy, None, <stdarg.h>)
-SYMBOL(va_end, None, <stdarg.h>)
-SYMBOL(va_start, None, <stdarg.h>)
SYMBOL(vfprintf, None, <stdio.h>)
-SYMBOL(vfprintf_s, None, <stdio.h>)
-SYMBOL(vfscanf, None, <stdio.h>)
-SYMBOL(vfscanf_s, None, <stdio.h>)
+SYMBOL_VERSION(vfprintf_s, None, <stdio.h>, "c11")
+SYMBOL_VERSION(vfscanf, None, <stdio.h>, "c99")
+SYMBOL_VERSION(vfscanf_s, None, <stdio.h>, "c11")
SYMBOL(vfwprintf, None, <wchar.h>)
-SYMBOL(vfwprintf_s, None, <wchar.h>)
-SYMBOL(vfwscanf, None, <wchar.h>)
-SYMBOL(vfwscanf_s, None, <wchar.h>)
+SYMBOL_VERSION(vfwprintf_s, None, <wchar.h>, "c11")
+SYMBOL_VERSION(vfwscanf, None, <wchar.h>, "c99")
+SYMBOL_VERSION(vfwscanf_s, None, <wchar.h>, "c11")
SYMBOL(vprintf, None, <stdio.h>)
-SYMBOL(vprintf_s, None, <stdio.h>)
-SYMBOL(vscanf, None, <stdio.h>)
-SYMBOL(vscanf_s, None, <stdio.h>)
-SYMBOL(vsnprintf, None, <stdio.h>)
-SYMBOL(vsnprintf_s, None, <stdio.h>)
-SYMBOL(vsnwprintf_s, None, <wchar.h>)
+SYMBOL_VERSION(vprintf_s, None, <stdio.h>, "c11")
+SYMBOL_VERSION(vscanf, None, <stdio.h>, "c99")
+SYMBOL_VERSION(vscanf_s, None, <stdio.h>, "c11")
+SYMBOL_VERSION(vsnprintf, None, <stdio.h>, "c99")
+SYMBOL_VERSION(vsnprintf_s, None, <stdio.h>, "c11")
+SYMBOL_VERSION(vsnwprintf_s, None, <wchar.h>, "c11")
SYMBOL(vsprintf, None, <stdio.h>)
-SYMBOL(vsprintf_s, None, <stdio.h>)
-SYMBOL(vsscanf, None, <stdio.h>)
-SYMBOL(vsscanf_s, None, <stdio.h>)
+SYMBOL_VERSION(vsprintf_s, None, <stdio.h>, "c11")
+SYMBOL_VERSION(vsscanf, None, <stdio.h>, "c99")
+SYMBOL_VERSION(vsscanf_s, None, <stdio.h>, "c11")
SYMBOL(vswprintf, None, <wchar.h>)
-SYMBOL(vswprintf_s, None, <wchar.h>)
-SYMBOL(vswscanf, None, <wchar.h>)
-SYMBOL(vswscanf_s, None, <wchar.h>)
+SYMBOL_VERSION(vswprintf_s, None, <wchar.h>, "c11")
+SYMBOL_VERSION(vswscanf, None, <wchar.h>, "c99")
+SYMBOL_VERSION(vswscanf_s, None, <wchar.h>, "c11")
SYMBOL(vwprintf, None, <wchar.h>)
-SYMBOL(vwprintf_s, None, <wchar.h>)
-SYMBOL(vwscanf, None, <wchar.h>)
-SYMBOL(vwscanf_s, None, <wchar.h>)
-SYMBOL(wchar_t, None, <wchar.h>)
+SYMBOL_VERSION(vwprintf_s, None, <wchar.h>, "c11")
+SYMBOL_VERSION(vwscanf, None, <wchar.h>, "c99")
+SYMBOL_VERSION(vwscanf_s, None, <wchar.h>, "c11")
SYMBOL(wcrtomb, None, <wchar.h>)
-SYMBOL(wcrtomb_s, None, <wchar.h>)
+SYMBOL_VERSION(wcrtomb_s, None, <wchar.h>, "c11")
SYMBOL(wcscat, None, <wchar.h>)
-SYMBOL(wcscat_s, None, <wchar.h>)
+SYMBOL_VERSION(wcscat_s, None, <wchar.h>, "c11")
SYMBOL(wcschr, None, <wchar.h>)
SYMBOL(wcscmp, None, <wchar.h>)
SYMBOL(wcscoll, None, <wchar.h>)
SYMBOL(wcscpy, None, <wchar.h>)
-SYMBOL(wcscpy_s, None, <wchar.h>)
+SYMBOL_VERSION(wcscpy_s, None, <wchar.h>, "c11")
SYMBOL(wcscspn, None, <wchar.h>)
SYMBOL(wcsftime, None, <wchar.h>)
SYMBOL(wcslen, None, <wchar.h>)
SYMBOL(wcsncat, None, <wchar.h>)
-SYMBOL(wcsncat_s, None, <wchar.h>)
+SYMBOL_VERSION(wcsncat_s, None, <wchar.h>, "c11")
SYMBOL(wcsncmp, None, <wchar.h>)
SYMBOL(wcsncpy, None, <wchar.h>)
-SYMBOL(wcsncpy_s, None, <wchar.h>)
-SYMBOL(wcsnlen_s, None, <wchar.h>)
+SYMBOL_VERSION(wcsncpy_s, None, <wchar.h>, "c11")
+SYMBOL_VERSION(wcsnlen_s, None, <wchar.h>, "c11")
SYMBOL(wcspbrk, None, <wchar.h>)
SYMBOL(wcsrchr, None, <wchar.h>)
SYMBOL(wcsrtombs, None, <wchar.h>)
-SYMBOL(wcsrtombs_s, None, <wchar.h>)
+SYMBOL_VERSION(wcsrtombs_s, None, <wchar.h>, "c11")
SYMBOL(wcsspn, None, <wchar.h>)
SYMBOL(wcsstr, None, <wchar.h>)
SYMBOL(wcstod, None, <wchar.h>)
-SYMBOL(wcstof, None, <wchar.h>)
-SYMBOL(wcstoimax, None, <inttypes.h>)
+SYMBOL_VERSION(wcstof, None, <wchar.h>, "c99")
+SYMBOL_VERSION(wcstoimax, None, <inttypes.h>, "c99")
SYMBOL(wcstok, None, <wchar.h>)
-SYMBOL(wcstok_s, None, <wchar.h>)
+SYMBOL_VERSION(wcstok_s, None, <wchar.h>, "c11")
SYMBOL(wcstol, None, <wchar.h>)
-SYMBOL(wcstold, None, <wchar.h>)
-SYMBOL(wcstoll, None, <wchar.h>)
+SYMBOL_VERSION(wcstold, None, <wchar.h>, "c99")
+SYMBOL_VERSION(wcstoll, None, <wchar.h>, "c99")
SYMBOL(wcstombs, None, <stdlib.h>)
-SYMBOL(wcstombs_s, None, <stdlib.h>)
+SYMBOL_VERSION(wcstombs_s, None, <stdlib.h>, "c11")
SYMBOL(wcstoul, None, <wchar.h>)
-SYMBOL(wcstoull, None, <wchar.h>)
-SYMBOL(wcstoumax, None, <inttypes.h>)
+SYMBOL_VERSION(wcstoull, None, <wchar.h>, "c99")
+SYMBOL_VERSION(wcstoumax, None, <inttypes.h>, "c99")
SYMBOL(wcsxfrm, None, <wchar.h>)
SYMBOL(wctob, None, <wchar.h>)
SYMBOL(wctomb, None, <stdlib.h>)
-SYMBOL(wctomb_s, None, <stdlib.h>)
+SYMBOL_VERSION(wctomb_s, None, <stdlib.h>, "c11")
SYMBOL(wctrans, None, <wctype.h>)
SYMBOL(wctrans_t, None, <wctype.h>)
SYMBOL(wctype, None, <wctype.h>)
SYMBOL(wctype_t, None, <wctype.h>)
-SYMBOL(wint_t, None, <wctype.h>)
SYMBOL(wmemchr, None, <wchar.h>)
SYMBOL(wmemcmp, None, <wchar.h>)
SYMBOL(wmemcpy, None, <wchar.h>)
-SYMBOL(wmemcpy_s, None, <wchar.h>)
+SYMBOL_VERSION(wmemcpy_s, None, <wchar.h>, "c11")
SYMBOL(wmemmove, None, <wchar.h>)
-SYMBOL(wmemmove_s, None, <wchar.h>)
+SYMBOL_VERSION(wmemmove_s, None, <wchar.h>, "c11")
SYMBOL(wmemset, None, <wchar.h>)
SYMBOL(wprintf, None, <wchar.h>)
-SYMBOL(wprintf_s, None, <wchar.h>)
+SYMBOL_VERSION(wprintf_s, None, <wchar.h>, "c11")
SYMBOL(wscanf, None, <wchar.h>)
-SYMBOL(wscanf_s, None, <wchar.h>)
-SYMBOL(xor, None, <iso646.h>)
-SYMBOL(xor_eq, None, <iso646.h>)
+SYMBOL_VERSION(wscanf_s, None, <wchar.h>, "c11")
+// clang-format on
diff --git a/clang/lib/Tooling/Inclusions/Stdlib/StandardLibrary.cpp b/clang/lib/Tooling/Inclusions/Stdlib/StandardLibrary.cpp
index b88e6db7cceb7..562faa2cbf5eb 100644
--- a/clang/lib/Tooling/Inclusions/Stdlib/StandardLibrary.cpp
+++ b/clang/lib/Tooling/Inclusions/Stdlib/StandardLibrary.cpp
@@ -36,6 +36,9 @@ struct SymbolHeaderMapping {
const char *Data; // std::vector
unsigned ScopeLen; // ~~~~~
unsigned NameLen; // ~~~~~~
+ Version CurrentVersion;
+
+ Version version() const { return CurrentVersion; }
StringRef scope() const { return StringRef(Data, ScopeLen); }
StringRef name() const { return StringRef(Data + ScopeLen, NameLen); }
StringRef qualifiedName() const {
@@ -57,6 +60,7 @@ static const SymbolHeaderMapping *getMappingPerLang(Lang L) {
static int countSymbols(Lang Language) {
ArrayRef<const char *> Symbols;
#define SYMBOL(Name, NS, Header) #NS #Name,
+#define SYMBOL_VERSION(Name, NS, Header, Version) #NS #Name,
switch (Language) {
case Lang::C: {
static constexpr const char *CSymbols[] = {
@@ -77,6 +81,7 @@ static int countSymbols(Lang Language) {
}
}
#undef SYMBOL
+#undef SYMBOL_VERSION
return llvm::DenseSet<StringRef>(llvm::from_range, Symbols).size();
}
@@ -107,7 +112,8 @@ static int initialize(Lang Language) {
};
auto Add = [&, SymIndex(-1)](llvm::StringRef QName, unsigned NSLen,
- llvm::StringRef HeaderName) mutable {
+ llvm::StringRef HeaderName,
+ llvm::StringRef Ver) mutable {
// Correct "Nonefoo" => foo.
// FIXME: get rid of "None" from the generated mapping files.
if (QName.take_front(NSLen) == "None") {
@@ -128,10 +134,24 @@ static int initialize(Lang Language) {
// First symbol or new symbol, increment next available index.
++SymIndex;
} // Else use the same index.
+
+ Version CurrentVersion = llvm::StringSwitch<Version>(Ver)
+ .Case("c++11", CPlusPlus11)
+ .Case("c++14", CPlusPlus14)
+ .Case("c++17", CPlusPlus17)
+ .Case("c++20", CPlusPlus20)
+ .Case("c++23", CPlusPlus23)
+ .Case("c++26", CPlusPlus26)
+ .Case("c99", C99)
+ .Case("c11", C11)
+ .Case("unknown", Unknown)
+ .Default(Unknown);
+
Mapping->SymbolNames[SymIndex] = {
- QName.data(), NSLen, static_cast<unsigned int>(QName.size() - NSLen)};
+ QName.data(), NSLen, static_cast<unsigned int>(QName.size() - NSLen),
+ CurrentVersion};
if (!HeaderName.empty())
- Mapping->SymbolHeaderIDs[SymIndex].push_back(AddHeader(HeaderName));
+ Mapping->SymbolHeaderIDs[SymIndex].push_back(AddHeader(HeaderName));
NSSymbolMap &NSSymbols = AddNS(QName.take_front(NSLen));
NSSymbols.try_emplace(QName.drop_front(NSLen), SymIndex);
@@ -141,10 +161,14 @@ static int initialize(Lang Language) {
const char *QName;
unsigned NSLen;
const char *HeaderName;
+ const char *Version = "unknown";
};
#define SYMBOL(Name, NS, Header) \
{#NS #Name, static_cast<decltype(Symbol::NSLen)>(StringRef(#NS).size()), \
#Header},
+#define SYMBOL_VERSION(Name, NS, Header, Version) \
+ {#NS #Name, static_cast<decltype(Symbol::NSLen)>(StringRef(#NS).size()), \
+ #Header, Version},
switch (Language) {
case Lang::C: {
static constexpr Symbol CSymbols[] = {
@@ -152,7 +176,7 @@ static int initialize(Lang Language) {
#include "CSymbolMap.inc"
};
for (const Symbol &S : CSymbols)
- Add(S.QName, S.NSLen, S.HeaderName);
+ Add(S.QName, S.NSLen, S.HeaderName, S.Version);
break;
}
case Lang::CXX: {
@@ -162,11 +186,12 @@ static int initialize(Lang Language) {
#include "StdTsSymbolMap.inc"
};
for (const Symbol &S : CXXSymbols)
- Add(S.QName, S.NSLen, S.HeaderName);
+ Add(S.QName, S.NSLen, S.HeaderName, S.Version);
break;
}
}
#undef SYMBOL
+#undef SYMBOL_VERSION
Mapping->HeaderNames = new llvm::StringRef[Mapping->HeaderIDs->size()];
for (const auto &E : *Mapping->HeaderIDs)
@@ -223,6 +248,9 @@ llvm::StringRef Symbol::name() const {
llvm::StringRef Symbol::qualifiedName() const {
return getMappingPerLang(Language)->SymbolNames[ID].qualifiedName();
}
+Version Symbol::version() const {
+ return getMappingPerLang(Language)->SymbolNames[ID].version();
+}
std::optional<Symbol> Symbol::named(llvm::StringRef Scope, llvm::StringRef Name,
Lang L) {
ensureInitialized();
@@ -320,6 +348,28 @@ std::optional<Symbol> Recognizer::operator()(const Decl *D) {
return Symbol(It->second, L);
}
+llvm::StringRef GetAsString(Version Ver) {
+ switch (Ver) {
+ case tooling::stdlib::CPlusPlus11:
+ return "c++11";
+ case tooling::stdlib::CPlusPlus14:
+ return "c++14";
+ case tooling::stdlib::CPlusPlus17:
+ return "c++17";
+ case tooling::stdlib::CPlusPlus20:
+ return "c++20";
+ case tooling::stdlib::CPlusPlus23:
+ return "c++23";
+ case tooling::stdlib::CPlusPlus26:
+ return "c++26";
+ case tooling::stdlib::C99:
+ return "c99";
+ case tooling::stdlib::C11:
+ return "c11";
+ default:
+ llvm_unreachable("other optinos shouldn't be possible!");
+ }
+}
} // namespace stdlib
} // namespace tooling
} // namespace clang
diff --git a/clang/lib/Tooling/Inclusions/Stdlib/StdSpecialSymbolMap.inc b/clang/lib/Tooling/Inclusions/Stdlib/StdSpecialSymbolMap.inc
index a2c12007134d6..1973f19e9b1ad 100644
--- a/clang/lib/Tooling/Inclusions/Stdlib/StdSpecialSymbolMap.inc
+++ b/clang/lib/Tooling/Inclusions/Stdlib/StdSpecialSymbolMap.inc
@@ -447,11 +447,6 @@ SYMBOL(erase_if, std::, /*no headers*/)
SYMBOL(div, std::, <cstdlib>)
SYMBOL(abort, std::, <cstdlib>)
-SYMBOL(binary_search, std::ranges::, <algorithm>)
-SYMBOL(equal_range, std::ranges::, <algorithm>)
-SYMBOL(lower_bound, std::ranges::, <algorithm>)
-SYMBOL(upper_bound, std::ranges::, <algorithm>)
-
SYMBOL(unwrap_reference_t, std::, <type_traits>)
// These are C symbols that are not under std namespace.
diff --git a/clang/lib/Tooling/Inclusions/Stdlib/StdSymbolMap.inc b/clang/lib/Tooling/Inclusions/Stdlib/StdSymbolMap.inc
index c1927180d3397..3212bf00f357a 100644
--- a/clang/lib/Tooling/Inclusions/Stdlib/StdSymbolMap.inc
+++ b/clang/lib/Tooling/Inclusions/Stdlib/StdSymbolMap.inc
@@ -6,22 +6,23 @@
// This file was generated automatically by
// clang/tools/include-mapping/gen_std.py, DO NOT EDIT!
//
-// Generated from cppreference offline HTML book (modified on 2024-11-10).
+// Generated from cppreference offline HTML book (modified on 2025-02-10).
//===----------------------------------------------------------------------===//
-SYMBOL(ATOMIC_BOOL_LOCK_FREE, None, <atomic>)
-SYMBOL(ATOMIC_CHAR16_T_LOCK_FREE, None, <atomic>)
-SYMBOL(ATOMIC_CHAR32_T_LOCK_FREE, None, <atomic>)
-SYMBOL(ATOMIC_CHAR8_T_LOCK_FREE, None, <atomic>)
-SYMBOL(ATOMIC_CHAR_LOCK_FREE, None, <atomic>)
-SYMBOL(ATOMIC_FLAG_INIT, None, <atomic>)
-SYMBOL(ATOMIC_INT_LOCK_FREE, None, <atomic>)
-SYMBOL(ATOMIC_LLONG_LOCK_FREE, None, <atomic>)
-SYMBOL(ATOMIC_LONG_LOCK_FREE, None, <atomic>)
-SYMBOL(ATOMIC_POINTER_LOCK_FREE, None, <atomic>)
-SYMBOL(ATOMIC_SHORT_LOCK_FREE, None, <atomic>)
-SYMBOL(ATOMIC_VAR_INIT, None, <atomic>)
-SYMBOL(ATOMIC_WCHAR_T_LOCK_FREE, None, <atomic>)
+// clang-format off
+SYMBOL_VERSION(ATOMIC_BOOL_LOCK_FREE, None, <atomic>, "c++11")
+SYMBOL_VERSION(ATOMIC_CHAR16_T_LOCK_FREE, None, <atomic>, "c++11")
+SYMBOL_VERSION(ATOMIC_CHAR32_T_LOCK_FREE, None, <atomic>, "c++11")
+SYMBOL_VERSION(ATOMIC_CHAR8_T_LOCK_FREE, None, <atomic>, "c++20")
+SYMBOL_VERSION(ATOMIC_CHAR_LOCK_FREE, None, <atomic>, "c++11")
+SYMBOL_VERSION(ATOMIC_FLAG_INIT, None, <atomic>, "c++11")
+SYMBOL_VERSION(ATOMIC_INT_LOCK_FREE, None, <atomic>, "c++11")
+SYMBOL_VERSION(ATOMIC_LLONG_LOCK_FREE, None, <atomic>, "c++11")
+SYMBOL_VERSION(ATOMIC_LONG_LOCK_FREE, None, <atomic>, "c++11")
+SYMBOL_VERSION(ATOMIC_POINTER_LOCK_FREE, None, <atomic>, "c++11")
+SYMBOL_VERSION(ATOMIC_SHORT_LOCK_FREE, None, <atomic>, "c++11")
+SYMBOL_VERSION(ATOMIC_VAR_INIT, None, <atomic>, "c++11")
+SYMBOL_VERSION(ATOMIC_WCHAR_T_LOCK_FREE, None, <atomic>, "c++11")
SYMBOL(BUFSIZ, None, <cstdio>)
SYMBOL(BUFSIZ, None, <stdio.h>)
SYMBOL(CHAR_BIT, None, <climits>)
@@ -32,13 +33,13 @@ SYMBOL(CHAR_MIN, None, <climits>)
SYMBOL(CHAR_MIN, None, <limits.h>)
SYMBOL(CLOCKS_PER_SEC, None, <ctime>)
SYMBOL(CLOCKS_PER_SEC, None, <time.h>)
-SYMBOL(DBL_DECIMAL_DIG, None, <cfloat>)
+SYMBOL_VERSION(DBL_DECIMAL_DIG, None, <cfloat>, "c++17")
SYMBOL(DBL_DECIMAL_DIG, None, <float.h>)
SYMBOL(DBL_DIG, None, <cfloat>)
SYMBOL(DBL_DIG, None, <float.h>)
SYMBOL(DBL_EPSILON, None, <cfloat>)
SYMBOL(DBL_EPSILON, None, <float.h>)
-SYMBOL(DBL_HAS_SUBNORM, None, <cfloat>)
+SYMBOL_VERSION(DBL_HAS_SUBNORM, None, <cfloat>, "c++17")
SYMBOL(DBL_HAS_SUBNORM, None, <float.h>)
SYMBOL(DBL_MANT_DIG, None, <cfloat>)
SYMBOL(DBL_MANT_DIG, None, <float.h>)
@@ -54,205 +55,205 @@ SYMBOL(DBL_MIN_10_EXP, None, <cfloat>)
SYMBOL(DBL_MIN_10_EXP, None, <float.h>)
SYMBOL(DBL_MIN_EXP, None, <cfloat>)
SYMBOL(DBL_MIN_EXP, None, <float.h>)
-SYMBOL(DBL_TRUE_MIN, None, <cfloat>)
+SYMBOL_VERSION(DBL_TRUE_MIN, None, <cfloat>, "c++17")
SYMBOL(DBL_TRUE_MIN, None, <float.h>)
-SYMBOL(DECIMAL_DIG, None, <cfloat>)
+SYMBOL_VERSION(DECIMAL_DIG, None, <cfloat>, "c++11")
SYMBOL(DECIMAL_DIG, None, <float.h>)
-SYMBOL(E2BIG, None, <cerrno>)
+SYMBOL_VERSION(E2BIG, None, <cerrno>, "c++11")
SYMBOL(E2BIG, None, <errno.h>)
-SYMBOL(EACCES, None, <cerrno>)
+SYMBOL_VERSION(EACCES, None, <cerrno>, "c++11")
SYMBOL(EACCES, None, <errno.h>)
-SYMBOL(EADDRINUSE, None, <cerrno>)
+SYMBOL_VERSION(EADDRINUSE, None, <cerrno>, "c++11")
SYMBOL(EADDRINUSE, None, <errno.h>)
-SYMBOL(EADDRNOTAVAIL, None, <cerrno>)
+SYMBOL_VERSION(EADDRNOTAVAIL, None, <cerrno>, "c++11")
SYMBOL(EADDRNOTAVAIL, None, <errno.h>)
-SYMBOL(EAFNOSUPPORT, None, <cerrno>)
+SYMBOL_VERSION(EAFNOSUPPORT, None, <cerrno>, "c++11")
SYMBOL(EAFNOSUPPORT, None, <errno.h>)
-SYMBOL(EAGAIN, None, <cerrno>)
+SYMBOL_VERSION(EAGAIN, None, <cerrno>, "c++11")
SYMBOL(EAGAIN, None, <errno.h>)
-SYMBOL(EALREADY, None, <cerrno>)
+SYMBOL_VERSION(EALREADY, None, <cerrno>, "c++11")
SYMBOL(EALREADY, None, <errno.h>)
-SYMBOL(EBADF, None, <cerrno>)
+SYMBOL_VERSION(EBADF, None, <cerrno>, "c++11")
SYMBOL(EBADF, None, <errno.h>)
-SYMBOL(EBADMSG, None, <cerrno>)
+SYMBOL_VERSION(EBADMSG, None, <cerrno>, "c++11")
SYMBOL(EBADMSG, None, <errno.h>)
-SYMBOL(EBUSY, None, <cerrno>)
+SYMBOL_VERSION(EBUSY, None, <cerrno>, "c++11")
SYMBOL(EBUSY, None, <errno.h>)
-SYMBOL(ECANCELED, None, <cerrno>)
+SYMBOL_VERSION(ECANCELED, None, <cerrno>, "c++11")
SYMBOL(ECANCELED, None, <errno.h>)
-SYMBOL(ECHILD, None, <cerrno>)
+SYMBOL_VERSION(ECHILD, None, <cerrno>, "c++11")
SYMBOL(ECHILD, None, <errno.h>)
-SYMBOL(ECONNABORTED, None, <cerrno>)
+SYMBOL_VERSION(ECONNABORTED, None, <cerrno>, "c++11")
SYMBOL(ECONNABORTED, None, <errno.h>)
-SYMBOL(ECONNREFUSED, None, <cerrno>)
+SYMBOL_VERSION(ECONNREFUSED, None, <cerrno>, "c++11")
SYMBOL(ECONNREFUSED, None, <errno.h>)
-SYMBOL(ECONNRESET, None, <cerrno>)
+SYMBOL_VERSION(ECONNRESET, None, <cerrno>, "c++11")
SYMBOL(ECONNRESET, None, <errno.h>)
-SYMBOL(EDEADLK, None, <cerrno>)
+SYMBOL_VERSION(EDEADLK, None, <cerrno>, "c++11")
SYMBOL(EDEADLK, None, <errno.h>)
-SYMBOL(EDESTADDRREQ, None, <cerrno>)
+SYMBOL_VERSION(EDESTADDRREQ, None, <cerrno>, "c++11")
SYMBOL(EDESTADDRREQ, None, <errno.h>)
SYMBOL(EDOM, None, <cerrno>)
SYMBOL(EDOM, None, <errno.h>)
-SYMBOL(EEXIST, None, <cerrno>)
+SYMBOL_VERSION(EEXIST, None, <cerrno>, "c++11")
SYMBOL(EEXIST, None, <errno.h>)
-SYMBOL(EFAULT, None, <cerrno>)
+SYMBOL_VERSION(EFAULT, None, <cerrno>, "c++11")
SYMBOL(EFAULT, None, <errno.h>)
-SYMBOL(EFBIG, None, <cerrno>)
+SYMBOL_VERSION(EFBIG, None, <cerrno>, "c++11")
SYMBOL(EFBIG, None, <errno.h>)
-SYMBOL(EHOSTUNREACH, None, <cerrno>)
+SYMBOL_VERSION(EHOSTUNREACH, None, <cerrno>, "c++11")
SYMBOL(EHOSTUNREACH, None, <errno.h>)
-SYMBOL(EIDRM, None, <cerrno>)
+SYMBOL_VERSION(EIDRM, None, <cerrno>, "c++11")
SYMBOL(EIDRM, None, <errno.h>)
-SYMBOL(EILSEQ, None, <cerrno>)
+SYMBOL_VERSION(EILSEQ, None, <cerrno>, "c++11")
SYMBOL(EILSEQ, None, <errno.h>)
-SYMBOL(EINPROGRESS, None, <cerrno>)
+SYMBOL_VERSION(EINPROGRESS, None, <cerrno>, "c++11")
SYMBOL(EINPROGRESS, None, <errno.h>)
-SYMBOL(EINTR, None, <cerrno>)
+SYMBOL_VERSION(EINTR, None, <cerrno>, "c++11")
SYMBOL(EINTR, None, <errno.h>)
-SYMBOL(EINVAL, None, <cerrno>)
+SYMBOL_VERSION(EINVAL, None, <cerrno>, "c++11")
SYMBOL(EINVAL, None, <errno.h>)
-SYMBOL(EIO, None, <cerrno>)
+SYMBOL_VERSION(EIO, None, <cerrno>, "c++11")
SYMBOL(EIO, None, <errno.h>)
-SYMBOL(EISCONN, None, <cerrno>)
+SYMBOL_VERSION(EISCONN, None, <cerrno>, "c++11")
SYMBOL(EISCONN, None, <errno.h>)
-SYMBOL(EISDIR, None, <cerrno>)
+SYMBOL_VERSION(EISDIR, None, <cerrno>, "c++11")
SYMBOL(EISDIR, None, <errno.h>)
-SYMBOL(ELOOP, None, <cerrno>)
+SYMBOL_VERSION(ELOOP, None, <cerrno>, "c++11")
SYMBOL(ELOOP, None, <errno.h>)
-SYMBOL(EMFILE, None, <cerrno>)
+SYMBOL_VERSION(EMFILE, None, <cerrno>, "c++11")
SYMBOL(EMFILE, None, <errno.h>)
-SYMBOL(EMLINK, None, <cerrno>)
+SYMBOL_VERSION(EMLINK, None, <cerrno>, "c++11")
SYMBOL(EMLINK, None, <errno.h>)
-SYMBOL(EMSGSIZE, None, <cerrno>)
+SYMBOL_VERSION(EMSGSIZE, None, <cerrno>, "c++11")
SYMBOL(EMSGSIZE, None, <errno.h>)
-SYMBOL(ENAMETOOLONG, None, <cerrno>)
+SYMBOL_VERSION(ENAMETOOLONG, None, <cerrno>, "c++11")
SYMBOL(ENAMETOOLONG, None, <errno.h>)
-SYMBOL(ENETDOWN, None, <cerrno>)
+SYMBOL_VERSION(ENETDOWN, None, <cerrno>, "c++11")
SYMBOL(ENETDOWN, None, <errno.h>)
-SYMBOL(ENETRESET, None, <cerrno>)
+SYMBOL_VERSION(ENETRESET, None, <cerrno>, "c++11")
SYMBOL(ENETRESET, None, <errno.h>)
-SYMBOL(ENETUNREACH, None, <cerrno>)
+SYMBOL_VERSION(ENETUNREACH, None, <cerrno>, "c++11")
SYMBOL(ENETUNREACH, None, <errno.h>)
-SYMBOL(ENFILE, None, <cerrno>)
+SYMBOL_VERSION(ENFILE, None, <cerrno>, "c++11")
SYMBOL(ENFILE, None, <errno.h>)
-SYMBOL(ENOBUFS, None, <cerrno>)
+SYMBOL_VERSION(ENOBUFS, None, <cerrno>, "c++11")
SYMBOL(ENOBUFS, None, <errno.h>)
-SYMBOL(ENODATA, None, <cerrno>)
+SYMBOL_VERSION(ENODATA, None, <cerrno>, "c++11")
SYMBOL(ENODATA, None, <errno.h>)
-SYMBOL(ENODEV, None, <cerrno>)
+SYMBOL_VERSION(ENODEV, None, <cerrno>, "c++11")
SYMBOL(ENODEV, None, <errno.h>)
-SYMBOL(ENOENT, None, <cerrno>)
+SYMBOL_VERSION(ENOENT, None, <cerrno>, "c++11")
SYMBOL(ENOENT, None, <errno.h>)
-SYMBOL(ENOEXEC, None, <cerrno>)
+SYMBOL_VERSION(ENOEXEC, None, <cerrno>, "c++11")
SYMBOL(ENOEXEC, None, <errno.h>)
-SYMBOL(ENOLCK, None, <cerrno>)
+SYMBOL_VERSION(ENOLCK, None, <cerrno>, "c++11")
SYMBOL(ENOLCK, None, <errno.h>)
-SYMBOL(ENOLINK, None, <cerrno>)
+SYMBOL_VERSION(ENOLINK, None, <cerrno>, "c++11")
SYMBOL(ENOLINK, None, <errno.h>)
-SYMBOL(ENOMEM, None, <cerrno>)
+SYMBOL_VERSION(ENOMEM, None, <cerrno>, "c++11")
SYMBOL(ENOMEM, None, <errno.h>)
-SYMBOL(ENOMSG, None, <cerrno>)
+SYMBOL_VERSION(ENOMSG, None, <cerrno>, "c++11")
SYMBOL(ENOMSG, None, <errno.h>)
-SYMBOL(ENOPROTOOPT, None, <cerrno>)
+SYMBOL_VERSION(ENOPROTOOPT, None, <cerrno>, "c++11")
SYMBOL(ENOPROTOOPT, None, <errno.h>)
-SYMBOL(ENOSPC, None, <cerrno>)
+SYMBOL_VERSION(ENOSPC, None, <cerrno>, "c++11")
SYMBOL(ENOSPC, None, <errno.h>)
-SYMBOL(ENOSR, None, <cerrno>)
+SYMBOL_VERSION(ENOSR, None, <cerrno>, "c++11")
SYMBOL(ENOSR, None, <errno.h>)
-SYMBOL(ENOSTR, None, <cerrno>)
+SYMBOL_VERSION(ENOSTR, None, <cerrno>, "c++11")
SYMBOL(ENOSTR, None, <errno.h>)
-SYMBOL(ENOSYS, None, <cerrno>)
+SYMBOL_VERSION(ENOSYS, None, <cerrno>, "c++11")
SYMBOL(ENOSYS, None, <errno.h>)
-SYMBOL(ENOTCONN, None, <cerrno>)
+SYMBOL_VERSION(ENOTCONN, None, <cerrno>, "c++11")
SYMBOL(ENOTCONN, None, <errno.h>)
-SYMBOL(ENOTDIR, None, <cerrno>)
+SYMBOL_VERSION(ENOTDIR, None, <cerrno>, "c++11")
SYMBOL(ENOTDIR, None, <errno.h>)
-SYMBOL(ENOTEMPTY, None, <cerrno>)
+SYMBOL_VERSION(ENOTEMPTY, None, <cerrno>, "c++11")
SYMBOL(ENOTEMPTY, None, <errno.h>)
-SYMBOL(ENOTRECOVERABLE, None, <cerrno>)
+SYMBOL_VERSION(ENOTRECOVERABLE, None, <cerrno>, "c++11")
SYMBOL(ENOTRECOVERABLE, None, <errno.h>)
-SYMBOL(ENOTSOCK, None, <cerrno>)
+SYMBOL_VERSION(ENOTSOCK, None, <cerrno>, "c++11")
SYMBOL(ENOTSOCK, None, <errno.h>)
-SYMBOL(ENOTSUP, None, <cerrno>)
+SYMBOL_VERSION(ENOTSUP, None, <cerrno>, "c++11")
SYMBOL(ENOTSUP, None, <errno.h>)
-SYMBOL(ENOTTY, None, <cerrno>)
+SYMBOL_VERSION(ENOTTY, None, <cerrno>, "c++11")
SYMBOL(ENOTTY, None, <errno.h>)
-SYMBOL(ENXIO, None, <cerrno>)
+SYMBOL_VERSION(ENXIO, None, <cerrno>, "c++11")
SYMBOL(ENXIO, None, <errno.h>)
SYMBOL(EOF, None, <cstdio>)
SYMBOL(EOF, None, <stdio.h>)
-SYMBOL(EOPNOTSUPP, None, <cerrno>)
+SYMBOL_VERSION(EOPNOTSUPP, None, <cerrno>, "c++11")
SYMBOL(EOPNOTSUPP, None, <errno.h>)
-SYMBOL(EOVERFLOW, None, <cerrno>)
+SYMBOL_VERSION(EOVERFLOW, None, <cerrno>, "c++11")
SYMBOL(EOVERFLOW, None, <errno.h>)
-SYMBOL(EOWNERDEAD, None, <cerrno>)
+SYMBOL_VERSION(EOWNERDEAD, None, <cerrno>, "c++11")
SYMBOL(EOWNERDEAD, None, <errno.h>)
-SYMBOL(EPERM, None, <cerrno>)
+SYMBOL_VERSION(EPERM, None, <cerrno>, "c++11")
SYMBOL(EPERM, None, <errno.h>)
-SYMBOL(EPIPE, None, <cerrno>)
+SYMBOL_VERSION(EPIPE, None, <cerrno>, "c++11")
SYMBOL(EPIPE, None, <errno.h>)
-SYMBOL(EPROTO, None, <cerrno>)
+SYMBOL_VERSION(EPROTO, None, <cerrno>, "c++11")
SYMBOL(EPROTO, None, <errno.h>)
-SYMBOL(EPROTONOSUPPORT, None, <cerrno>)
+SYMBOL_VERSION(EPROTONOSUPPORT, None, <cerrno>, "c++11")
SYMBOL(EPROTONOSUPPORT, None, <errno.h>)
-SYMBOL(EPROTOTYPE, None, <cerrno>)
+SYMBOL_VERSION(EPROTOTYPE, None, <cerrno>, "c++11")
SYMBOL(EPROTOTYPE, None, <errno.h>)
SYMBOL(ERANGE, None, <cerrno>)
SYMBOL(ERANGE, None, <errno.h>)
-SYMBOL(EROFS, None, <cerrno>)
+SYMBOL_VERSION(EROFS, None, <cerrno>, "c++11")
SYMBOL(EROFS, None, <errno.h>)
-SYMBOL(ESPIPE, None, <cerrno>)
+SYMBOL_VERSION(ESPIPE, None, <cerrno>, "c++11")
SYMBOL(ESPIPE, None, <errno.h>)
-SYMBOL(ESRCH, None, <cerrno>)
+SYMBOL_VERSION(ESRCH, None, <cerrno>, "c++11")
SYMBOL(ESRCH, None, <errno.h>)
-SYMBOL(ETIME, None, <cerrno>)
+SYMBOL_VERSION(ETIME, None, <cerrno>, "c++11")
SYMBOL(ETIME, None, <errno.h>)
-SYMBOL(ETIMEDOUT, None, <cerrno>)
+SYMBOL_VERSION(ETIMEDOUT, None, <cerrno>, "c++11")
SYMBOL(ETIMEDOUT, None, <errno.h>)
-SYMBOL(ETXTBSY, None, <cerrno>)
+SYMBOL_VERSION(ETXTBSY, None, <cerrno>, "c++11")
SYMBOL(ETXTBSY, None, <errno.h>)
-SYMBOL(EWOULDBLOCK, None, <cerrno>)
+SYMBOL_VERSION(EWOULDBLOCK, None, <cerrno>, "c++11")
SYMBOL(EWOULDBLOCK, None, <errno.h>)
-SYMBOL(EXDEV, None, <cerrno>)
+SYMBOL_VERSION(EXDEV, None, <cerrno>, "c++11")
SYMBOL(EXDEV, None, <errno.h>)
SYMBOL(EXIT_FAILURE, None, <cstdlib>)
SYMBOL(EXIT_FAILURE, None, <stdlib.h>)
SYMBOL(EXIT_SUCCESS, None, <cstdlib>)
SYMBOL(EXIT_SUCCESS, None, <stdlib.h>)
-SYMBOL(FE_ALL_EXCEPT, None, <cfenv>)
+SYMBOL_VERSION(FE_ALL_EXCEPT, None, <cfenv>, "c++11")
SYMBOL(FE_ALL_EXCEPT, None, <fenv.h>)
-SYMBOL(FE_DFL_ENV, None, <cfenv>)
+SYMBOL_VERSION(FE_DFL_ENV, None, <cfenv>, "c++11")
SYMBOL(FE_DFL_ENV, None, <fenv.h>)
-SYMBOL(FE_DIVBYZERO, None, <cfenv>)
+SYMBOL_VERSION(FE_DIVBYZERO, None, <cfenv>, "c++11")
SYMBOL(FE_DIVBYZERO, None, <fenv.h>)
-SYMBOL(FE_DOWNWARD, None, <cfenv>)
+SYMBOL_VERSION(FE_DOWNWARD, None, <cfenv>, "c++11")
SYMBOL(FE_DOWNWARD, None, <fenv.h>)
-SYMBOL(FE_INEXACT, None, <cfenv>)
+SYMBOL_VERSION(FE_INEXACT, None, <cfenv>, "c++11")
SYMBOL(FE_INEXACT, None, <fenv.h>)
-SYMBOL(FE_INVALID, None, <cfenv>)
+SYMBOL_VERSION(FE_INVALID, None, <cfenv>, "c++11")
SYMBOL(FE_INVALID, None, <fenv.h>)
-SYMBOL(FE_OVERFLOW, None, <cfenv>)
+SYMBOL_VERSION(FE_OVERFLOW, None, <cfenv>, "c++11")
SYMBOL(FE_OVERFLOW, None, <fenv.h>)
-SYMBOL(FE_TONEAREST, None, <cfenv>)
+SYMBOL_VERSION(FE_TONEAREST, None, <cfenv>, "c++11")
SYMBOL(FE_TONEAREST, None, <fenv.h>)
-SYMBOL(FE_TOWARDZERO, None, <cfenv>)
+SYMBOL_VERSION(FE_TOWARDZERO, None, <cfenv>, "c++11")
SYMBOL(FE_TOWARDZERO, None, <fenv.h>)
-SYMBOL(FE_UNDERFLOW, None, <cfenv>)
+SYMBOL_VERSION(FE_UNDERFLOW, None, <cfenv>, "c++11")
SYMBOL(FE_UNDERFLOW, None, <fenv.h>)
-SYMBOL(FE_UPWARD, None, <cfenv>)
+SYMBOL_VERSION(FE_UPWARD, None, <cfenv>, "c++11")
SYMBOL(FE_UPWARD, None, <fenv.h>)
SYMBOL(FILENAME_MAX, None, <cstdio>)
SYMBOL(FILENAME_MAX, None, <stdio.h>)
-SYMBOL(FLT_DECIMAL_DIG, None, <cfloat>)
+SYMBOL_VERSION(FLT_DECIMAL_DIG, None, <cfloat>, "c++17")
SYMBOL(FLT_DECIMAL_DIG, None, <float.h>)
SYMBOL(FLT_DIG, None, <cfloat>)
SYMBOL(FLT_DIG, None, <float.h>)
SYMBOL(FLT_EPSILON, None, <cfloat>)
SYMBOL(FLT_EPSILON, None, <float.h>)
-SYMBOL(FLT_EVAL_METHOD, None, <cfloat>)
+SYMBOL_VERSION(FLT_EVAL_METHOD, None, <cfloat>, "c++11")
SYMBOL(FLT_EVAL_METHOD, None, <float.h>)
-SYMBOL(FLT_HAS_SUBNORM, None, <cfloat>)
+SYMBOL_VERSION(FLT_HAS_SUBNORM, None, <cfloat>, "c++17")
SYMBOL(FLT_HAS_SUBNORM, None, <float.h>)
SYMBOL(FLT_MANT_DIG, None, <cfloat>)
SYMBOL(FLT_MANT_DIG, None, <float.h>)
@@ -272,93 +273,93 @@ SYMBOL(FLT_RADIX, None, <cfloat>)
SYMBOL(FLT_RADIX, None, <float.h>)
SYMBOL(FLT_ROUNDS, None, <cfloat>)
SYMBOL(FLT_ROUNDS, None, <float.h>)
-SYMBOL(FLT_TRUE_MIN, None, <cfloat>)
+SYMBOL_VERSION(FLT_TRUE_MIN, None, <cfloat>, "c++17")
SYMBOL(FLT_TRUE_MIN, None, <float.h>)
SYMBOL(FOPEN_MAX, None, <cstdio>)
SYMBOL(FOPEN_MAX, None, <stdio.h>)
-SYMBOL(FP_FAST_FMA, None, <cmath>)
+SYMBOL_VERSION(FP_FAST_FMA, None, <cmath>, "c++11")
SYMBOL(FP_FAST_FMA, None, <math.h>)
-SYMBOL(FP_FAST_FMAF, None, <cmath>)
+SYMBOL_VERSION(FP_FAST_FMAF, None, <cmath>, "c++11")
SYMBOL(FP_FAST_FMAF, None, <math.h>)
-SYMBOL(FP_FAST_FMAL, None, <cmath>)
+SYMBOL_VERSION(FP_FAST_FMAL, None, <cmath>, "c++11")
SYMBOL(FP_FAST_FMAL, None, <math.h>)
-SYMBOL(FP_ILOGB0, None, <cmath>)
+SYMBOL_VERSION(FP_ILOGB0, None, <cmath>, "c++11")
SYMBOL(FP_ILOGB0, None, <math.h>)
-SYMBOL(FP_ILOGBNAN, None, <cmath>)
+SYMBOL_VERSION(FP_ILOGBNAN, None, <cmath>, "c++11")
SYMBOL(FP_ILOGBNAN, None, <math.h>)
-SYMBOL(FP_INFINITE, None, <cmath>)
+SYMBOL_VERSION(FP_INFINITE, None, <cmath>, "c++11")
SYMBOL(FP_INFINITE, None, <math.h>)
-SYMBOL(FP_NAN, None, <cmath>)
+SYMBOL_VERSION(FP_NAN, None, <cmath>, "c++11")
SYMBOL(FP_NAN, None, <math.h>)
-SYMBOL(FP_NORMAL, None, <cmath>)
+SYMBOL_VERSION(FP_NORMAL, None, <cmath>, "c++11")
SYMBOL(FP_NORMAL, None, <math.h>)
-SYMBOL(FP_SUBNORMAL, None, <cmath>)
+SYMBOL_VERSION(FP_SUBNORMAL, None, <cmath>, "c++11")
SYMBOL(FP_SUBNORMAL, None, <math.h>)
-SYMBOL(FP_ZERO, None, <cmath>)
+SYMBOL_VERSION(FP_ZERO, None, <cmath>, "c++11")
SYMBOL(FP_ZERO, None, <math.h>)
SYMBOL(HUGE_VAL, None, <cmath>)
SYMBOL(HUGE_VAL, None, <math.h>)
-SYMBOL(HUGE_VALF, None, <cmath>)
+SYMBOL_VERSION(HUGE_VALF, None, <cmath>, "c++11")
SYMBOL(HUGE_VALF, None, <math.h>)
-SYMBOL(HUGE_VALL, None, <cmath>)
+SYMBOL_VERSION(HUGE_VALL, None, <cmath>, "c++11")
SYMBOL(HUGE_VALL, None, <math.h>)
-SYMBOL(INFINITY, None, <cmath>)
+SYMBOL_VERSION(INFINITY, None, <cmath>, "c++11")
SYMBOL(INFINITY, None, <math.h>)
-SYMBOL(INT16_MAX, None, <cstdint>)
+SYMBOL_VERSION(INT16_MAX, None, <cstdint>, "c++11")
SYMBOL(INT16_MAX, None, <stdint.h>)
-SYMBOL(INT16_MIN, None, <cstdint>)
+SYMBOL_VERSION(INT16_MIN, None, <cstdint>, "c++11")
SYMBOL(INT16_MIN, None, <stdint.h>)
-SYMBOL(INT32_MAX, None, <cstdint>)
+SYMBOL_VERSION(INT32_MAX, None, <cstdint>, "c++11")
SYMBOL(INT32_MAX, None, <stdint.h>)
-SYMBOL(INT32_MIN, None, <cstdint>)
+SYMBOL_VERSION(INT32_MIN, None, <cstdint>, "c++11")
SYMBOL(INT32_MIN, None, <stdint.h>)
-SYMBOL(INT64_MAX, None, <cstdint>)
+SYMBOL_VERSION(INT64_MAX, None, <cstdint>, "c++11")
SYMBOL(INT64_MAX, None, <stdint.h>)
-SYMBOL(INT64_MIN, None, <cstdint>)
+SYMBOL_VERSION(INT64_MIN, None, <cstdint>, "c++11")
SYMBOL(INT64_MIN, None, <stdint.h>)
-SYMBOL(INT8_MAX, None, <cstdint>)
+SYMBOL_VERSION(INT8_MAX, None, <cstdint>, "c++11")
SYMBOL(INT8_MAX, None, <stdint.h>)
-SYMBOL(INT8_MIN, None, <cstdint>)
+SYMBOL_VERSION(INT8_MIN, None, <cstdint>, "c++11")
SYMBOL(INT8_MIN, None, <stdint.h>)
-SYMBOL(INTMAX_MAX, None, <cstdint>)
+SYMBOL_VERSION(INTMAX_MAX, None, <cstdint>, "c++11")
SYMBOL(INTMAX_MAX, None, <stdint.h>)
-SYMBOL(INTMAX_MIN, None, <cstdint>)
+SYMBOL_VERSION(INTMAX_MIN, None, <cstdint>, "c++11")
SYMBOL(INTMAX_MIN, None, <stdint.h>)
-SYMBOL(INTPTR_MAX, None, <cstdint>)
+SYMBOL_VERSION(INTPTR_MAX, None, <cstdint>, "c++11")
SYMBOL(INTPTR_MAX, None, <stdint.h>)
-SYMBOL(INTPTR_MIN, None, <cstdint>)
+SYMBOL_VERSION(INTPTR_MIN, None, <cstdint>, "c++11")
SYMBOL(INTPTR_MIN, None, <stdint.h>)
-SYMBOL(INT_FAST16_MAX, None, <cstdint>)
+SYMBOL_VERSION(INT_FAST16_MAX, None, <cstdint>, "c++11")
SYMBOL(INT_FAST16_MAX, None, <stdint.h>)
-SYMBOL(INT_FAST16_MIN, None, <cstdint>)
+SYMBOL_VERSION(INT_FAST16_MIN, None, <cstdint>, "c++11")
SYMBOL(INT_FAST16_MIN, None, <stdint.h>)
-SYMBOL(INT_FAST32_MAX, None, <cstdint>)
+SYMBOL_VERSION(INT_FAST32_MAX, None, <cstdint>, "c++11")
SYMBOL(INT_FAST32_MAX, None, <stdint.h>)
-SYMBOL(INT_FAST32_MIN, None, <cstdint>)
+SYMBOL_VERSION(INT_FAST32_MIN, None, <cstdint>, "c++11")
SYMBOL(INT_FAST32_MIN, None, <stdint.h>)
-SYMBOL(INT_FAST64_MAX, None, <cstdint>)
+SYMBOL_VERSION(INT_FAST64_MAX, None, <cstdint>, "c++11")
SYMBOL(INT_FAST64_MAX, None, <stdint.h>)
-SYMBOL(INT_FAST64_MIN, None, <cstdint>)
+SYMBOL_VERSION(INT_FAST64_MIN, None, <cstdint>, "c++11")
SYMBOL(INT_FAST64_MIN, None, <stdint.h>)
-SYMBOL(INT_FAST8_MAX, None, <cstdint>)
+SYMBOL_VERSION(INT_FAST8_MAX, None, <cstdint>, "c++11")
SYMBOL(INT_FAST8_MAX, None, <stdint.h>)
-SYMBOL(INT_FAST8_MIN, None, <cstdint>)
+SYMBOL_VERSION(INT_FAST8_MIN, None, <cstdint>, "c++11")
SYMBOL(INT_FAST8_MIN, None, <stdint.h>)
-SYMBOL(INT_LEAST16_MAX, None, <cstdint>)
+SYMBOL_VERSION(INT_LEAST16_MAX, None, <cstdint>, "c++11")
SYMBOL(INT_LEAST16_MAX, None, <stdint.h>)
-SYMBOL(INT_LEAST16_MIN, None, <cstdint>)
+SYMBOL_VERSION(INT_LEAST16_MIN, None, <cstdint>, "c++11")
SYMBOL(INT_LEAST16_MIN, None, <stdint.h>)
-SYMBOL(INT_LEAST32_MAX, None, <cstdint>)
+SYMBOL_VERSION(INT_LEAST32_MAX, None, <cstdint>, "c++11")
SYMBOL(INT_LEAST32_MAX, None, <stdint.h>)
-SYMBOL(INT_LEAST32_MIN, None, <cstdint>)
+SYMBOL_VERSION(INT_LEAST32_MIN, None, <cstdint>, "c++11")
SYMBOL(INT_LEAST32_MIN, None, <stdint.h>)
-SYMBOL(INT_LEAST64_MAX, None, <cstdint>)
+SYMBOL_VERSION(INT_LEAST64_MAX, None, <cstdint>, "c++11")
SYMBOL(INT_LEAST64_MAX, None, <stdint.h>)
-SYMBOL(INT_LEAST64_MIN, None, <cstdint>)
+SYMBOL_VERSION(INT_LEAST64_MIN, None, <cstdint>, "c++11")
SYMBOL(INT_LEAST64_MIN, None, <stdint.h>)
-SYMBOL(INT_LEAST8_MAX, None, <cstdint>)
+SYMBOL_VERSION(INT_LEAST8_MAX, None, <cstdint>, "c++11")
SYMBOL(INT_LEAST8_MAX, None, <stdint.h>)
-SYMBOL(INT_LEAST8_MIN, None, <cstdint>)
+SYMBOL_VERSION(INT_LEAST8_MIN, None, <cstdint>, "c++11")
SYMBOL(INT_LEAST8_MIN, None, <stdint.h>)
SYMBOL(INT_MAX, None, <climits>)
SYMBOL(INT_MAX, None, <limits.h>)
@@ -376,13 +377,13 @@ SYMBOL(LC_NUMERIC, None, <clocale>)
SYMBOL(LC_NUMERIC, None, <locale.h>)
SYMBOL(LC_TIME, None, <clocale>)
SYMBOL(LC_TIME, None, <locale.h>)
-SYMBOL(LDBL_DECIMAL_DIG, None, <cfloat>)
+SYMBOL_VERSION(LDBL_DECIMAL_DIG, None, <cfloat>, "c++17")
SYMBOL(LDBL_DECIMAL_DIG, None, <float.h>)
SYMBOL(LDBL_DIG, None, <cfloat>)
SYMBOL(LDBL_DIG, None, <float.h>)
SYMBOL(LDBL_EPSILON, None, <cfloat>)
SYMBOL(LDBL_EPSILON, None, <float.h>)
-SYMBOL(LDBL_HAS_SUBNORM, None, <cfloat>)
+SYMBOL_VERSION(LDBL_HAS_SUBNORM, None, <cfloat>, "c++17")
SYMBOL(LDBL_HAS_SUBNORM, None, <float.h>)
SYMBOL(LDBL_MANT_DIG, None, <cfloat>)
SYMBOL(LDBL_MANT_DIG, None, <float.h>)
@@ -398,11 +399,11 @@ SYMBOL(LDBL_MIN_10_EXP, None, <cfloat>)
SYMBOL(LDBL_MIN_10_EXP, None, <float.h>)
SYMBOL(LDBL_MIN_EXP, None, <cfloat>)
SYMBOL(LDBL_MIN_EXP, None, <float.h>)
-SYMBOL(LDBL_TRUE_MIN, None, <cfloat>)
+SYMBOL_VERSION(LDBL_TRUE_MIN, None, <cfloat>, "c++17")
SYMBOL(LDBL_TRUE_MIN, None, <float.h>)
-SYMBOL(LLONG_MAX, None, <climits>)
+SYMBOL_VERSION(LLONG_MAX, None, <climits>, "c++11")
SYMBOL(LLONG_MAX, None, <limits.h>)
-SYMBOL(LLONG_MIN, None, <climits>)
+SYMBOL_VERSION(LLONG_MIN, None, <climits>, "c++11")
SYMBOL(LLONG_MIN, None, <limits.h>)
SYMBOL(LONG_MAX, None, <climits>)
SYMBOL(LONG_MAX, None, <limits.h>)
@@ -410,20 +411,20 @@ SYMBOL(LONG_MIN, None, <climits>)
SYMBOL(LONG_MIN, None, <limits.h>)
SYMBOL(L_tmpnam, None, <cstdio>)
SYMBOL(L_tmpnam, None, <stdio.h>)
-SYMBOL(MATH_ERREXCEPT, None, <cmath>)
+SYMBOL_VERSION(MATH_ERREXCEPT, None, <cmath>, "c++11")
SYMBOL(MATH_ERREXCEPT, None, <math.h>)
-SYMBOL(MATH_ERRNO, None, <cmath>)
+SYMBOL_VERSION(MATH_ERRNO, None, <cmath>, "c++11")
SYMBOL(MATH_ERRNO, None, <math.h>)
SYMBOL(MB_CUR_MAX, None, <cstdlib>)
SYMBOL(MB_CUR_MAX, None, <stdlib.h>)
SYMBOL(MB_LEN_MAX, None, <climits>)
SYMBOL(MB_LEN_MAX, None, <limits.h>)
-SYMBOL(NAN, None, <cmath>)
+SYMBOL_VERSION(NAN, None, <cmath>, "c++11")
SYMBOL(NAN, None, <math.h>)
-SYMBOL(ONCE_FLAG_INIT, None, <mutex>)
-SYMBOL(PTRDIFF_MAX, None, <cstdint>)
+SYMBOL_VERSION(ONCE_FLAG_INIT, None, <mutex>, "c++11")
+SYMBOL_VERSION(PTRDIFF_MAX, None, <cstdint>, "c++11")
SYMBOL(PTRDIFF_MAX, None, <stdint.h>)
-SYMBOL(PTRDIFF_MIN, None, <cstdint>)
+SYMBOL_VERSION(PTRDIFF_MIN, None, <cstdint>, "c++11")
SYMBOL(PTRDIFF_MIN, None, <stdint.h>)
SYMBOL(RAND_MAX, None, <cstdlib>)
SYMBOL(RAND_MAX, None, <stdlib.h>)
@@ -453,9 +454,9 @@ SYMBOL(SIGSEGV, None, <csignal>)
SYMBOL(SIGSEGV, None, <signal.h>)
SYMBOL(SIGTERM, None, <csignal>)
SYMBOL(SIGTERM, None, <signal.h>)
-SYMBOL(SIG_ATOMIC_MAX, None, <cstdint>)
+SYMBOL_VERSION(SIG_ATOMIC_MAX, None, <cstdint>, "c++11")
SYMBOL(SIG_ATOMIC_MAX, None, <stdint.h>)
-SYMBOL(SIG_ATOMIC_MIN, None, <cstdint>)
+SYMBOL_VERSION(SIG_ATOMIC_MIN, None, <cstdint>, "c++11")
SYMBOL(SIG_ATOMIC_MIN, None, <stdint.h>)
SYMBOL(SIG_DFL, None, <csignal>)
SYMBOL(SIG_DFL, None, <signal.h>)
@@ -463,45 +464,45 @@ SYMBOL(SIG_ERR, None, <csignal>)
SYMBOL(SIG_ERR, None, <signal.h>)
SYMBOL(SIG_IGN, None, <csignal>)
SYMBOL(SIG_IGN, None, <signal.h>)
-SYMBOL(SIZE_MAX, None, <cstdint>)
+SYMBOL_VERSION(SIZE_MAX, None, <cstdint>, "c++11")
SYMBOL(SIZE_MAX, None, <stdint.h>)
-SYMBOL(TIME_UTC, None, <ctime>)
+SYMBOL_VERSION(TIME_UTC, None, <ctime>, "c++17")
SYMBOL(TIME_UTC, None, <time.h>)
SYMBOL(TMP_MAX, None, <cstdio>)
SYMBOL(TMP_MAX, None, <stdio.h>)
SYMBOL(UCHAR_MAX, None, <climits>)
SYMBOL(UCHAR_MAX, None, <limits.h>)
-SYMBOL(UINT16_MAX, None, <cstdint>)
+SYMBOL_VERSION(UINT16_MAX, None, <cstdint>, "c++11")
SYMBOL(UINT16_MAX, None, <stdint.h>)
-SYMBOL(UINT32_MAX, None, <cstdint>)
+SYMBOL_VERSION(UINT32_MAX, None, <cstdint>, "c++11")
SYMBOL(UINT32_MAX, None, <stdint.h>)
-SYMBOL(UINT64_MAX, None, <cstdint>)
+SYMBOL_VERSION(UINT64_MAX, None, <cstdint>, "c++11")
SYMBOL(UINT64_MAX, None, <stdint.h>)
-SYMBOL(UINT8_MAX, None, <cstdint>)
+SYMBOL_VERSION(UINT8_MAX, None, <cstdint>, "c++11")
SYMBOL(UINT8_MAX, None, <stdint.h>)
-SYMBOL(UINTMAX_MAX, None, <cstdint>)
+SYMBOL_VERSION(UINTMAX_MAX, None, <cstdint>, "c++11")
SYMBOL(UINTMAX_MAX, None, <stdint.h>)
-SYMBOL(UINTPTR_MAX, None, <cstdint>)
+SYMBOL_VERSION(UINTPTR_MAX, None, <cstdint>, "c++11")
SYMBOL(UINTPTR_MAX, None, <stdint.h>)
-SYMBOL(UINT_FAST16_MAX, None, <cstdint>)
+SYMBOL_VERSION(UINT_FAST16_MAX, None, <cstdint>, "c++11")
SYMBOL(UINT_FAST16_MAX, None, <stdint.h>)
-SYMBOL(UINT_FAST32_MAX, None, <cstdint>)
+SYMBOL_VERSION(UINT_FAST32_MAX, None, <cstdint>, "c++11")
SYMBOL(UINT_FAST32_MAX, None, <stdint.h>)
-SYMBOL(UINT_FAST64_MAX, None, <cstdint>)
+SYMBOL_VERSION(UINT_FAST64_MAX, None, <cstdint>, "c++11")
SYMBOL(UINT_FAST64_MAX, None, <stdint.h>)
-SYMBOL(UINT_FAST8_MAX, None, <cstdint>)
+SYMBOL_VERSION(UINT_FAST8_MAX, None, <cstdint>, "c++11")
SYMBOL(UINT_FAST8_MAX, None, <stdint.h>)
-SYMBOL(UINT_LEAST16_MAX, None, <cstdint>)
+SYMBOL_VERSION(UINT_LEAST16_MAX, None, <cstdint>, "c++11")
SYMBOL(UINT_LEAST16_MAX, None, <stdint.h>)
-SYMBOL(UINT_LEAST32_MAX, None, <cstdint>)
+SYMBOL_VERSION(UINT_LEAST32_MAX, None, <cstdint>, "c++11")
SYMBOL(UINT_LEAST32_MAX, None, <stdint.h>)
-SYMBOL(UINT_LEAST64_MAX, None, <cstdint>)
+SYMBOL_VERSION(UINT_LEAST64_MAX, None, <cstdint>, "c++11")
SYMBOL(UINT_LEAST64_MAX, None, <stdint.h>)
-SYMBOL(UINT_LEAST8_MAX, None, <cstdint>)
+SYMBOL_VERSION(UINT_LEAST8_MAX, None, <cstdint>, "c++11")
SYMBOL(UINT_LEAST8_MAX, None, <stdint.h>)
SYMBOL(UINT_MAX, None, <climits>)
SYMBOL(UINT_MAX, None, <limits.h>)
-SYMBOL(ULLONG_MAX, None, <climits>)
+SYMBOL_VERSION(ULLONG_MAX, None, <climits>, "c++11")
SYMBOL(ULLONG_MAX, None, <limits.h>)
SYMBOL(ULONG_MAX, None, <climits>)
SYMBOL(ULONG_MAX, None, <limits.h>)
@@ -509,9 +510,9 @@ SYMBOL(USHRT_MAX, None, <climits>)
SYMBOL(USHRT_MAX, None, <limits.h>)
SYMBOL(WEOF, None, <cwchar>)
SYMBOL(WEOF, None, <wchar.h>)
-SYMBOL(WINT_MAX, None, <cstdint>)
+SYMBOL_VERSION(WINT_MAX, None, <cstdint>, "c++11")
SYMBOL(WINT_MAX, None, <stdint.h>)
-SYMBOL(WINT_MIN, None, <cstdint>)
+SYMBOL_VERSION(WINT_MIN, None, <cstdint>, "c++11")
SYMBOL(WINT_MIN, None, <stdint.h>)
SYMBOL(_IOFBF, None, <cstdio>)
SYMBOL(_IOFBF, None, <stdio.h>)
@@ -523,7 +524,7 @@ SYMBOL(assert, None, <cassert>)
SYMBOL(assert, None, <assert.h>)
SYMBOL(errno, None, <cerrno>)
SYMBOL(errno, None, <errno.h>)
-SYMBOL(math_errhandling, None, <cmath>)
+SYMBOL_VERSION(math_errhandling, None, <cmath>, "c++11")
SYMBOL(math_errhandling, None, <math.h>)
SYMBOL(offsetof, None, <cstddef>)
SYMBOL(offsetof, None, <stddef.h>)
@@ -537,7 +538,7 @@ SYMBOL(stdout, None, <cstdio>)
SYMBOL(stdout, None, <stdio.h>)
SYMBOL(va_arg, None, <cstdarg>)
SYMBOL(va_arg, None, <stdarg.h>)
-SYMBOL(va_copy, None, <cstdarg>)
+SYMBOL_VERSION(va_copy, None, <cstdarg>, "c++11")
SYMBOL(va_copy, None, <stdarg.h>)
SYMBOL(va_end, None, <cstdarg>)
SYMBOL(va_end, None, <stdarg.h>)
@@ -546,133 +547,112 @@ SYMBOL(va_start, None, <stdarg.h>)
SYMBOL(FILE, std::, <cstdio>)
SYMBOL(FILE, None, <cstdio>)
SYMBOL(FILE, None, <stdio.h>)
-SYMBOL(_Exit, std::, <cstdlib>)
+SYMBOL_VERSION(_Exit, std::, <cstdlib>, "c++11")
SYMBOL(_Exit, None, <cstdlib>)
SYMBOL(_Exit, None, <stdlib.h>)
SYMBOL(accumulate, std::, <numeric>)
-SYMBOL(acos, std::, <cmath>)
-SYMBOL(acos, None, <cmath>)
-SYMBOL(acos, None, <math.h>)
-SYMBOL(acosf, std::, <cmath>)
+SYMBOL_VERSION(acosf, std::, <cmath>, "c++11")
SYMBOL(acosf, None, <cmath>)
SYMBOL(acosf, None, <math.h>)
-SYMBOL(acosh, std::, <cmath>)
-SYMBOL(acosh, None, <cmath>)
-SYMBOL(acosh, None, <math.h>)
-SYMBOL(acoshf, std::, <cmath>)
+SYMBOL_VERSION(acoshf, std::, <cmath>, "c++11")
SYMBOL(acoshf, None, <cmath>)
SYMBOL(acoshf, None, <math.h>)
-SYMBOL(acoshl, std::, <cmath>)
+SYMBOL_VERSION(acoshl, std::, <cmath>, "c++11")
SYMBOL(acoshl, None, <cmath>)
SYMBOL(acoshl, None, <math.h>)
-SYMBOL(acosl, std::, <cmath>)
+SYMBOL_VERSION(acosl, std::, <cmath>, "c++11")
SYMBOL(acosl, None, <cmath>)
SYMBOL(acosl, None, <math.h>)
-SYMBOL(add_const, std::, <type_traits>)
-SYMBOL(add_const_t, std::, <type_traits>)
-SYMBOL(add_cv, std::, <type_traits>)
-SYMBOL(add_cv_t, std::, <type_traits>)
-SYMBOL(add_lvalue_reference, std::, <type_traits>)
-SYMBOL(add_lvalue_reference_t, std::, <type_traits>)
-SYMBOL(add_pointer, std::, <type_traits>)
-SYMBOL(add_pointer_t, std::, <type_traits>)
-SYMBOL(add_rvalue_reference, std::, <type_traits>)
-SYMBOL(add_rvalue_reference_t, std::, <type_traits>)
-SYMBOL(add_sat, std::, <numeric>)
-SYMBOL(add_volatile, std::, <type_traits>)
-SYMBOL(add_volatile_t, std::, <type_traits>)
-SYMBOL(addressof, std::, <memory>)
+SYMBOL_VERSION(add_const, std::, <type_traits>, "c++11")
+SYMBOL_VERSION(add_const_t, std::, <type_traits>, "c++14")
+SYMBOL_VERSION(add_cv, std::, <type_traits>, "c++11")
+SYMBOL_VERSION(add_cv_t, std::, <type_traits>, "c++14")
+SYMBOL_VERSION(add_lvalue_reference, std::, <type_traits>, "c++11")
+SYMBOL_VERSION(add_lvalue_reference_t, std::, <type_traits>, "c++14")
+SYMBOL_VERSION(add_pointer, std::, <type_traits>, "c++11")
+SYMBOL_VERSION(add_pointer_t, std::, <type_traits>, "c++14")
+SYMBOL_VERSION(add_rvalue_reference, std::, <type_traits>, "c++11")
+SYMBOL_VERSION(add_rvalue_reference_t, std::, <type_traits>, "c++14")
+SYMBOL_VERSION(add_sat, std::, <numeric>, "c++26")
+SYMBOL_VERSION(add_volatile, std::, <type_traits>, "c++11")
+SYMBOL_VERSION(add_volatile_t, std::, <type_traits>, "c++14")
+SYMBOL_VERSION(addressof, std::, <memory>, "c++11")
SYMBOL(adjacent_difference, std::, <numeric>)
SYMBOL(adjacent_find, std::, <algorithm>)
-SYMBOL(adopt_lock, std::, <mutex>)
-SYMBOL(adopt_lock_t, std::, <mutex>)
+SYMBOL_VERSION(adopt_lock, std::, <mutex>, "c++11")
+SYMBOL_VERSION(adopt_lock_t, std::, <mutex>, "c++11")
SYMBOL(advance, std::, <iterator>)
-SYMBOL(align, std::, <memory>)
-SYMBOL(align_val_t, std::, <new>)
-SYMBOL(aligned_alloc, std::, <cstdlib>)
+SYMBOL_VERSION(align, std::, <memory>, "c++11")
+SYMBOL_VERSION(align_val_t, std::, <new>, "c++17")
+SYMBOL_VERSION(aligned_alloc, std::, <cstdlib>, "c++17")
SYMBOL(aligned_alloc, None, <cstdlib>)
SYMBOL(aligned_alloc, None, <stdlib.h>)
-SYMBOL(aligned_storage, std::, <type_traits>)
-SYMBOL(aligned_storage_t, std::, <type_traits>)
-SYMBOL(aligned_union, std::, <type_traits>)
-SYMBOL(aligned_union_t, std::, <type_traits>)
-SYMBOL(alignment_of, std::, <type_traits>)
-SYMBOL(alignment_of_v, std::, <type_traits>)
-SYMBOL(all_of, std::, <algorithm>)
-SYMBOL(allocate_shared, std::, <memory>)
-SYMBOL(allocate_shared_for_overwrite, std::, <memory>)
-SYMBOL(allocation_result, std::, <memory>)
+SYMBOL_VERSION(aligned_storage, std::, <type_traits>, "c++11")
+SYMBOL_VERSION(aligned_storage_t, std::, <type_traits>, "c++14")
+SYMBOL_VERSION(aligned_union, std::, <type_traits>, "c++11")
+SYMBOL_VERSION(aligned_union_t, std::, <type_traits>, "c++14")
+SYMBOL_VERSION(alignment_of, std::, <type_traits>, "c++11")
+SYMBOL_VERSION(alignment_of_v, std::, <type_traits>, "c++17")
+SYMBOL_VERSION(all_of, std::, <algorithm>, "c++11")
+SYMBOL_VERSION(allocate_shared, std::, <memory>, "c++11")
+SYMBOL_VERSION(allocate_shared_for_overwrite, std::, <memory>, "c++20")
+SYMBOL_VERSION(allocation_result, std::, <memory>, "c++23")
SYMBOL(allocator, std::, <memory>)
-SYMBOL(allocator_arg, std::, <memory>)
-SYMBOL(allocator_arg_t, std::, <memory>)
-SYMBOL(allocator_traits, std::, <memory>)
-SYMBOL(any, std::, <any>)
-SYMBOL(any_cast, std::, <any>)
-SYMBOL(any_of, std::, <algorithm>)
-SYMBOL(apply, std::, <tuple>)
+SYMBOL_VERSION(allocator_arg, std::, <memory>, "c++11")
+SYMBOL_VERSION(allocator_arg_t, std::, <memory>, "c++11")
+SYMBOL_VERSION(allocator_traits, std::, <memory>, "c++11")
+SYMBOL_VERSION(any, std::, <any>, "c++17")
+SYMBOL_VERSION(any_cast, std::, <any>, "c++17")
+SYMBOL_VERSION(any_of, std::, <algorithm>, "c++11")
+SYMBOL_VERSION(apply, std::, <tuple>, "c++17")
SYMBOL(arg, std::, <complex>)
-SYMBOL(array, std::, <array>)
-SYMBOL(as_bytes, std::, <span>)
-SYMBOL(as_const, std::, <utility>)
-SYMBOL(as_writable_bytes, std::, <span>)
+SYMBOL_VERSION(array, std::, <array>, "c++11")
+SYMBOL_VERSION(as_bytes, std::, <span>, "c++20")
+SYMBOL_VERSION(as_const, std::, <utility>, "c++17")
+SYMBOL_VERSION(as_writable_bytes, std::, <span>, "c++20")
SYMBOL(asctime, std::, <ctime>)
SYMBOL(asctime, None, <ctime>)
SYMBOL(asctime, None, <time.h>)
-SYMBOL(asin, std::, <cmath>)
-SYMBOL(asin, None, <cmath>)
-SYMBOL(asin, None, <math.h>)
-SYMBOL(asinf, std::, <cmath>)
+SYMBOL_VERSION(asinf, std::, <cmath>, "c++11")
SYMBOL(asinf, None, <cmath>)
SYMBOL(asinf, None, <math.h>)
-SYMBOL(asinh, std::, <cmath>)
-SYMBOL(asinh, None, <cmath>)
-SYMBOL(asinh, None, <math.h>)
-SYMBOL(asinhf, std::, <cmath>)
+SYMBOL_VERSION(asinhf, std::, <cmath>, "c++11")
SYMBOL(asinhf, None, <cmath>)
SYMBOL(asinhf, None, <math.h>)
-SYMBOL(asinhl, std::, <cmath>)
+SYMBOL_VERSION(asinhl, std::, <cmath>, "c++11")
SYMBOL(asinhl, None, <cmath>)
SYMBOL(asinhl, None, <math.h>)
-SYMBOL(asinl, std::, <cmath>)
+SYMBOL_VERSION(asinl, std::, <cmath>, "c++11")
SYMBOL(asinl, None, <cmath>)
SYMBOL(asinl, None, <math.h>)
-SYMBOL(assignable_from, std::, <concepts>)
-SYMBOL(assoc_laguerre, std::, <cmath>)
-SYMBOL(assoc_laguerref, std::, <cmath>)
-SYMBOL(assoc_laguerrel, std::, <cmath>)
-SYMBOL(assoc_legendre, std::, <cmath>)
-SYMBOL(assoc_legendref, std::, <cmath>)
-SYMBOL(assoc_legendrel, std::, <cmath>)
-SYMBOL(assume_aligned, std::, <memory>)
-SYMBOL(async, std::, <future>)
-SYMBOL(at_quick_exit, std::, <cstdlib>)
+SYMBOL_VERSION(assignable_from, std::, <concepts>, "c++20")
+SYMBOL_VERSION(assoc_laguerre, std::, <cmath>, "c++17")
+SYMBOL_VERSION(assoc_laguerref, std::, <cmath>, "c++17")
+SYMBOL_VERSION(assoc_laguerrel, std::, <cmath>, "c++17")
+SYMBOL_VERSION(assoc_legendre, std::, <cmath>, "c++17")
+SYMBOL_VERSION(assoc_legendref, std::, <cmath>, "c++17")
+SYMBOL_VERSION(assoc_legendrel, std::, <cmath>, "c++17")
+SYMBOL_VERSION(assume_aligned, std::, <memory>, "c++20")
+SYMBOL_VERSION(async, std::, <future>, "c++11")
+SYMBOL_VERSION(at_quick_exit, std::, <cstdlib>, "c++11")
SYMBOL(at_quick_exit, None, <cstdlib>)
SYMBOL(at_quick_exit, None, <stdlib.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(atan2f, std::, <cmath>)
+SYMBOL_VERSION(atan2f, std::, <cmath>, "c++11")
SYMBOL(atan2f, None, <cmath>)
SYMBOL(atan2f, None, <math.h>)
-SYMBOL(atan2l, std::, <cmath>)
+SYMBOL_VERSION(atan2l, std::, <cmath>, "c++11")
SYMBOL(atan2l, None, <cmath>)
SYMBOL(atan2l, None, <math.h>)
-SYMBOL(atanf, std::, <cmath>)
+SYMBOL_VERSION(atanf, std::, <cmath>, "c++11")
SYMBOL(atanf, None, <cmath>)
SYMBOL(atanf, None, <math.h>)
-SYMBOL(atanh, std::, <cmath>)
-SYMBOL(atanh, None, <cmath>)
-SYMBOL(atanh, None, <math.h>)
-SYMBOL(atanhf, std::, <cmath>)
+SYMBOL_VERSION(atanhf, std::, <cmath>, "c++11")
SYMBOL(atanhf, None, <cmath>)
SYMBOL(atanhf, None, <math.h>)
-SYMBOL(atanhl, std::, <cmath>)
+SYMBOL_VERSION(atanhl, std::, <cmath>, "c++11")
SYMBOL(atanhl, None, <cmath>)
SYMBOL(atanhl, None, <math.h>)
-SYMBOL(atanl, std::, <cmath>)
+SYMBOL_VERSION(atanl, std::, <cmath>, "c++11")
SYMBOL(atanl, None, <cmath>)
SYMBOL(atanl, None, <math.h>)
SYMBOL(atexit, std::, <cstdlib>)
@@ -687,78 +667,78 @@ SYMBOL(atoi, None, <stdlib.h>)
SYMBOL(atol, std::, <cstdlib>)
SYMBOL(atol, None, <cstdlib>)
SYMBOL(atol, None, <stdlib.h>)
-SYMBOL(atoll, std::, <cstdlib>)
+SYMBOL_VERSION(atoll, std::, <cstdlib>, "c++11")
SYMBOL(atoll, None, <cstdlib>)
SYMBOL(atoll, None, <stdlib.h>)
-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_fetch_add, std::, <atomic>)
-SYMBOL(atomic_fetch_add_explicit, std::, <atomic>)
-SYMBOL(atomic_fetch_and, std::, <atomic>)
-SYMBOL(atomic_fetch_and_explicit, std::, <atomic>)
-SYMBOL(atomic_fetch_max, std::, <atomic>)
-SYMBOL(atomic_fetch_max_explicit, std::, <atomic>)
-SYMBOL(atomic_fetch_min, std::, <atomic>)
-SYMBOL(atomic_fetch_min_explicit, std::, <atomic>)
-SYMBOL(atomic_fetch_or, std::, <atomic>)
-SYMBOL(atomic_fetch_or_explicit, std::, <atomic>)
-SYMBOL(atomic_fetch_sub, std::, <atomic>)
-SYMBOL(atomic_fetch_sub_explicit, std::, <atomic>)
-SYMBOL(atomic_fetch_xor, std::, <atomic>)
-SYMBOL(atomic_fetch_xor_explicit, std::, <atomic>)
-SYMBOL(atomic_flag, std::, <atomic>)
-SYMBOL(atomic_flag_clear, std::, <atomic>)
-SYMBOL(atomic_flag_clear_explicit, std::, <atomic>)
-SYMBOL(atomic_flag_notify_all, std::, <atomic>)
-SYMBOL(atomic_flag_notify_one, std::, <atomic>)
-SYMBOL(atomic_flag_test, std::, <atomic>)
-SYMBOL(atomic_flag_test_and_set, std::, <atomic>)
-SYMBOL(atomic_flag_test_and_set_explicit, std::, <atomic>)
-SYMBOL(atomic_flag_test_explicit, std::, <atomic>)
-SYMBOL(atomic_flag_wait, std::, <atomic>)
-SYMBOL(atomic_flag_wait_explicit, std::, <atomic>)
-SYMBOL(atomic_init, std::, <atomic>)
-SYMBOL(atomic_is_lock_free, std::, <atomic>)
-SYMBOL(atomic_load, std::, <atomic>)
-SYMBOL(atomic_load_explicit, std::, <atomic>)
-SYMBOL(atomic_notify_all, std::, <atomic>)
-SYMBOL(atomic_notify_one, std::, <atomic>)
-SYMBOL(atomic_ref, std::, <atomic>)
-SYMBOL(atomic_signal_fence, std::, <atomic>)
-SYMBOL(atomic_store, std::, <atomic>)
-SYMBOL(atomic_store_explicit, std::, <atomic>)
-SYMBOL(atomic_thread_fence, std::, <atomic>)
-SYMBOL(atomic_wait, std::, <atomic>)
-SYMBOL(atomic_wait_explicit, std::, <atomic>)
-SYMBOL(atto, std::, <ratio>)
+SYMBOL_VERSION(atomic_compare_exchange_strong, std::, <atomic>, "c++11")
+SYMBOL_VERSION(atomic_compare_exchange_strong_explicit, std::, <atomic>, "c++11")
+SYMBOL_VERSION(atomic_compare_exchange_weak, std::, <atomic>, "c++11")
+SYMBOL_VERSION(atomic_compare_exchange_weak_explicit, std::, <atomic>, "c++11")
+SYMBOL_VERSION(atomic_exchange, std::, <atomic>, "c++11")
+SYMBOL_VERSION(atomic_exchange_explicit, std::, <atomic>, "c++11")
+SYMBOL_VERSION(atomic_fetch_add, std::, <atomic>, "c++11")
+SYMBOL_VERSION(atomic_fetch_add_explicit, std::, <atomic>, "c++11")
+SYMBOL_VERSION(atomic_fetch_and, std::, <atomic>, "c++11")
+SYMBOL_VERSION(atomic_fetch_and_explicit, std::, <atomic>, "c++11")
+SYMBOL_VERSION(atomic_fetch_max, std::, <atomic>, "c++26")
+SYMBOL_VERSION(atomic_fetch_max_explicit, std::, <atomic>, "c++26")
+SYMBOL_VERSION(atomic_fetch_min, std::, <atomic>, "c++26")
+SYMBOL_VERSION(atomic_fetch_min_explicit, std::, <atomic>, "c++26")
+SYMBOL_VERSION(atomic_fetch_or, std::, <atomic>, "c++11")
+SYMBOL_VERSION(atomic_fetch_or_explicit, std::, <atomic>, "c++11")
+SYMBOL_VERSION(atomic_fetch_sub, std::, <atomic>, "c++11")
+SYMBOL_VERSION(atomic_fetch_sub_explicit, std::, <atomic>, "c++11")
+SYMBOL_VERSION(atomic_fetch_xor, std::, <atomic>, "c++11")
+SYMBOL_VERSION(atomic_fetch_xor_explicit, std::, <atomic>, "c++11")
+SYMBOL_VERSION(atomic_flag, std::, <atomic>, "c++11")
+SYMBOL_VERSION(atomic_flag_clear, std::, <atomic>, "c++11")
+SYMBOL_VERSION(atomic_flag_clear_explicit, std::, <atomic>, "c++11")
+SYMBOL_VERSION(atomic_flag_notify_all, std::, <atomic>, "c++20")
+SYMBOL_VERSION(atomic_flag_notify_one, std::, <atomic>, "c++20")
+SYMBOL_VERSION(atomic_flag_test, std::, <atomic>, "c++20")
+SYMBOL_VERSION(atomic_flag_test_and_set, std::, <atomic>, "c++11")
+SYMBOL_VERSION(atomic_flag_test_and_set_explicit, std::, <atomic>, "c++11")
+SYMBOL_VERSION(atomic_flag_test_explicit, std::, <atomic>, "c++20")
+SYMBOL_VERSION(atomic_flag_wait, std::, <atomic>, "c++20")
+SYMBOL_VERSION(atomic_flag_wait_explicit, std::, <atomic>, "c++20")
+SYMBOL_VERSION(atomic_init, std::, <atomic>, "c++11")
+SYMBOL_VERSION(atomic_is_lock_free, std::, <atomic>, "c++11")
+SYMBOL_VERSION(atomic_load, std::, <atomic>, "c++11")
+SYMBOL_VERSION(atomic_load_explicit, std::, <atomic>, "c++11")
+SYMBOL_VERSION(atomic_notify_all, std::, <atomic>, "c++20")
+SYMBOL_VERSION(atomic_notify_one, std::, <atomic>, "c++20")
+SYMBOL_VERSION(atomic_ref, std::, <atomic>, "c++20")
+SYMBOL_VERSION(atomic_signal_fence, std::, <atomic>, "c++11")
+SYMBOL_VERSION(atomic_store, std::, <atomic>, "c++11")
+SYMBOL_VERSION(atomic_store_explicit, std::, <atomic>, "c++11")
+SYMBOL_VERSION(atomic_thread_fence, std::, <atomic>, "c++11")
+SYMBOL_VERSION(atomic_wait, std::, <atomic>, "c++20")
+SYMBOL_VERSION(atomic_wait_explicit, std::, <atomic>, "c++20")
+SYMBOL_VERSION(atto, std::, <ratio>, "c++11")
SYMBOL(auto_ptr, std::, <memory>)
SYMBOL(back_insert_iterator, std::, <iterator>)
SYMBOL(back_inserter, std::, <iterator>)
SYMBOL(bad_alloc, std::, <new>)
-SYMBOL(bad_any_cast, std::, <any>)
-SYMBOL(bad_array_new_length, std::, <new>)
+SYMBOL_VERSION(bad_any_cast, std::, <any>, "c++17")
+SYMBOL_VERSION(bad_array_new_length, std::, <new>, "c++11")
SYMBOL(bad_cast, std::, <typeinfo>)
SYMBOL(bad_exception, std::, <exception>)
-SYMBOL(bad_expected_access, std::, <expected>)
-SYMBOL(bad_function_call, std::, <functional>)
-SYMBOL(bad_optional_access, std::, <optional>)
+SYMBOL_VERSION(bad_expected_access, std::, <expected>, "c++23")
+SYMBOL_VERSION(bad_function_call, std::, <functional>, "c++11")
+SYMBOL_VERSION(bad_optional_access, std::, <optional>, "c++17")
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_const_iterator, std::, <iterator>)
+SYMBOL_VERSION(bad_variant_access, std::, <variant>, "c++17")
+SYMBOL_VERSION(bad_weak_ptr, std::, <memory>, "c++11")
+SYMBOL_VERSION(barrier, std::, <barrier>, "c++20")
+SYMBOL_VERSION(basic_common_reference, std::, <type_traits>, "c++20")
+SYMBOL_VERSION(basic_const_iterator, std::, <iterator>, "c++23")
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_format_string, std::, <format>)
+SYMBOL_VERSION(basic_format_arg, std::, <format>, "c++20")
+SYMBOL_VERSION(basic_format_args, std::, <format>, "c++20")
+SYMBOL_VERSION(basic_format_context, std::, <format>, "c++20")
+SYMBOL_VERSION(basic_format_parse_context, std::, <format>, "c++20")
+SYMBOL_VERSION(basic_format_string, std::, <format>, "c++20")
SYMBOL(basic_fstream, std::, <fstream>)
SYMBOL(basic_fstream, std::, <iosfwd>)
SYMBOL(basic_ifstream, std::, <fstream>)
@@ -769,8 +749,8 @@ 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_VERSION(basic_ispanstream, std::, <spanstream>, "c++23")
+SYMBOL_VERSION(basic_ispanstream, std::, <iosfwd>, "c++23")
SYMBOL(basic_istream, std::, <istream>)
SYMBOL(basic_istream, std::, <iostream>)
SYMBOL(basic_istream, std::, <iosfwd>)
@@ -778,113 +758,107 @@ 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_VERSION(basic_ospanstream, std::, <spanstream>, "c++23")
+SYMBOL_VERSION(basic_ospanstream, std::, <iosfwd>, "c++23")
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_VERSION(basic_osyncstream, std::, <syncstream>, "c++20")
+SYMBOL_VERSION(basic_osyncstream, std::, <iosfwd>, "c++20")
+SYMBOL_VERSION(basic_regex, std::, <regex>, "c++11")
+SYMBOL_VERSION(basic_spanbuf, std::, <spanstream>, "c++23")
+SYMBOL_VERSION(basic_spanbuf, std::, <iosfwd>, "c++23")
+SYMBOL_VERSION(basic_spanstream, std::, <spanstream>, "c++23")
+SYMBOL_VERSION(basic_spanstream, std::, <iosfwd>, "c++23")
+SYMBOL_VERSION(basic_stacktrace, std::, <stacktrace>, "c++23")
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_VERSION(basic_string_view, std::, <string_view>, "c++17")
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_VERSION(basic_syncbuf, std::, <syncstream>, "c++20")
+SYMBOL_VERSION(basic_syncbuf, std::, <iosfwd>, "c++20")
+SYMBOL_VERSION(bernoulli_distribution, std::, <random>, "c++11")
+SYMBOL_VERSION(beta, std::, <cmath>, "c++17")
+SYMBOL_VERSION(betaf, std::, <cmath>, "c++17")
+SYMBOL_VERSION(betal, std::, <cmath>, "c++17")
+SYMBOL_VERSION(bidirectional_iterator, std::, <iterator>, "c++20")
SYMBOL(bidirectional_iterator_tag, std::, <iterator>)
SYMBOL(binary_function, std::, <functional>)
SYMBOL(binary_negate, std::, <functional>)
SYMBOL(binary_search, std::, <algorithm>)
-SYMBOL(binary_semaphore, std::, <semaphore>)
-SYMBOL(bind, std::, <functional>)
+SYMBOL_VERSION(binary_semaphore, std::, <semaphore>, "c++20")
+SYMBOL_VERSION(bind, std::, <functional>, "c++11")
SYMBOL(bind1st, std::, <functional>)
SYMBOL(bind2nd, std::, <functional>)
-SYMBOL(bind_back, std::, <functional>)
-SYMBOL(bind_front, std::, <functional>)
+SYMBOL_VERSION(bind_back, std::, <functional>, "c++23")
+SYMBOL_VERSION(bind_front, std::, <functional>, "c++20")
SYMBOL(binder1st, std::, <functional>)
SYMBOL(binder2nd, std::, <functional>)
-SYMBOL(binomial_distribution, std::, <random>)
+SYMBOL_VERSION(binomial_distribution, std::, <random>, "c++11")
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_VERSION(bit_cast, std::, <bit>, "c++20")
+SYMBOL_VERSION(bit_ceil, std::, <bit>, "c++20")
+SYMBOL_VERSION(bit_floor, std::, <bit>, "c++20")
+SYMBOL_VERSION(bit_not, std::, <functional>, "c++14")
SYMBOL(bit_or, std::, <functional>)
-SYMBOL(bit_width, std::, <bit>)
+SYMBOL_VERSION(bit_width, std::, <bit>, "c++20")
SYMBOL(bit_xor, std::, <functional>)
SYMBOL(bitset, std::, <bitset>)
-SYMBOL(bool_constant, std::, <type_traits>)
+SYMBOL_VERSION(bool_constant, std::, <type_traits>, "c++17")
SYMBOL(boolalpha, std::, <ios>)
SYMBOL(boolalpha, std::, <iostream>)
-SYMBOL(boyer_moore_horspool_searcher, std::, <functional>)
-SYMBOL(boyer_moore_searcher, std::, <functional>)
-SYMBOL(breakpoint, std::, <debugging>)
-SYMBOL(breakpoint_if_debugging, std::, <debugging>)
+SYMBOL_VERSION(boyer_moore_horspool_searcher, std::, <functional>, "c++17")
+SYMBOL_VERSION(boyer_moore_searcher, std::, <functional>, "c++17")
+SYMBOL_VERSION(breakpoint, std::, <debugging>, "c++26")
+SYMBOL_VERSION(breakpoint_if_debugging, std::, <debugging>, "c++26")
SYMBOL(bsearch, std::, <cstdlib>)
SYMBOL(bsearch, None, <cstdlib>)
SYMBOL(bsearch, None, <stdlib.h>)
SYMBOL(btowc, std::, <cwchar>)
SYMBOL(btowc, None, <cwchar>)
SYMBOL(btowc, None, <wchar.h>)
-SYMBOL(byte, std::, <cstddef>)
-SYMBOL(byteswap, std::, <bit>)
-SYMBOL(c16rtomb, std::, <cuchar>)
+SYMBOL_VERSION(byte, std::, <cstddef>, "c++17")
+SYMBOL_VERSION(byteswap, std::, <bit>, "c++23")
+SYMBOL_VERSION(c16rtomb, std::, <cuchar>, "c++11")
SYMBOL(c16rtomb, None, <cuchar>)
SYMBOL(c16rtomb, None, <uchar.h>)
-SYMBOL(c32rtomb, std::, <cuchar>)
+SYMBOL_VERSION(c32rtomb, std::, <cuchar>, "c++11")
SYMBOL(c32rtomb, None, <cuchar>)
SYMBOL(c32rtomb, None, <uchar.h>)
-SYMBOL(c8rtomb, std::, <cuchar>)
+SYMBOL_VERSION(c8rtomb, std::, <cuchar>, "c++20")
SYMBOL(c8rtomb, None, <cuchar>)
SYMBOL(c8rtomb, None, <uchar.h>)
-SYMBOL(call_once, std::, <mutex>)
+SYMBOL_VERSION(call_once, std::, <mutex>, "c++11")
SYMBOL(calloc, std::, <cstdlib>)
SYMBOL(calloc, None, <cstdlib>)
SYMBOL(calloc, None, <stdlib.h>)
-SYMBOL(cauchy_distribution, std::, <random>)
-SYMBOL(cbrt, std::, <cmath>)
-SYMBOL(cbrt, None, <cmath>)
-SYMBOL(cbrt, None, <math.h>)
-SYMBOL(cbrtf, std::, <cmath>)
+SYMBOL_VERSION(cauchy_distribution, std::, <random>, "c++11")
+SYMBOL_VERSION(cbrtf, std::, <cmath>, "c++11")
SYMBOL(cbrtf, None, <cmath>)
SYMBOL(cbrtf, None, <math.h>)
-SYMBOL(cbrtl, std::, <cmath>)
+SYMBOL_VERSION(cbrtl, std::, <cmath>, "c++11")
SYMBOL(cbrtl, None, <cmath>)
SYMBOL(cbrtl, None, <math.h>)
-SYMBOL(ceil, std::, <cmath>)
-SYMBOL(ceil, None, <cmath>)
-SYMBOL(ceil, None, <math.h>)
-SYMBOL(ceilf, std::, <cmath>)
+SYMBOL_VERSION(ceilf, std::, <cmath>, "c++11")
SYMBOL(ceilf, None, <cmath>)
SYMBOL(ceilf, None, <math.h>)
-SYMBOL(ceill, std::, <cmath>)
+SYMBOL_VERSION(ceill, std::, <cmath>, "c++11")
SYMBOL(ceill, None, <cmath>)
SYMBOL(ceill, None, <math.h>)
-SYMBOL(centi, std::, <ratio>)
+SYMBOL_VERSION(centi, std::, <ratio>, "c++11")
SYMBOL(cerr, std::, <iostream>)
SYMBOL(char_traits, std::, <string>)
-SYMBOL(chars_format, std::, <charconv>)
-SYMBOL(chi_squared_distribution, std::, <random>)
+SYMBOL_VERSION(chars_format, std::, <charconv>, "c++17")
+SYMBOL_VERSION(chi_squared_distribution, std::, <random>, "c++11")
SYMBOL(cin, std::, <iostream>)
-SYMBOL(clamp, std::, <algorithm>)
+SYMBOL_VERSION(clamp, std::, <algorithm>, "c++17")
SYMBOL(clearerr, std::, <cstdio>)
SYMBOL(clearerr, None, <cstdio>)
SYMBOL(clearerr, None, <stdio.h>)
@@ -895,203 +869,194 @@ SYMBOL(clock_t, std::, <ctime>)
SYMBOL(clock_t, None, <ctime>)
SYMBOL(clock_t, None, <time.h>)
SYMBOL(clog, std::, <iostream>)
-SYMBOL(cmatch, std::, <regex>)
-SYMBOL(cmp_equal, std::, <utility>)
-SYMBOL(cmp_greater, std::, <utility>)
-SYMBOL(cmp_greater_equal, std::, <utility>)
-SYMBOL(cmp_less, std::, <utility>)
-SYMBOL(cmp_less_equal, std::, <utility>)
-SYMBOL(cmp_not_equal, std::, <utility>)
+SYMBOL_VERSION(cmatch, std::, <regex>, "c++11")
+SYMBOL_VERSION(cmp_equal, std::, <utility>, "c++20")
+SYMBOL_VERSION(cmp_greater, std::, <utility>, "c++20")
+SYMBOL_VERSION(cmp_greater_equal, std::, <utility>, "c++20")
+SYMBOL_VERSION(cmp_less, std::, <utility>, "c++20")
+SYMBOL_VERSION(cmp_less_equal, std::, <utility>, "c++20")
+SYMBOL_VERSION(cmp_not_equal, std::, <utility>, "c++20")
SYMBOL(codecvt, std::, <locale>)
SYMBOL(codecvt_base, std::, <locale>)
SYMBOL(codecvt_byname, std::, <locale>)
-SYMBOL(codecvt_mode, std::, <codecvt>)
-SYMBOL(codecvt_utf16, std::, <codecvt>)
-SYMBOL(codecvt_utf8, std::, <codecvt>)
-SYMBOL(codecvt_utf8_utf16, std::, <codecvt>)
+SYMBOL_VERSION(codecvt_mode, std::, <codecvt>, "c++11")
+SYMBOL_VERSION(codecvt_utf16, std::, <codecvt>, "c++11")
+SYMBOL_VERSION(codecvt_utf8, std::, <codecvt>, "c++11")
+SYMBOL_VERSION(codecvt_utf8_utf16, std::, <codecvt>, "c++11")
SYMBOL(collate, std::, <locale>)
SYMBOL(collate_byname, std::, <locale>)
-SYMBOL(common_comparison_category, std::, <compare>)
-SYMBOL(common_comparison_category_t, std::, <compare>)
-SYMBOL(common_iterator, std::, <iterator>)
-SYMBOL(common_reference, std::, <type_traits>)
-SYMBOL(common_reference_t, std::, <type_traits>)
-SYMBOL(common_reference_with, std::, <concepts>)
-SYMBOL(common_type, std::, <type_traits>)
-SYMBOL(common_type_t, std::, <type_traits>)
-SYMBOL(common_with, std::, <concepts>)
-SYMBOL(comp_ellint_1, std::, <cmath>)
-SYMBOL(comp_ellint_1f, std::, <cmath>)
-SYMBOL(comp_ellint_1l, std::, <cmath>)
-SYMBOL(comp_ellint_2, std::, <cmath>)
-SYMBOL(comp_ellint_2f, std::, <cmath>)
-SYMBOL(comp_ellint_2l, std::, <cmath>)
-SYMBOL(comp_ellint_3, std::, <cmath>)
-SYMBOL(comp_ellint_3f, std::, <cmath>)
-SYMBOL(comp_ellint_3l, std::, <cmath>)
-SYMBOL(compare_partial_order_fallback, std::, <compare>)
-SYMBOL(compare_strong_order_fallback, std::, <compare>)
-SYMBOL(compare_three_way_result, std::, <compare>)
-SYMBOL(compare_three_way_result_t, std::, <compare>)
-SYMBOL(compare_weak_order_fallback, std::, <compare>)
+SYMBOL_VERSION(common_comparison_category, std::, <compare>, "c++20")
+SYMBOL_VERSION(common_comparison_category_t, std::, <compare>, "c++20")
+SYMBOL_VERSION(common_iterator, std::, <iterator>, "c++20")
+SYMBOL_VERSION(common_reference, std::, <type_traits>, "c++20")
+SYMBOL_VERSION(common_reference_t, std::, <type_traits>, "c++20")
+SYMBOL_VERSION(common_reference_with, std::, <concepts>, "c++20")
+SYMBOL_VERSION(common_type, std::, <type_traits>, "c++11")
+SYMBOL_VERSION(common_type_t, std::, <type_traits>, "c++14")
+SYMBOL_VERSION(common_with, std::, <concepts>, "c++20")
+SYMBOL_VERSION(comp_ellint_1, std::, <cmath>, "c++17")
+SYMBOL_VERSION(comp_ellint_1f, std::, <cmath>, "c++17")
+SYMBOL_VERSION(comp_ellint_1l, std::, <cmath>, "c++17")
+SYMBOL_VERSION(comp_ellint_2, std::, <cmath>, "c++17")
+SYMBOL_VERSION(comp_ellint_2f, std::, <cmath>, "c++17")
+SYMBOL_VERSION(comp_ellint_2l, std::, <cmath>, "c++17")
+SYMBOL_VERSION(comp_ellint_3, std::, <cmath>, "c++17")
+SYMBOL_VERSION(comp_ellint_3f, std::, <cmath>, "c++17")
+SYMBOL_VERSION(comp_ellint_3l, std::, <cmath>, "c++17")
+SYMBOL_VERSION(compare_partial_order_fallback, std::, <compare>, "c++20")
+SYMBOL_VERSION(compare_strong_order_fallback, std::, <compare>, "c++20")
+SYMBOL_VERSION(compare_three_way_result, std::, <compare>, "c++20")
+SYMBOL_VERSION(compare_three_way_result_t, std::, <compare>, "c++20")
+SYMBOL_VERSION(compare_weak_order_fallback, std::, <compare>, "c++20")
SYMBOL(complex, std::, <complex>)
-SYMBOL(condition_variable, std::, <condition_variable>)
-SYMBOL(condition_variable_any, std::, <condition_variable>)
-SYMBOL(conditional, std::, <type_traits>)
-SYMBOL(conditional_t, std::, <type_traits>)
+SYMBOL_VERSION(condition_variable, std::, <condition_variable>, "c++11")
+SYMBOL_VERSION(condition_variable_any, std::, <condition_variable>, "c++11")
+SYMBOL_VERSION(conditional, std::, <type_traits>, "c++11")
+SYMBOL_VERSION(conditional_t, std::, <type_traits>, "c++14")
SYMBOL(conj, std::, <complex>)
-SYMBOL(conjunction, std::, <type_traits>)
-SYMBOL(conjunction_v, std::, <type_traits>)
-SYMBOL(const_iterator, std::, <iterator>)
+SYMBOL_VERSION(conjunction, std::, <type_traits>, "c++17")
+SYMBOL_VERSION(conjunction_v, std::, <type_traits>, "c++17")
+SYMBOL_VERSION(const_iterator, std::, <iterator>, "c++23")
SYMBOL(const_mem_fun1_ref_t, std::, <functional>)
SYMBOL(const_mem_fun1_t, std::, <functional>)
SYMBOL(const_mem_fun_ref_t, std::, <functional>)
SYMBOL(const_mem_fun_t, std::, <functional>)
-SYMBOL(const_pointer_cast, std::, <memory>)
-SYMBOL(const_sentinel, std::, <iterator>)
-SYMBOL(construct_at, std::, <memory>)
-SYMBOL(constructible_from, std::, <concepts>)
-SYMBOL(contiguous_iterator, std::, <iterator>)
-SYMBOL(contiguous_iterator_tag, std::, <iterator>)
-SYMBOL(convertible_to, std::, <concepts>)
+SYMBOL_VERSION(const_pointer_cast, std::, <memory>, "c++11")
+SYMBOL_VERSION(const_sentinel, std::, <iterator>, "c++23")
+SYMBOL_VERSION(construct_at, std::, <memory>, "c++20")
+SYMBOL_VERSION(constructible_from, std::, <concepts>, "c++20")
+SYMBOL_VERSION(contiguous_iterator, std::, <iterator>, "c++20")
+SYMBOL_VERSION(contiguous_iterator_tag, std::, <iterator>, "c++20")
+SYMBOL_VERSION(convertible_to, std::, <concepts>, "c++20")
SYMBOL(copy, std::, <algorithm>)
SYMBOL(copy_backward, std::, <algorithm>)
-SYMBOL(copy_constructible, std::, <concepts>)
-SYMBOL(copy_if, std::, <algorithm>)
-SYMBOL(copy_n, std::, <algorithm>)
-SYMBOL(copyable, std::, <concepts>)
-SYMBOL(copyable_function, std::, <functional>)
-SYMBOL(copysign, std::, <cmath>)
-SYMBOL(copysign, None, <cmath>)
-SYMBOL(copysign, None, <math.h>)
-SYMBOL(copysignf, std::, <cmath>)
+SYMBOL_VERSION(copy_constructible, std::, <concepts>, "c++20")
+SYMBOL_VERSION(copy_if, std::, <algorithm>, "c++11")
+SYMBOL_VERSION(copy_n, std::, <algorithm>, "c++11")
+SYMBOL_VERSION(copyable, std::, <concepts>, "c++20")
+SYMBOL_VERSION(copyable_function, std::, <functional>, "c++26")
+SYMBOL_VERSION(copysignf, std::, <cmath>, "c++11")
SYMBOL(copysignf, None, <cmath>)
SYMBOL(copysignf, None, <math.h>)
-SYMBOL(copysignl, std::, <cmath>)
+SYMBOL_VERSION(copysignl, std::, <cmath>, "c++11")
SYMBOL(copysignl, None, <cmath>)
SYMBOL(copysignl, None, <math.h>)
-SYMBOL(coroutine_handle, std::, <coroutine>)
-SYMBOL(coroutine_traits, std::, <coroutine>)
-SYMBOL(cos, std::, <cmath>)
-SYMBOL(cos, None, <cmath>)
-SYMBOL(cos, None, <math.h>)
-SYMBOL(cosf, std::, <cmath>)
+SYMBOL_VERSION(coroutine_handle, std::, <coroutine>, "c++20")
+SYMBOL_VERSION(coroutine_traits, std::, <coroutine>, "c++20")
+SYMBOL_VERSION(cosf, std::, <cmath>, "c++11")
SYMBOL(cosf, None, <cmath>)
SYMBOL(cosf, None, <math.h>)
-SYMBOL(cosh, std::, <cmath>)
-SYMBOL(cosh, None, <cmath>)
-SYMBOL(cosh, None, <math.h>)
-SYMBOL(coshf, std::, <cmath>)
+SYMBOL_VERSION(coshf, std::, <cmath>, "c++11")
SYMBOL(coshf, None, <cmath>)
SYMBOL(coshf, None, <math.h>)
-SYMBOL(coshl, std::, <cmath>)
+SYMBOL_VERSION(coshl, std::, <cmath>, "c++11")
SYMBOL(coshl, None, <cmath>)
SYMBOL(coshl, None, <math.h>)
-SYMBOL(cosl, std::, <cmath>)
+SYMBOL_VERSION(cosl, std::, <cmath>, "c++11")
SYMBOL(cosl, None, <cmath>)
SYMBOL(cosl, None, <math.h>)
SYMBOL(count, std::, <algorithm>)
SYMBOL(count_if, std::, <algorithm>)
-SYMBOL(counted_iterator, std::, <iterator>)
-SYMBOL(counting_semaphore, std::, <semaphore>)
-SYMBOL(countl_one, std::, <bit>)
-SYMBOL(countl_zero, std::, <bit>)
-SYMBOL(countr_one, std::, <bit>)
-SYMBOL(countr_zero, std::, <bit>)
+SYMBOL_VERSION(counted_iterator, std::, <iterator>, "c++20")
+SYMBOL_VERSION(counting_semaphore, std::, <semaphore>, "c++20")
+SYMBOL_VERSION(countl_one, std::, <bit>, "c++20")
+SYMBOL_VERSION(countl_zero, std::, <bit>, "c++20")
+SYMBOL_VERSION(countr_one, std::, <bit>, "c++20")
+SYMBOL_VERSION(countr_zero, std::, <bit>, "c++20")
SYMBOL(cout, std::, <iostream>)
-SYMBOL(cref, std::, <functional>)
-SYMBOL(cregex_iterator, std::, <regex>)
-SYMBOL(cregex_token_iterator, std::, <regex>)
-SYMBOL(csub_match, std::, <regex>)
+SYMBOL_VERSION(cref, std::, <functional>, "c++11")
+SYMBOL_VERSION(cregex_iterator, std::, <regex>, "c++11")
+SYMBOL_VERSION(cregex_token_iterator, std::, <regex>, "c++11")
+SYMBOL_VERSION(csub_match, std::, <regex>, "c++11")
SYMBOL(ctime, std::, <ctime>)
SYMBOL(ctime, None, <ctime>)
SYMBOL(ctime, None, <time.h>)
SYMBOL(ctype, std::, <locale>)
SYMBOL(ctype_base, std::, <locale>)
SYMBOL(ctype_byname, std::, <locale>)
-SYMBOL(current_exception, std::, <exception>)
-SYMBOL(cv_status, std::, <condition_variable>)
-SYMBOL(cyl_bessel_i, std::, <cmath>)
-SYMBOL(cyl_bessel_if, std::, <cmath>)
-SYMBOL(cyl_bessel_il, std::, <cmath>)
-SYMBOL(cyl_bessel_j, std::, <cmath>)
-SYMBOL(cyl_bessel_jf, std::, <cmath>)
-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_VERSION(current_exception, std::, <exception>, "c++11")
+SYMBOL_VERSION(cv_status, std::, <condition_variable>, "c++11")
+SYMBOL_VERSION(cyl_bessel_i, std::, <cmath>, "c++17")
+SYMBOL_VERSION(cyl_bessel_if, std::, <cmath>, "c++17")
+SYMBOL_VERSION(cyl_bessel_il, std::, <cmath>, "c++17")
+SYMBOL_VERSION(cyl_bessel_j, std::, <cmath>, "c++17")
+SYMBOL_VERSION(cyl_bessel_jf, std::, <cmath>, "c++17")
+SYMBOL_VERSION(cyl_bessel_jl, std::, <cmath>, "c++17")
+SYMBOL_VERSION(cyl_bessel_k, std::, <cmath>, "c++17")
+SYMBOL_VERSION(cyl_bessel_kf, std::, <cmath>, "c++17")
+SYMBOL_VERSION(cyl_bessel_kl, std::, <cmath>, "c++17")
+SYMBOL_VERSION(cyl_neumann, std::, <cmath>, "c++17")
+SYMBOL_VERSION(cyl_neumannf, std::, <cmath>, "c++17")
+SYMBOL_VERSION(cyl_neumannl, std::, <cmath>, "c++17")
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(declare_no_pointers, std::, <memory>)
-SYMBOL(declare_reachable, std::, <memory>)
-SYMBOL(declval, std::, <utility>)
-SYMBOL(default_accessor, std::, <mdspan>)
-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_VERSION(deca, std::, <ratio>, "c++11")
+SYMBOL_VERSION(decay, std::, <type_traits>, "c++11")
+SYMBOL_VERSION(decay_t, std::, <type_traits>, "c++14")
+SYMBOL_VERSION(deci, std::, <ratio>, "c++11")
+SYMBOL_VERSION(declare_no_pointers, std::, <memory>, "c++11")
+SYMBOL_VERSION(declare_reachable, std::, <memory>, "c++11")
+SYMBOL_VERSION(declval, std::, <utility>, "c++11")
+SYMBOL_VERSION(default_accessor, std::, <mdspan>, "c++23")
+SYMBOL_VERSION(default_delete, std::, <memory>, "c++11")
+SYMBOL_VERSION(default_initializable, std::, <concepts>, "c++20")
+SYMBOL_VERSION(default_random_engine, std::, <random>, "c++11")
+SYMBOL_VERSION(default_searcher, std::, <functional>, "c++17")
+SYMBOL_VERSION(default_sentinel, std::, <iterator>, "c++20")
+SYMBOL_VERSION(default_sentinel_t, std::, <iterator>, "c++20")
+SYMBOL_VERSION(defaultfloat, std::, <ios>, "c++11")
+SYMBOL_VERSION(defaultfloat, std::, <iostream>, "c++11")
+SYMBOL_VERSION(defer_lock, std::, <mutex>, "c++11")
+SYMBOL_VERSION(defer_lock_t, std::, <mutex>, "c++11")
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(destroy_at, std::, <memory>)
-SYMBOL(destroy_n, std::, <memory>)
-SYMBOL(destroying_delete, std::, <new>)
-SYMBOL(destroying_delete_t, std::, <new>)
-SYMBOL(destructible, std::, <concepts>)
-SYMBOL(dextents, std::, <mdspan>)
+SYMBOL_VERSION(derived_from, std::, <concepts>, "c++20")
+SYMBOL_VERSION(destroy, std::, <memory>, "c++17")
+SYMBOL_VERSION(destroy_at, std::, <memory>, "c++17")
+SYMBOL_VERSION(destroy_n, std::, <memory>, "c++17")
+SYMBOL_VERSION(destroying_delete, std::, <new>, "c++20")
+SYMBOL_VERSION(destroying_delete_t, std::, <new>, "c++20")
+SYMBOL_VERSION(destructible, std::, <concepts>, "c++20")
+SYMBOL_VERSION(dextents, std::, <mdspan>, "c++23")
SYMBOL(difftime, std::, <ctime>)
SYMBOL(difftime, None, <ctime>)
SYMBOL(difftime, None, <time.h>)
-SYMBOL(dims, std::, <mdspan>)
-SYMBOL(disable_sized_sentinel_for, std::, <iterator>)
-SYMBOL(discard_block_engine, std::, <random>)
-SYMBOL(discrete_distribution, std::, <random>)
-SYMBOL(disjunction, std::, <type_traits>)
-SYMBOL(disjunction_v, std::, <type_traits>)
+SYMBOL_VERSION(dims, std::, <mdspan>, "c++26")
+SYMBOL_VERSION(disable_sized_sentinel_for, std::, <iterator>, "c++20")
+SYMBOL_VERSION(discard_block_engine, std::, <random>, "c++11")
+SYMBOL_VERSION(discrete_distribution, std::, <random>, "c++11")
+SYMBOL_VERSION(disjunction, std::, <type_traits>, "c++17")
+SYMBOL_VERSION(disjunction_v, std::, <type_traits>, "c++17")
SYMBOL(distance, std::, <iterator>)
-SYMBOL(div_sat, std::, <numeric>)
+SYMBOL_VERSION(div_sat, std::, <numeric>, "c++26")
SYMBOL(div_t, std::, <cstdlib>)
SYMBOL(div_t, None, <cstdlib>)
SYMBOL(div_t, None, <stdlib.h>)
SYMBOL(divides, std::, <functional>)
SYMBOL(domain_error, std::, <stdexcept>)
-SYMBOL(double_t, std::, <cmath>)
+SYMBOL_VERSION(double_t, std::, <cmath>, "c++11")
SYMBOL(double_t, None, <cmath>)
SYMBOL(double_t, None, <math.h>)
-SYMBOL(dynamic_extent, std::, <span>)
-SYMBOL(dynamic_pointer_cast, std::, <memory>)
-SYMBOL(ellint_1, std::, <cmath>)
-SYMBOL(ellint_1f, std::, <cmath>)
-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_nonlocking_formatter_optimization, std::, <format>)
-SYMBOL(enable_shared_from_this, std::, <memory>)
-SYMBOL(endian, std::, <bit>)
+SYMBOL_VERSION(dynamic_extent, std::, <span>, "c++20")
+SYMBOL_VERSION(dynamic_pointer_cast, std::, <memory>, "c++11")
+SYMBOL_VERSION(ellint_1, std::, <cmath>, "c++17")
+SYMBOL_VERSION(ellint_1f, std::, <cmath>, "c++17")
+SYMBOL_VERSION(ellint_1l, std::, <cmath>, "c++17")
+SYMBOL_VERSION(ellint_2, std::, <cmath>, "c++17")
+SYMBOL_VERSION(ellint_2f, std::, <cmath>, "c++17")
+SYMBOL_VERSION(ellint_2l, std::, <cmath>, "c++17")
+SYMBOL_VERSION(ellint_3, std::, <cmath>, "c++17")
+SYMBOL_VERSION(ellint_3f, std::, <cmath>, "c++17")
+SYMBOL_VERSION(ellint_3l, std::, <cmath>, "c++17")
+SYMBOL_VERSION(emit_on_flush, std::, <ostream>, "c++20")
+SYMBOL_VERSION(emit_on_flush, std::, <iostream>, "c++20")
+SYMBOL_VERSION(enable_if, std::, <type_traits>, "c++11")
+SYMBOL_VERSION(enable_if_t, std::, <type_traits>, "c++14")
+SYMBOL_VERSION(enable_nonlocking_formatter_optimization, std::, <format>, "c++23")
+SYMBOL_VERSION(enable_shared_from_this, std::, <memory>, "c++11")
+SYMBOL_VERSION(endian, std::, <bit>, "c++20")
SYMBOL(endl, std::, <ostream>)
SYMBOL(endl, std::, <iostream>)
SYMBOL(ends, std::, <ostream>)
@@ -1099,141 +1064,123 @@ 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(erf, std::, <cmath>)
-SYMBOL(erf, None, <cmath>)
-SYMBOL(erf, None, <math.h>)
-SYMBOL(erfc, std::, <cmath>)
-SYMBOL(erfc, None, <cmath>)
-SYMBOL(erfc, None, <math.h>)
-SYMBOL(erfcf, std::, <cmath>)
+SYMBOL_VERSION(equality_comparable, std::, <concepts>, "c++20")
+SYMBOL_VERSION(equality_comparable_with, std::, <concepts>, "c++20")
+SYMBOL_VERSION(equivalence_relation, std::, <concepts>, "c++20")
+SYMBOL_VERSION(erfcf, std::, <cmath>, "c++11")
SYMBOL(erfcf, None, <cmath>)
SYMBOL(erfcf, None, <math.h>)
-SYMBOL(erfcl, std::, <cmath>)
+SYMBOL_VERSION(erfcl, std::, <cmath>, "c++11")
SYMBOL(erfcl, None, <cmath>)
SYMBOL(erfcl, None, <math.h>)
-SYMBOL(erff, std::, <cmath>)
+SYMBOL_VERSION(erff, std::, <cmath>, "c++11")
SYMBOL(erff, None, <cmath>)
SYMBOL(erff, None, <math.h>)
-SYMBOL(erfl, std::, <cmath>)
+SYMBOL_VERSION(erfl, std::, <cmath>, "c++11")
SYMBOL(erfl, None, <cmath>)
SYMBOL(erfl, None, <math.h>)
-SYMBOL(errc, std::, <system_error>)
-SYMBOL(error_category, std::, <system_error>)
-SYMBOL(error_code, std::, <system_error>)
-SYMBOL(error_condition, std::, <system_error>)
-SYMBOL(exa, std::, <ratio>)
+SYMBOL_VERSION(errc, std::, <system_error>, "c++11")
+SYMBOL_VERSION(error_category, std::, <system_error>, "c++11")
+SYMBOL_VERSION(error_code, std::, <system_error>, "c++11")
+SYMBOL_VERSION(error_condition, std::, <system_error>, "c++11")
+SYMBOL_VERSION(exa, std::, <ratio>, "c++11")
SYMBOL(exception, std::, <exception>)
-SYMBOL(exception_ptr, std::, <exception>)
-SYMBOL(exchange, std::, <utility>)
-SYMBOL(exclusive_scan, std::, <numeric>)
+SYMBOL_VERSION(exception_ptr, std::, <exception>, "c++11")
+SYMBOL_VERSION(exchange, std::, <utility>, "c++14")
+SYMBOL_VERSION(exclusive_scan, std::, <numeric>, "c++17")
SYMBOL(exit, std::, <cstdlib>)
SYMBOL(exit, None, <cstdlib>)
SYMBOL(exit, None, <stdlib.h>)
-SYMBOL(exp, std::, <cmath>)
-SYMBOL(exp, None, <cmath>)
-SYMBOL(exp, None, <math.h>)
-SYMBOL(exp2, std::, <cmath>)
-SYMBOL(exp2, None, <cmath>)
-SYMBOL(exp2, None, <math.h>)
-SYMBOL(exp2f, std::, <cmath>)
+SYMBOL_VERSION(exp2f, std::, <cmath>, "c++11")
SYMBOL(exp2f, None, <cmath>)
SYMBOL(exp2f, None, <math.h>)
-SYMBOL(exp2l, std::, <cmath>)
+SYMBOL_VERSION(exp2l, std::, <cmath>, "c++11")
SYMBOL(exp2l, None, <cmath>)
SYMBOL(exp2l, None, <math.h>)
-SYMBOL(expected, std::, <expected>)
-SYMBOL(expf, std::, <cmath>)
+SYMBOL_VERSION(expected, std::, <expected>, "c++23")
+SYMBOL_VERSION(expf, std::, <cmath>, "c++11")
SYMBOL(expf, None, <cmath>)
SYMBOL(expf, None, <math.h>)
-SYMBOL(expint, std::, <cmath>)
-SYMBOL(expintf, std::, <cmath>)
-SYMBOL(expintl, std::, <cmath>)
-SYMBOL(expl, std::, <cmath>)
+SYMBOL_VERSION(expint, std::, <cmath>, "c++17")
+SYMBOL_VERSION(expintf, std::, <cmath>, "c++17")
+SYMBOL_VERSION(expintl, std::, <cmath>, "c++17")
+SYMBOL_VERSION(expl, std::, <cmath>, "c++11")
SYMBOL(expl, None, <cmath>)
SYMBOL(expl, None, <math.h>)
-SYMBOL(expm1, std::, <cmath>)
-SYMBOL(expm1, None, <cmath>)
-SYMBOL(expm1, None, <math.h>)
-SYMBOL(expm1f, std::, <cmath>)
+SYMBOL_VERSION(expm1f, std::, <cmath>, "c++11")
SYMBOL(expm1f, None, <cmath>)
SYMBOL(expm1f, None, <math.h>)
-SYMBOL(expm1l, std::, <cmath>)
+SYMBOL_VERSION(expm1l, std::, <cmath>, "c++11")
SYMBOL(expm1l, None, <cmath>)
SYMBOL(expm1l, None, <math.h>)
-SYMBOL(exponential_distribution, std::, <random>)
-SYMBOL(extent, std::, <type_traits>)
-SYMBOL(extent_v, std::, <type_traits>)
-SYMBOL(extents, std::, <mdspan>)
-SYMBOL(extreme_value_distribution, std::, <random>)
+SYMBOL_VERSION(exponential_distribution, std::, <random>, "c++11")
+SYMBOL_VERSION(extent, std::, <type_traits>, "c++11")
+SYMBOL_VERSION(extent_v, std::, <type_traits>, "c++17")
+SYMBOL_VERSION(extents, std::, <mdspan>, "c++23")
+SYMBOL_VERSION(extreme_value_distribution, std::, <random>, "c++11")
SYMBOL(fabs, std::, <cmath>)
SYMBOL(fabs, None, <cmath>)
SYMBOL(fabs, None, <math.h>)
-SYMBOL(fabsf, std::, <cmath>)
+SYMBOL_VERSION(fabsf, std::, <cmath>, "c++11")
SYMBOL(fabsf, None, <cmath>)
SYMBOL(fabsf, None, <math.h>)
-SYMBOL(fabsl, std::, <cmath>)
+SYMBOL_VERSION(fabsl, std::, <cmath>, "c++11")
SYMBOL(fabsl, None, <cmath>)
SYMBOL(fabsl, None, <math.h>)
-SYMBOL(false_type, std::, <type_traits>)
+SYMBOL_VERSION(false_type, std::, <type_traits>, "c++11")
SYMBOL(fclose, std::, <cstdio>)
SYMBOL(fclose, None, <cstdio>)
SYMBOL(fclose, None, <stdio.h>)
-SYMBOL(fdim, std::, <cmath>)
-SYMBOL(fdim, None, <cmath>)
-SYMBOL(fdim, None, <math.h>)
-SYMBOL(fdimf, std::, <cmath>)
+SYMBOL_VERSION(fdimf, std::, <cmath>, "c++11")
SYMBOL(fdimf, None, <cmath>)
SYMBOL(fdimf, None, <math.h>)
-SYMBOL(fdiml, std::, <cmath>)
+SYMBOL_VERSION(fdiml, std::, <cmath>, "c++11")
SYMBOL(fdiml, None, <cmath>)
SYMBOL(fdiml, None, <math.h>)
-SYMBOL(feclearexcept, std::, <cfenv>)
+SYMBOL_VERSION(feclearexcept, std::, <cfenv>, "c++11")
SYMBOL(feclearexcept, None, <cfenv>)
SYMBOL(feclearexcept, None, <fenv.h>)
-SYMBOL(fegetenv, std::, <cfenv>)
+SYMBOL_VERSION(fegetenv, std::, <cfenv>, "c++11")
SYMBOL(fegetenv, None, <cfenv>)
SYMBOL(fegetenv, None, <fenv.h>)
-SYMBOL(fegetexceptflag, std::, <cfenv>)
+SYMBOL_VERSION(fegetexceptflag, std::, <cfenv>, "c++11")
SYMBOL(fegetexceptflag, None, <cfenv>)
SYMBOL(fegetexceptflag, None, <fenv.h>)
-SYMBOL(fegetround, std::, <cfenv>)
+SYMBOL_VERSION(fegetround, std::, <cfenv>, "c++11")
SYMBOL(fegetround, None, <cfenv>)
SYMBOL(fegetround, None, <fenv.h>)
-SYMBOL(feholdexcept, std::, <cfenv>)
+SYMBOL_VERSION(feholdexcept, std::, <cfenv>, "c++11")
SYMBOL(feholdexcept, None, <cfenv>)
SYMBOL(feholdexcept, None, <fenv.h>)
-SYMBOL(femto, std::, <ratio>)
-SYMBOL(fenv_t, std::, <cfenv>)
+SYMBOL_VERSION(femto, std::, <ratio>, "c++11")
+SYMBOL_VERSION(fenv_t, std::, <cfenv>, "c++11")
SYMBOL(fenv_t, None, <cfenv>)
SYMBOL(fenv_t, None, <fenv.h>)
SYMBOL(feof, std::, <cstdio>)
SYMBOL(feof, None, <cstdio>)
SYMBOL(feof, None, <stdio.h>)
-SYMBOL(feraiseexcept, std::, <cfenv>)
+SYMBOL_VERSION(feraiseexcept, std::, <cfenv>, "c++11")
SYMBOL(feraiseexcept, None, <cfenv>)
SYMBOL(feraiseexcept, None, <fenv.h>)
SYMBOL(ferror, std::, <cstdio>)
SYMBOL(ferror, None, <cstdio>)
SYMBOL(ferror, None, <stdio.h>)
-SYMBOL(fesetenv, std::, <cfenv>)
+SYMBOL_VERSION(fesetenv, std::, <cfenv>, "c++11")
SYMBOL(fesetenv, None, <cfenv>)
SYMBOL(fesetenv, None, <fenv.h>)
-SYMBOL(fesetexceptflag, std::, <cfenv>)
+SYMBOL_VERSION(fesetexceptflag, std::, <cfenv>, "c++11")
SYMBOL(fesetexceptflag, None, <cfenv>)
SYMBOL(fesetexceptflag, None, <fenv.h>)
-SYMBOL(fesetround, std::, <cfenv>)
+SYMBOL_VERSION(fesetround, std::, <cfenv>, "c++11")
SYMBOL(fesetround, None, <cfenv>)
SYMBOL(fesetround, None, <fenv.h>)
-SYMBOL(fetestexcept, std::, <cfenv>)
+SYMBOL_VERSION(fetestexcept, std::, <cfenv>, "c++11")
SYMBOL(fetestexcept, None, <cfenv>)
SYMBOL(fetestexcept, None, <fenv.h>)
-SYMBOL(feupdateenv, std::, <cfenv>)
+SYMBOL_VERSION(feupdateenv, std::, <cfenv>, "c++11")
SYMBOL(feupdateenv, None, <cfenv>)
SYMBOL(feupdateenv, None, <fenv.h>)
-SYMBOL(fexcept_t, std::, <cfenv>)
+SYMBOL_VERSION(fexcept_t, std::, <cfenv>, "c++11")
SYMBOL(fexcept_t, None, <cfenv>)
SYMBOL(fexcept_t, None, <fenv.h>)
SYMBOL(fflush, std::, <cstdio>)
@@ -1262,94 +1209,82 @@ 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_VERSION(find_if_not, std::, <algorithm>, "c++11")
+SYMBOL_VERSION(fisher_f_distribution, std::, <random>, "c++11")
SYMBOL(fixed, std::, <ios>)
SYMBOL(fixed, std::, <iostream>)
-SYMBOL(flat_map, std::, <flat_map>)
-SYMBOL(flat_multimap, std::, <flat_map>)
-SYMBOL(flat_multiset, std::, <flat_set>)
-SYMBOL(flat_set, std::, <flat_set>)
+SYMBOL_VERSION(flat_map, std::, <flat_map>, "c++23")
+SYMBOL_VERSION(flat_multimap, std::, <flat_map>, "c++23")
+SYMBOL_VERSION(flat_multiset, std::, <flat_set>, "c++23")
+SYMBOL_VERSION(flat_set, std::, <flat_set>, "c++23")
SYMBOL(float_denorm_style, std::, <limits>)
SYMBOL(float_round_style, std::, <limits>)
-SYMBOL(float_t, std::, <cmath>)
+SYMBOL_VERSION(float_t, std::, <cmath>, "c++11")
SYMBOL(float_t, None, <cmath>)
SYMBOL(float_t, None, <math.h>)
-SYMBOL(floating_point, std::, <concepts>)
-SYMBOL(floor, std::, <cmath>)
-SYMBOL(floor, None, <cmath>)
-SYMBOL(floor, None, <math.h>)
-SYMBOL(floorf, std::, <cmath>)
+SYMBOL_VERSION(floating_point, std::, <concepts>, "c++20")
+SYMBOL_VERSION(floorf, std::, <cmath>, "c++11")
SYMBOL(floorf, None, <cmath>)
SYMBOL(floorf, None, <math.h>)
-SYMBOL(floorl, std::, <cmath>)
+SYMBOL_VERSION(floorl, std::, <cmath>, "c++11")
SYMBOL(floorl, None, <cmath>)
SYMBOL(floorl, None, <math.h>)
SYMBOL(flush, std::, <ostream>)
SYMBOL(flush, std::, <iostream>)
-SYMBOL(flush_emit, std::, <ostream>)
-SYMBOL(flush_emit, std::, <iostream>)
-SYMBOL(fma, std::, <cmath>)
+SYMBOL_VERSION(flush_emit, std::, <ostream>, "c++20")
+SYMBOL_VERSION(flush_emit, std::, <iostream>, "c++20")
+SYMBOL_VERSION(fma, std::, <cmath>, "c++11")
SYMBOL(fma, None, <cmath>)
SYMBOL(fma, None, <math.h>)
-SYMBOL(fmaf, std::, <cmath>)
+SYMBOL_VERSION(fmaf, std::, <cmath>, "c++11")
SYMBOL(fmaf, None, <cmath>)
SYMBOL(fmaf, None, <math.h>)
-SYMBOL(fmal, std::, <cmath>)
+SYMBOL_VERSION(fmal, std::, <cmath>, "c++11")
SYMBOL(fmal, None, <cmath>)
SYMBOL(fmal, None, <math.h>)
-SYMBOL(fmax, std::, <cmath>)
-SYMBOL(fmax, None, <cmath>)
-SYMBOL(fmax, None, <math.h>)
-SYMBOL(fmaxf, std::, <cmath>)
+SYMBOL_VERSION(fmaxf, std::, <cmath>, "c++11")
SYMBOL(fmaxf, None, <cmath>)
SYMBOL(fmaxf, None, <math.h>)
-SYMBOL(fmaxl, std::, <cmath>)
+SYMBOL_VERSION(fmaxl, std::, <cmath>, "c++11")
SYMBOL(fmaxl, None, <cmath>)
SYMBOL(fmaxl, None, <math.h>)
-SYMBOL(fmin, std::, <cmath>)
-SYMBOL(fmin, None, <cmath>)
-SYMBOL(fmin, None, <math.h>)
-SYMBOL(fminf, std::, <cmath>)
+SYMBOL_VERSION(fminf, std::, <cmath>, "c++11")
SYMBOL(fminf, None, <cmath>)
SYMBOL(fminf, None, <math.h>)
-SYMBOL(fminl, std::, <cmath>)
+SYMBOL_VERSION(fminl, std::, <cmath>, "c++11")
SYMBOL(fminl, None, <cmath>)
SYMBOL(fminl, None, <math.h>)
-SYMBOL(fmod, std::, <cmath>)
-SYMBOL(fmod, None, <cmath>)
-SYMBOL(fmod, None, <math.h>)
-SYMBOL(fmodf, std::, <cmath>)
+SYMBOL_VERSION(fmodf, std::, <cmath>, "c++11")
SYMBOL(fmodf, None, <cmath>)
SYMBOL(fmodf, None, <math.h>)
-SYMBOL(fmodl, std::, <cmath>)
+SYMBOL_VERSION(fmodl, std::, <cmath>, "c++11")
SYMBOL(fmodl, None, <cmath>)
SYMBOL(fmodl, None, <math.h>)
SYMBOL(fopen, std::, <cstdio>)
SYMBOL(fopen, None, <cstdio>)
SYMBOL(fopen, None, <stdio.h>)
SYMBOL(for_each, std::, <algorithm>)
-SYMBOL(for_each_n, std::, <algorithm>)
-SYMBOL(format, std::, <format>)
-SYMBOL(format_args, std::, <format>)
-SYMBOL(format_context, std::, <format>)
-SYMBOL(format_error, std::, <format>)
-SYMBOL(format_kind, std::, <format>)
-SYMBOL(format_parse_context, std::, <format>)
-SYMBOL(format_string, std::, <format>)
-SYMBOL(format_to, std::, <format>)
-SYMBOL(format_to_n, std::, <format>)
-SYMBOL(format_to_n_result, std::, <format>)
-SYMBOL(formattable, std::, <format>)
-SYMBOL(formatted_size, std::, <format>)
-SYMBOL(formatter, std::, <format>)
-SYMBOL(forward, std::, <utility>)
-SYMBOL(forward_as_tuple, std::, <tuple>)
-SYMBOL(forward_iterator, std::, <iterator>)
+SYMBOL_VERSION(for_each_n, std::, <algorithm>, "c++17")
+SYMBOL_VERSION(format, std::, <format>, "c++20")
+SYMBOL_VERSION(format_args, std::, <format>, "c++20")
+SYMBOL_VERSION(format_context, std::, <format>, "c++20")
+SYMBOL_VERSION(format_error, std::, <format>, "c++20")
+SYMBOL_VERSION(format_kind, std::, <format>, "c++23")
+SYMBOL_VERSION(format_parse_context, std::, <format>, "c++20")
+SYMBOL_VERSION(format_string, std::, <format>, "c++20")
+SYMBOL_VERSION(format_to, std::, <format>, "c++20")
+SYMBOL_VERSION(format_to_n, std::, <format>, "c++20")
+SYMBOL_VERSION(format_to_n_result, std::, <format>, "c++20")
+SYMBOL_VERSION(formattable, std::, <format>, "c++23")
+SYMBOL_VERSION(formatted_size, std::, <format>, "c++20")
+SYMBOL_VERSION(formatter, std::, <format>, "c++20")
+SYMBOL_VERSION(forward, std::, <utility>, "c++11")
+SYMBOL_VERSION(forward_as_tuple, std::, <tuple>, "c++11")
+SYMBOL_VERSION(forward_iterator, std::, <iterator>, "c++20")
SYMBOL(forward_iterator_tag, std::, <iterator>)
-SYMBOL(forward_like, std::, <utility>)
-SYMBOL(forward_list, std::, <forward_list>)
-SYMBOL(fpclassify, std::, <cmath>)
+SYMBOL_VERSION(forward_like, std::, <utility>, "c++23")
+SYMBOL_VERSION(forward_list, std::, <forward_list>, "c++11")
+SYMBOL_VERSION(fpclassify, std::, <cmath>, "c++11")
SYMBOL(fpclassify, None, <cmath>)
SYMBOL(fpclassify, None, <math.h>)
SYMBOL(fpos, std::, <ios>)
@@ -1385,16 +1320,16 @@ SYMBOL(freopen, None, <stdio.h>)
SYMBOL(frexp, std::, <cmath>)
SYMBOL(frexp, None, <cmath>)
SYMBOL(frexp, None, <math.h>)
-SYMBOL(frexpf, std::, <cmath>)
+SYMBOL_VERSION(frexpf, std::, <cmath>, "c++11")
SYMBOL(frexpf, None, <cmath>)
SYMBOL(frexpf, None, <math.h>)
-SYMBOL(frexpl, std::, <cmath>)
+SYMBOL_VERSION(frexpl, std::, <cmath>, "c++11")
SYMBOL(frexpl, None, <cmath>)
SYMBOL(frexpl, None, <math.h>)
-SYMBOL(from_chars, std::, <charconv>)
-SYMBOL(from_chars_result, std::, <charconv>)
-SYMBOL(from_range, std::, <ranges>)
-SYMBOL(from_range_t, std::, <ranges>)
+SYMBOL_VERSION(from_chars, std::, <charconv>, "c++17")
+SYMBOL_VERSION(from_chars_result, std::, <charconv>, "c++17")
+SYMBOL_VERSION(from_range, std::, <ranges>, "c++23")
+SYMBOL_VERSION(from_range_t, std::, <ranges>, "c++23")
SYMBOL(front_insert_iterator, std::, <iterator>)
SYMBOL(front_inserter, std::, <iterator>)
SYMBOL(fscanf, std::, <cstdio>)
@@ -1411,13 +1346,13 @@ SYMBOL(fstream, std::, <iosfwd>)
SYMBOL(ftell, std::, <cstdio>)
SYMBOL(ftell, None, <cstdio>)
SYMBOL(ftell, None, <stdio.h>)
-SYMBOL(function, std::, <functional>)
-SYMBOL(function_ref, 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_VERSION(function, std::, <functional>, "c++11")
+SYMBOL_VERSION(function_ref, std::, <functional>, "c++26")
+SYMBOL_VERSION(future, std::, <future>, "c++11")
+SYMBOL_VERSION(future_category, std::, <future>, "c++11")
+SYMBOL_VERSION(future_errc, std::, <future>, "c++11")
+SYMBOL_VERSION(future_error, std::, <future>, "c++11")
+SYMBOL_VERSION(future_status, std::, <future>, "c++11")
SYMBOL(fwide, std::, <cwchar>)
SYMBOL(fwide, None, <cwchar>)
SYMBOL(fwide, None, <wchar.h>)
@@ -1430,22 +1365,22 @@ SYMBOL(fwrite, None, <stdio.h>)
SYMBOL(fwscanf, std::, <cwchar>)
SYMBOL(fwscanf, None, <cwchar>)
SYMBOL(fwscanf, None, <wchar.h>)
-SYMBOL(gamma_distribution, std::, <random>)
-SYMBOL(gcd, std::, <numeric>)
+SYMBOL_VERSION(gamma_distribution, std::, <random>, "c++11")
+SYMBOL_VERSION(gcd, std::, <numeric>, "c++17")
SYMBOL(generate, std::, <algorithm>)
-SYMBOL(generate_canonical, std::, <random>)
+SYMBOL_VERSION(generate_canonical, std::, <random>, "c++11")
SYMBOL(generate_n, std::, <algorithm>)
-SYMBOL(generator, std::, <generator>)
-SYMBOL(generic_category, std::, <system_error>)
-SYMBOL(geometric_distribution, std::, <random>)
-SYMBOL(get_deleter, std::, <memory>)
-SYMBOL(get_if, std::, <variant>)
-SYMBOL(get_money, std::, <iomanip>)
-SYMBOL(get_new_handler, std::, <new>)
-SYMBOL(get_pointer_safety, std::, <memory>)
+SYMBOL_VERSION(generator, std::, <generator>, "c++23")
+SYMBOL_VERSION(generic_category, std::, <system_error>, "c++11")
+SYMBOL_VERSION(geometric_distribution, std::, <random>, "c++11")
+SYMBOL_VERSION(get_deleter, std::, <memory>, "c++11")
+SYMBOL_VERSION(get_if, std::, <variant>, "c++17")
+SYMBOL_VERSION(get_money, std::, <iomanip>, "c++11")
+SYMBOL_VERSION(get_new_handler, std::, <new>, "c++11")
+SYMBOL_VERSION(get_pointer_safety, std::, <memory>, "c++11")
SYMBOL(get_temporary_buffer, std::, <memory>)
-SYMBOL(get_terminate, std::, <exception>)
-SYMBOL(get_time, std::, <iomanip>)
+SYMBOL_VERSION(get_terminate, std::, <exception>, "c++11")
+SYMBOL_VERSION(get_time, std::, <iomanip>, "c++11")
SYMBOL(get_unexpected, std::, <exception>)
SYMBOL(getc, std::, <cstdio>)
SYMBOL(getc, None, <cstdio>)
@@ -1466,7 +1401,7 @@ SYMBOL(getwc, None, <wchar.h>)
SYMBOL(getwchar, std::, <cwchar>)
SYMBOL(getwchar, None, <cwchar>)
SYMBOL(getwchar, None, <wchar.h>)
-SYMBOL(giga, std::, <ratio>)
+SYMBOL_VERSION(giga, std::, <ratio>, "c++11")
SYMBOL(gmtime, std::, <ctime>)
SYMBOL(gmtime, None, <ctime>)
SYMBOL(gmtime, None, <time.h>)
@@ -1474,151 +1409,151 @@ SYMBOL(greater, std::, <functional>)
SYMBOL(greater_equal, std::, <functional>)
SYMBOL(gslice, std::, <valarray>)
SYMBOL(gslice_array, std::, <valarray>)
-SYMBOL(hardware_constructive_interference_size, std::, <new>)
-SYMBOL(hardware_destructive_interference_size, std::, <new>)
+SYMBOL_VERSION(hardware_constructive_interference_size, std::, <new>, "c++17")
+SYMBOL_VERSION(hardware_destructive_interference_size, std::, <new>, "c++17")
SYMBOL(has_facet, std::, <locale>)
-SYMBOL(has_single_bit, std::, <bit>)
-SYMBOL(has_unique_object_representations, std::, <type_traits>)
-SYMBOL(has_unique_object_representations_v, std::, <type_traits>)
-SYMBOL(has_virtual_destructor, std::, <type_traits>)
-SYMBOL(has_virtual_destructor_v, std::, <type_traits>)
-SYMBOL(hecto, std::, <ratio>)
-SYMBOL(hermite, std::, <cmath>)
-SYMBOL(hermitef, std::, <cmath>)
-SYMBOL(hermitel, std::, <cmath>)
+SYMBOL_VERSION(has_single_bit, std::, <bit>, "c++20")
+SYMBOL_VERSION(has_unique_object_representations, std::, <type_traits>, "c++17")
+SYMBOL_VERSION(has_unique_object_representations_v, std::, <type_traits>, "c++17")
+SYMBOL_VERSION(has_virtual_destructor, std::, <type_traits>, "c++11")
+SYMBOL_VERSION(has_virtual_destructor_v, std::, <type_traits>, "c++17")
+SYMBOL_VERSION(hecto, std::, <ratio>, "c++11")
+SYMBOL_VERSION(hermite, std::, <cmath>, "c++17")
+SYMBOL_VERSION(hermitef, std::, <cmath>, "c++17")
+SYMBOL_VERSION(hermitel, std::, <cmath>, "c++17")
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_VERSION(hexfloat, std::, <ios>, "c++11")
+SYMBOL_VERSION(hexfloat, std::, <iostream>, "c++11")
+SYMBOL_VERSION(holds_alternative, std::, <variant>, "c++17")
+SYMBOL_VERSION(hypot, std::, <cmath>, "c++11")
SYMBOL(hypot, None, <cmath>)
SYMBOL(hypot, None, <math.h>)
-SYMBOL(hypotf, std::, <cmath>)
+SYMBOL_VERSION(hypotf, std::, <cmath>, "c++11")
SYMBOL(hypotf, None, <cmath>)
SYMBOL(hypotf, None, <math.h>)
-SYMBOL(hypotl, std::, <cmath>)
+SYMBOL_VERSION(hypotl, std::, <cmath>, "c++11")
SYMBOL(hypotl, None, <cmath>)
SYMBOL(hypotl, None, <math.h>)
-SYMBOL(identity, std::, <functional>)
+SYMBOL_VERSION(identity, std::, <functional>, "c++20")
SYMBOL(ifstream, std::, <fstream>)
SYMBOL(ifstream, std::, <iosfwd>)
-SYMBOL(ilogb, std::, <cmath>)
+SYMBOL_VERSION(ilogb, std::, <cmath>, "c++11")
SYMBOL(ilogb, None, <cmath>)
SYMBOL(ilogb, None, <math.h>)
-SYMBOL(ilogbf, std::, <cmath>)
+SYMBOL_VERSION(ilogbf, std::, <cmath>, "c++11")
SYMBOL(ilogbf, None, <cmath>)
SYMBOL(ilogbf, None, <math.h>)
-SYMBOL(ilogbl, std::, <cmath>)
+SYMBOL_VERSION(ilogbl, std::, <cmath>, "c++11")
SYMBOL(ilogbl, None, <cmath>)
SYMBOL(ilogbl, None, <math.h>)
SYMBOL(imag, std::, <complex>)
-SYMBOL(imaxabs, std::, <cinttypes>)
+SYMBOL_VERSION(imaxabs, std::, <cinttypes>, "c++11")
SYMBOL(imaxabs, None, <cinttypes>)
SYMBOL(imaxabs, None, <inttypes.h>)
-SYMBOL(imaxdiv, std::, <cinttypes>)
+SYMBOL_VERSION(imaxdiv, std::, <cinttypes>, "c++11")
SYMBOL(imaxdiv, None, <cinttypes>)
SYMBOL(imaxdiv, None, <inttypes.h>)
-SYMBOL(imaxdiv_t, std::, <cinttypes>)
+SYMBOL_VERSION(imaxdiv_t, std::, <cinttypes>, "c++11")
SYMBOL(imaxdiv_t, None, <cinttypes>)
SYMBOL(imaxdiv_t, None, <inttypes.h>)
-SYMBOL(in_place, std::, <utility>)
-SYMBOL(in_place_index, std::, <utility>)
-SYMBOL(in_place_index_t, std::, <utility>)
-SYMBOL(in_place_t, std::, <utility>)
-SYMBOL(in_place_type, std::, <utility>)
-SYMBOL(in_place_type_t, std::, <utility>)
-SYMBOL(in_range, std::, <utility>)
+SYMBOL_VERSION(in_place, std::, <utility>, "c++17")
+SYMBOL_VERSION(in_place_index, std::, <utility>, "c++17")
+SYMBOL_VERSION(in_place_index_t, std::, <utility>, "c++17")
+SYMBOL_VERSION(in_place_t, std::, <utility>, "c++17")
+SYMBOL_VERSION(in_place_type, std::, <utility>, "c++17")
+SYMBOL_VERSION(in_place_type_t, std::, <utility>, "c++17")
+SYMBOL_VERSION(in_range, std::, <utility>, "c++20")
SYMBOL(includes, std::, <algorithm>)
-SYMBOL(inclusive_scan, std::, <numeric>)
-SYMBOL(incrementable, std::, <iterator>)
-SYMBOL(incrementable_traits, std::, <iterator>)
-SYMBOL(independent_bits_engine, std::, <random>)
-SYMBOL(index_sequence, std::, <utility>)
-SYMBOL(index_sequence_for, std::, <utility>)
+SYMBOL_VERSION(inclusive_scan, std::, <numeric>, "c++17")
+SYMBOL_VERSION(incrementable, std::, <iterator>, "c++20")
+SYMBOL_VERSION(incrementable_traits, std::, <iterator>, "c++20")
+SYMBOL_VERSION(independent_bits_engine, std::, <random>, "c++11")
+SYMBOL_VERSION(index_sequence, std::, <utility>, "c++14")
+SYMBOL_VERSION(index_sequence_for, std::, <utility>, "c++14")
SYMBOL(indirect_array, std::, <valarray>)
-SYMBOL(indirect_binary_predicate, std::, <iterator>)
-SYMBOL(indirect_equivalence_relation, std::, <iterator>)
-SYMBOL(indirect_result_t, std::, <iterator>)
-SYMBOL(indirect_strict_weak_order, std::, <iterator>)
-SYMBOL(indirect_unary_predicate, std::, <iterator>)
-SYMBOL(indirectly_comparable, std::, <iterator>)
-SYMBOL(indirectly_copyable, std::, <iterator>)
-SYMBOL(indirectly_copyable_storable, std::, <iterator>)
-SYMBOL(indirectly_movable, std::, <iterator>)
-SYMBOL(indirectly_movable_storable, std::, <iterator>)
-SYMBOL(indirectly_readable, std::, <iterator>)
-SYMBOL(indirectly_readable_traits, std::, <iterator>)
-SYMBOL(indirectly_regular_unary_invocable, std::, <iterator>)
-SYMBOL(indirectly_swappable, std::, <iterator>)
-SYMBOL(indirectly_unary_invocable, std::, <iterator>)
-SYMBOL(indirectly_writable, std::, <iterator>)
-SYMBOL(initializer_list, std::, <initializer_list>)
+SYMBOL_VERSION(indirect_binary_predicate, std::, <iterator>, "c++20")
+SYMBOL_VERSION(indirect_equivalence_relation, std::, <iterator>, "c++20")
+SYMBOL_VERSION(indirect_result_t, std::, <iterator>, "c++20")
+SYMBOL_VERSION(indirect_strict_weak_order, std::, <iterator>, "c++20")
+SYMBOL_VERSION(indirect_unary_predicate, std::, <iterator>, "c++20")
+SYMBOL_VERSION(indirectly_comparable, std::, <iterator>, "c++20")
+SYMBOL_VERSION(indirectly_copyable, std::, <iterator>, "c++20")
+SYMBOL_VERSION(indirectly_copyable_storable, std::, <iterator>, "c++20")
+SYMBOL_VERSION(indirectly_movable, std::, <iterator>, "c++20")
+SYMBOL_VERSION(indirectly_movable_storable, std::, <iterator>, "c++20")
+SYMBOL_VERSION(indirectly_readable, std::, <iterator>, "c++20")
+SYMBOL_VERSION(indirectly_readable_traits, std::, <iterator>, "c++20")
+SYMBOL_VERSION(indirectly_regular_unary_invocable, std::, <iterator>, "c++20")
+SYMBOL_VERSION(indirectly_swappable, std::, <iterator>, "c++20")
+SYMBOL_VERSION(indirectly_unary_invocable, std::, <iterator>, "c++20")
+SYMBOL_VERSION(indirectly_writable, std::, <iterator>, "c++20")
+SYMBOL_VERSION(initializer_list, std::, <initializer_list>, "c++11")
SYMBOL(inner_product, std::, <numeric>)
-SYMBOL(inout_ptr, std::, <memory>)
-SYMBOL(inout_ptr_t, std::, <memory>)
+SYMBOL_VERSION(inout_ptr, std::, <memory>, "c++23")
+SYMBOL_VERSION(inout_ptr_t, std::, <memory>, "c++23")
SYMBOL(inplace_merge, std::, <algorithm>)
-SYMBOL(inplace_vector, std::, <inplace_vector>)
-SYMBOL(input_iterator, std::, <iterator>)
+SYMBOL_VERSION(inplace_vector, std::, <inplace_vector>, "c++26")
+SYMBOL_VERSION(input_iterator, std::, <iterator>, "c++20")
SYMBOL(input_iterator_tag, std::, <iterator>)
-SYMBOL(input_or_output_iterator, std::, <iterator>)
+SYMBOL_VERSION(input_or_output_iterator, std::, <iterator>, "c++20")
SYMBOL(insert_iterator, std::, <iterator>)
SYMBOL(inserter, std::, <iterator>)
-SYMBOL(int16_t, std::, <cstdint>)
+SYMBOL_VERSION(int16_t, std::, <cstdint>, "c++11")
SYMBOL(int16_t, None, <cstdint>)
SYMBOL(int16_t, None, <stdint.h>)
-SYMBOL(int32_t, std::, <cstdint>)
+SYMBOL_VERSION(int32_t, std::, <cstdint>, "c++11")
SYMBOL(int32_t, None, <cstdint>)
SYMBOL(int32_t, None, <stdint.h>)
-SYMBOL(int64_t, std::, <cstdint>)
+SYMBOL_VERSION(int64_t, std::, <cstdint>, "c++11")
SYMBOL(int64_t, None, <cstdint>)
SYMBOL(int64_t, None, <stdint.h>)
-SYMBOL(int8_t, std::, <cstdint>)
+SYMBOL_VERSION(int8_t, std::, <cstdint>, "c++11")
SYMBOL(int8_t, None, <cstdint>)
SYMBOL(int8_t, None, <stdint.h>)
-SYMBOL(int_fast16_t, std::, <cstdint>)
+SYMBOL_VERSION(int_fast16_t, std::, <cstdint>, "c++11")
SYMBOL(int_fast16_t, None, <cstdint>)
SYMBOL(int_fast16_t, None, <stdint.h>)
-SYMBOL(int_fast32_t, std::, <cstdint>)
+SYMBOL_VERSION(int_fast32_t, std::, <cstdint>, "c++11")
SYMBOL(int_fast32_t, None, <cstdint>)
SYMBOL(int_fast32_t, None, <stdint.h>)
-SYMBOL(int_fast64_t, std::, <cstdint>)
+SYMBOL_VERSION(int_fast64_t, std::, <cstdint>, "c++11")
SYMBOL(int_fast64_t, None, <cstdint>)
SYMBOL(int_fast64_t, None, <stdint.h>)
-SYMBOL(int_fast8_t, std::, <cstdint>)
+SYMBOL_VERSION(int_fast8_t, std::, <cstdint>, "c++11")
SYMBOL(int_fast8_t, None, <cstdint>)
SYMBOL(int_fast8_t, None, <stdint.h>)
-SYMBOL(int_least16_t, std::, <cstdint>)
+SYMBOL_VERSION(int_least16_t, std::, <cstdint>, "c++11")
SYMBOL(int_least16_t, None, <cstdint>)
SYMBOL(int_least16_t, None, <stdint.h>)
-SYMBOL(int_least32_t, std::, <cstdint>)
+SYMBOL_VERSION(int_least32_t, std::, <cstdint>, "c++11")
SYMBOL(int_least32_t, None, <cstdint>)
SYMBOL(int_least32_t, None, <stdint.h>)
-SYMBOL(int_least64_t, std::, <cstdint>)
+SYMBOL_VERSION(int_least64_t, std::, <cstdint>, "c++11")
SYMBOL(int_least64_t, None, <cstdint>)
SYMBOL(int_least64_t, None, <stdint.h>)
-SYMBOL(int_least8_t, std::, <cstdint>)
+SYMBOL_VERSION(int_least8_t, std::, <cstdint>, "c++11")
SYMBOL(int_least8_t, None, <cstdint>)
SYMBOL(int_least8_t, None, <stdint.h>)
-SYMBOL(integer_sequence, std::, <utility>)
-SYMBOL(integral, std::, <concepts>)
-SYMBOL(integral_constant, std::, <type_traits>)
+SYMBOL_VERSION(integer_sequence, std::, <utility>, "c++14")
+SYMBOL_VERSION(integral, std::, <concepts>, "c++20")
+SYMBOL_VERSION(integral_constant, std::, <type_traits>, "c++11")
SYMBOL(internal, std::, <ios>)
SYMBOL(internal, std::, <iostream>)
-SYMBOL(intmax_t, std::, <cstdint>)
+SYMBOL_VERSION(intmax_t, std::, <cstdint>, "c++11")
SYMBOL(intmax_t, None, <cstdint>)
SYMBOL(intmax_t, None, <stdint.h>)
-SYMBOL(intptr_t, std::, <cstdint>)
+SYMBOL_VERSION(intptr_t, std::, <cstdint>, "c++11")
SYMBOL(intptr_t, None, <cstdint>)
SYMBOL(intptr_t, None, <stdint.h>)
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_VERSION(invocable, std::, <concepts>, "c++20")
+SYMBOL_VERSION(invoke, std::, <functional>, "c++17")
+SYMBOL_VERSION(invoke_r, std::, <functional>, "c++23")
+SYMBOL_VERSION(invoke_result, std::, <type_traits>, "c++17")
+SYMBOL_VERSION(invoke_result_t, std::, <type_traits>, "c++17")
+SYMBOL_VERSION(io_errc, std::, <ios>, "c++11")
+SYMBOL_VERSION(io_errc, std::, <iostream>, "c++11")
SYMBOL(io_state, std::, <ios>)
SYMBOL(io_state, std::, <iostream>)
SYMBOL(ios, std::, <ios>)
@@ -1629,197 +1564,197 @@ 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(is_array_v, std::, <type_traits>)
-SYMBOL(is_assignable, std::, <type_traits>)
-SYMBOL(is_assignable_v, std::, <type_traits>)
-SYMBOL(is_base_of, std::, <type_traits>)
-SYMBOL(is_base_of_v, std::, <type_traits>)
-SYMBOL(is_bind_expression, std::, <functional>)
-SYMBOL(is_bind_expression_v, std::, <functional>)
-SYMBOL(is_bounded_array, std::, <type_traits>)
-SYMBOL(is_bounded_array_v, std::, <type_traits>)
-SYMBOL(is_class, std::, <type_traits>)
-SYMBOL(is_class_v, std::, <type_traits>)
-SYMBOL(is_compound, std::, <type_traits>)
-SYMBOL(is_compound_v, std::, <type_traits>)
-SYMBOL(is_const, std::, <type_traits>)
-SYMBOL(is_const_v, std::, <type_traits>)
-SYMBOL(is_constant_evaluated, std::, <type_traits>)
-SYMBOL(is_constructible, std::, <type_traits>)
-SYMBOL(is_constructible_v, std::, <type_traits>)
-SYMBOL(is_convertible, std::, <type_traits>)
-SYMBOL(is_convertible_v, std::, <type_traits>)
-SYMBOL(is_copy_assignable, std::, <type_traits>)
-SYMBOL(is_copy_assignable_v, std::, <type_traits>)
-SYMBOL(is_copy_constructible, std::, <type_traits>)
-SYMBOL(is_copy_constructible_v, std::, <type_traits>)
-SYMBOL(is_corresponding_member, std::, <type_traits>)
-SYMBOL(is_debugger_present, std::, <debugging>)
-SYMBOL(is_default_constructible, std::, <type_traits>)
-SYMBOL(is_default_constructible_v, std::, <type_traits>)
-SYMBOL(is_destructible, std::, <type_traits>)
-SYMBOL(is_destructible_v, std::, <type_traits>)
-SYMBOL(is_empty, std::, <type_traits>)
-SYMBOL(is_empty_v, std::, <type_traits>)
-SYMBOL(is_enum, std::, <type_traits>)
-SYMBOL(is_enum_v, std::, <type_traits>)
-SYMBOL(is_eq, std::, <compare>)
-SYMBOL(is_error_code_enum, std::, <system_error>)
-SYMBOL(is_error_condition_enum, std::, <system_error>)
-SYMBOL(is_error_condition_enum_v, std::, <system_error>)
-SYMBOL(is_execution_policy, std::, <execution>)
-SYMBOL(is_execution_policy_v, std::, <execution>)
-SYMBOL(is_final, std::, <type_traits>)
-SYMBOL(is_final_v, std::, <type_traits>)
-SYMBOL(is_floating_point, std::, <type_traits>)
-SYMBOL(is_floating_point_v, std::, <type_traits>)
-SYMBOL(is_function, std::, <type_traits>)
-SYMBOL(is_function_v, std::, <type_traits>)
-SYMBOL(is_fundamental, std::, <type_traits>)
-SYMBOL(is_fundamental_v, std::, <type_traits>)
-SYMBOL(is_gt, std::, <compare>)
-SYMBOL(is_gteq, std::, <compare>)
-SYMBOL(is_heap, std::, <algorithm>)
-SYMBOL(is_heap_until, std::, <algorithm>)
-SYMBOL(is_implicit_lifetime, std::, <type_traits>)
-SYMBOL(is_integral, std::, <type_traits>)
-SYMBOL(is_integral_v, std::, <type_traits>)
-SYMBOL(is_invocable, std::, <type_traits>)
-SYMBOL(is_invocable_r, std::, <type_traits>)
-SYMBOL(is_invocable_r_v, std::, <type_traits>)
-SYMBOL(is_invocable_v, std::, <type_traits>)
-SYMBOL(is_layout_compatible, std::, <type_traits>)
-SYMBOL(is_layout_compatible_v, std::, <type_traits>)
-SYMBOL(is_literal_type, std::, <type_traits>)
-SYMBOL(is_literal_type_v, std::, <type_traits>)
-SYMBOL(is_lt, std::, <compare>)
-SYMBOL(is_lteq, std::, <compare>)
-SYMBOL(is_lvalue_reference, std::, <type_traits>)
-SYMBOL(is_lvalue_reference_v, std::, <type_traits>)
-SYMBOL(is_member_function_pointer, std::, <type_traits>)
-SYMBOL(is_member_function_pointer_v, std::, <type_traits>)
-SYMBOL(is_member_object_pointer, std::, <type_traits>)
-SYMBOL(is_member_object_pointer_v, std::, <type_traits>)
-SYMBOL(is_member_pointer, std::, <type_traits>)
-SYMBOL(is_member_pointer_v, std::, <type_traits>)
-SYMBOL(is_move_assignable, std::, <type_traits>)
-SYMBOL(is_move_assignable_v, std::, <type_traits>)
-SYMBOL(is_move_constructible, std::, <type_traits>)
-SYMBOL(is_move_constructible_v, std::, <type_traits>)
-SYMBOL(is_neq, std::, <compare>)
-SYMBOL(is_nothrow_assignable, std::, <type_traits>)
-SYMBOL(is_nothrow_assignable_v, std::, <type_traits>)
-SYMBOL(is_nothrow_constructible, std::, <type_traits>)
-SYMBOL(is_nothrow_constructible_v, std::, <type_traits>)
-SYMBOL(is_nothrow_convertible, std::, <type_traits>)
-SYMBOL(is_nothrow_convertible_v, std::, <type_traits>)
-SYMBOL(is_nothrow_copy_assignable, std::, <type_traits>)
-SYMBOL(is_nothrow_copy_assignable_v, std::, <type_traits>)
-SYMBOL(is_nothrow_copy_constructible, std::, <type_traits>)
-SYMBOL(is_nothrow_copy_constructible_v, std::, <type_traits>)
-SYMBOL(is_nothrow_default_constructible, std::, <type_traits>)
-SYMBOL(is_nothrow_default_constructible_v, std::, <type_traits>)
-SYMBOL(is_nothrow_destructible, std::, <type_traits>)
-SYMBOL(is_nothrow_destructible_v, std::, <type_traits>)
-SYMBOL(is_nothrow_invocable, std::, <type_traits>)
-SYMBOL(is_nothrow_invocable_r, std::, <type_traits>)
-SYMBOL(is_nothrow_invocable_r_v, std::, <type_traits>)
-SYMBOL(is_nothrow_invocable_v, std::, <type_traits>)
-SYMBOL(is_nothrow_move_assignable, std::, <type_traits>)
-SYMBOL(is_nothrow_move_assignable_v, std::, <type_traits>)
-SYMBOL(is_nothrow_move_constructible, std::, <type_traits>)
-SYMBOL(is_nothrow_move_constructible_v, std::, <type_traits>)
-SYMBOL(is_nothrow_swappable, std::, <type_traits>)
-SYMBOL(is_nothrow_swappable_v, std::, <type_traits>)
-SYMBOL(is_nothrow_swappable_with, std::, <type_traits>)
-SYMBOL(is_nothrow_swappable_with_v, std::, <type_traits>)
-SYMBOL(is_null_pointer, std::, <type_traits>)
-SYMBOL(is_null_pointer_v, std::, <type_traits>)
-SYMBOL(is_object, std::, <type_traits>)
-SYMBOL(is_object_v, std::, <type_traits>)
-SYMBOL(is_partitioned, std::, <algorithm>)
-SYMBOL(is_permutation, std::, <algorithm>)
-SYMBOL(is_placeholder, std::, <functional>)
-SYMBOL(is_placeholder_v, std::, <functional>)
-SYMBOL(is_pod, std::, <type_traits>)
-SYMBOL(is_pod_v, std::, <type_traits>)
-SYMBOL(is_pointer, std::, <type_traits>)
-SYMBOL(is_pointer_interconvertible_base_of, std::, <type_traits>)
-SYMBOL(is_pointer_interconvertible_base_of_v, std::, <type_traits>)
-SYMBOL(is_pointer_interconvertible_with_class, std::, <type_traits>)
-SYMBOL(is_pointer_v, std::, <type_traits>)
-SYMBOL(is_polymorphic, std::, <type_traits>)
-SYMBOL(is_polymorphic_v, std::, <type_traits>)
-SYMBOL(is_reference, std::, <type_traits>)
-SYMBOL(is_reference_v, std::, <type_traits>)
-SYMBOL(is_rvalue_reference, std::, <type_traits>)
-SYMBOL(is_rvalue_reference_v, std::, <type_traits>)
-SYMBOL(is_same, std::, <type_traits>)
-SYMBOL(is_same_v, std::, <type_traits>)
-SYMBOL(is_scalar, std::, <type_traits>)
-SYMBOL(is_scalar_v, std::, <type_traits>)
-SYMBOL(is_scoped_enum, std::, <type_traits>)
-SYMBOL(is_scoped_enum_v, std::, <type_traits>)
-SYMBOL(is_signed, std::, <type_traits>)
-SYMBOL(is_signed_v, std::, <type_traits>)
-SYMBOL(is_sorted, std::, <algorithm>)
-SYMBOL(is_sorted_until, std::, <algorithm>)
-SYMBOL(is_standard_layout, std::, <type_traits>)
-SYMBOL(is_standard_layout_v, std::, <type_traits>)
-SYMBOL(is_swappable, std::, <type_traits>)
-SYMBOL(is_swappable_v, std::, <type_traits>)
-SYMBOL(is_swappable_with, std::, <type_traits>)
-SYMBOL(is_swappable_with_v, std::, <type_traits>)
-SYMBOL(is_trivial, std::, <type_traits>)
-SYMBOL(is_trivial_v, std::, <type_traits>)
-SYMBOL(is_trivially_assignable, std::, <type_traits>)
-SYMBOL(is_trivially_assignable_v, std::, <type_traits>)
-SYMBOL(is_trivially_constructible, std::, <type_traits>)
-SYMBOL(is_trivially_constructible_v, std::, <type_traits>)
-SYMBOL(is_trivially_copy_assignable, std::, <type_traits>)
-SYMBOL(is_trivially_copy_assignable_v, std::, <type_traits>)
-SYMBOL(is_trivially_copy_constructible, std::, <type_traits>)
-SYMBOL(is_trivially_copy_constructible_v, std::, <type_traits>)
-SYMBOL(is_trivially_copyable, std::, <type_traits>)
-SYMBOL(is_trivially_copyable_v, std::, <type_traits>)
-SYMBOL(is_trivially_default_constructible, std::, <type_traits>)
-SYMBOL(is_trivially_default_constructible_v, std::, <type_traits>)
-SYMBOL(is_trivially_destructible, std::, <type_traits>)
-SYMBOL(is_trivially_destructible_v, std::, <type_traits>)
-SYMBOL(is_trivially_move_assignable, std::, <type_traits>)
-SYMBOL(is_trivially_move_assignable_v, std::, <type_traits>)
-SYMBOL(is_trivially_move_constructible, std::, <type_traits>)
-SYMBOL(is_trivially_move_constructible_v, std::, <type_traits>)
-SYMBOL(is_unbounded_array, std::, <type_traits>)
-SYMBOL(is_unbounded_array_v, std::, <type_traits>)
-SYMBOL(is_union, std::, <type_traits>)
-SYMBOL(is_union_v, std::, <type_traits>)
-SYMBOL(is_unsigned, std::, <type_traits>)
-SYMBOL(is_unsigned_v, std::, <type_traits>)
-SYMBOL(is_virtual_base_of, std::, <type_traits>)
-SYMBOL(is_virtual_base_of_v, std::, <type_traits>)
-SYMBOL(is_void, std::, <type_traits>)
-SYMBOL(is_void_v, std::, <type_traits>)
-SYMBOL(is_volatile, std::, <type_traits>)
-SYMBOL(is_volatile_v, std::, <type_traits>)
-SYMBOL(is_within_lifetime, std::, <type_traits>)
+SYMBOL_VERSION(iostream_category, std::, <ios>, "c++11")
+SYMBOL_VERSION(iostream_category, std::, <iostream>, "c++11")
+SYMBOL_VERSION(iota, std::, <numeric>, "c++11")
+SYMBOL_VERSION(is_abstract, std::, <type_traits>, "c++11")
+SYMBOL_VERSION(is_abstract_v, std::, <type_traits>, "c++17")
+SYMBOL_VERSION(is_aggregate, std::, <type_traits>, "c++17")
+SYMBOL_VERSION(is_aggregate_v, std::, <type_traits>, "c++17")
+SYMBOL_VERSION(is_arithmetic, std::, <type_traits>, "c++11")
+SYMBOL_VERSION(is_arithmetic_v, std::, <type_traits>, "c++17")
+SYMBOL_VERSION(is_array, std::, <type_traits>, "c++11")
+SYMBOL_VERSION(is_array_v, std::, <type_traits>, "c++17")
+SYMBOL_VERSION(is_assignable, std::, <type_traits>, "c++11")
+SYMBOL_VERSION(is_assignable_v, std::, <type_traits>, "c++17")
+SYMBOL_VERSION(is_base_of, std::, <type_traits>, "c++11")
+SYMBOL_VERSION(is_base_of_v, std::, <type_traits>, "c++17")
+SYMBOL_VERSION(is_bind_expression, std::, <functional>, "c++11")
+SYMBOL_VERSION(is_bind_expression_v, std::, <functional>, "c++17")
+SYMBOL_VERSION(is_bounded_array, std::, <type_traits>, "c++20")
+SYMBOL_VERSION(is_bounded_array_v, std::, <type_traits>, "c++20")
+SYMBOL_VERSION(is_class, std::, <type_traits>, "c++11")
+SYMBOL_VERSION(is_class_v, std::, <type_traits>, "c++17")
+SYMBOL_VERSION(is_compound, std::, <type_traits>, "c++11")
+SYMBOL_VERSION(is_compound_v, std::, <type_traits>, "c++17")
+SYMBOL_VERSION(is_const, std::, <type_traits>, "c++11")
+SYMBOL_VERSION(is_const_v, std::, <type_traits>, "c++17")
+SYMBOL_VERSION(is_constant_evaluated, std::, <type_traits>, "c++20")
+SYMBOL_VERSION(is_constructible, std::, <type_traits>, "c++11")
+SYMBOL_VERSION(is_constructible_v, std::, <type_traits>, "c++17")
+SYMBOL_VERSION(is_convertible, std::, <type_traits>, "c++11")
+SYMBOL_VERSION(is_convertible_v, std::, <type_traits>, "c++17")
+SYMBOL_VERSION(is_copy_assignable, std::, <type_traits>, "c++11")
+SYMBOL_VERSION(is_copy_assignable_v, std::, <type_traits>, "c++17")
+SYMBOL_VERSION(is_copy_constructible, std::, <type_traits>, "c++11")
+SYMBOL_VERSION(is_copy_constructible_v, std::, <type_traits>, "c++17")
+SYMBOL_VERSION(is_corresponding_member, std::, <type_traits>, "c++20")
+SYMBOL_VERSION(is_debugger_present, std::, <debugging>, "c++26")
+SYMBOL_VERSION(is_default_constructible, std::, <type_traits>, "c++11")
+SYMBOL_VERSION(is_default_constructible_v, std::, <type_traits>, "c++17")
+SYMBOL_VERSION(is_destructible, std::, <type_traits>, "c++11")
+SYMBOL_VERSION(is_destructible_v, std::, <type_traits>, "c++17")
+SYMBOL_VERSION(is_empty, std::, <type_traits>, "c++11")
+SYMBOL_VERSION(is_empty_v, std::, <type_traits>, "c++17")
+SYMBOL_VERSION(is_enum, std::, <type_traits>, "c++11")
+SYMBOL_VERSION(is_enum_v, std::, <type_traits>, "c++17")
+SYMBOL_VERSION(is_eq, std::, <compare>, "c++20")
+SYMBOL_VERSION(is_error_code_enum, std::, <system_error>, "c++11")
+SYMBOL_VERSION(is_error_condition_enum, std::, <system_error>, "c++11")
+SYMBOL_VERSION(is_error_condition_enum_v, std::, <system_error>, "c++17")
+SYMBOL_VERSION(is_execution_policy, std::, <execution>, "c++17")
+SYMBOL_VERSION(is_execution_policy_v, std::, <execution>, "c++17")
+SYMBOL_VERSION(is_final, std::, <type_traits>, "c++14")
+SYMBOL_VERSION(is_final_v, std::, <type_traits>, "c++17")
+SYMBOL_VERSION(is_floating_point, std::, <type_traits>, "c++11")
+SYMBOL_VERSION(is_floating_point_v, std::, <type_traits>, "c++17")
+SYMBOL_VERSION(is_function, std::, <type_traits>, "c++11")
+SYMBOL_VERSION(is_function_v, std::, <type_traits>, "c++17")
+SYMBOL_VERSION(is_fundamental, std::, <type_traits>, "c++11")
+SYMBOL_VERSION(is_fundamental_v, std::, <type_traits>, "c++17")
+SYMBOL_VERSION(is_gt, std::, <compare>, "c++20")
+SYMBOL_VERSION(is_gteq, std::, <compare>, "c++20")
+SYMBOL_VERSION(is_heap, std::, <algorithm>, "c++11")
+SYMBOL_VERSION(is_heap_until, std::, <algorithm>, "c++11")
+SYMBOL_VERSION(is_implicit_lifetime, std::, <type_traits>, "c++23")
+SYMBOL_VERSION(is_integral, std::, <type_traits>, "c++11")
+SYMBOL_VERSION(is_integral_v, std::, <type_traits>, "c++17")
+SYMBOL_VERSION(is_invocable, std::, <type_traits>, "c++17")
+SYMBOL_VERSION(is_invocable_r, std::, <type_traits>, "c++17")
+SYMBOL_VERSION(is_invocable_r_v, std::, <type_traits>, "c++17")
+SYMBOL_VERSION(is_invocable_v, std::, <type_traits>, "c++17")
+SYMBOL_VERSION(is_layout_compatible, std::, <type_traits>, "c++20")
+SYMBOL_VERSION(is_layout_compatible_v, std::, <type_traits>, "c++20")
+SYMBOL_VERSION(is_literal_type, std::, <type_traits>, "c++11")
+SYMBOL_VERSION(is_literal_type_v, std::, <type_traits>, "c++17")
+SYMBOL_VERSION(is_lt, std::, <compare>, "c++20")
+SYMBOL_VERSION(is_lteq, std::, <compare>, "c++20")
+SYMBOL_VERSION(is_lvalue_reference, std::, <type_traits>, "c++11")
+SYMBOL_VERSION(is_lvalue_reference_v, std::, <type_traits>, "c++17")
+SYMBOL_VERSION(is_member_function_pointer, std::, <type_traits>, "c++11")
+SYMBOL_VERSION(is_member_function_pointer_v, std::, <type_traits>, "c++17")
+SYMBOL_VERSION(is_member_object_pointer, std::, <type_traits>, "c++11")
+SYMBOL_VERSION(is_member_object_pointer_v, std::, <type_traits>, "c++17")
+SYMBOL_VERSION(is_member_pointer, std::, <type_traits>, "c++11")
+SYMBOL_VERSION(is_member_pointer_v, std::, <type_traits>, "c++17")
+SYMBOL_VERSION(is_move_assignable, std::, <type_traits>, "c++11")
+SYMBOL_VERSION(is_move_assignable_v, std::, <type_traits>, "c++17")
+SYMBOL_VERSION(is_move_constructible, std::, <type_traits>, "c++11")
+SYMBOL_VERSION(is_move_constructible_v, std::, <type_traits>, "c++17")
+SYMBOL_VERSION(is_neq, std::, <compare>, "c++20")
+SYMBOL_VERSION(is_nothrow_assignable, std::, <type_traits>, "c++11")
+SYMBOL_VERSION(is_nothrow_assignable_v, std::, <type_traits>, "c++17")
+SYMBOL_VERSION(is_nothrow_constructible, std::, <type_traits>, "c++11")
+SYMBOL_VERSION(is_nothrow_constructible_v, std::, <type_traits>, "c++17")
+SYMBOL_VERSION(is_nothrow_convertible, std::, <type_traits>, "c++20")
+SYMBOL_VERSION(is_nothrow_convertible_v, std::, <type_traits>, "c++20")
+SYMBOL_VERSION(is_nothrow_copy_assignable, std::, <type_traits>, "c++11")
+SYMBOL_VERSION(is_nothrow_copy_assignable_v, std::, <type_traits>, "c++17")
+SYMBOL_VERSION(is_nothrow_copy_constructible, std::, <type_traits>, "c++11")
+SYMBOL_VERSION(is_nothrow_copy_constructible_v, std::, <type_traits>, "c++17")
+SYMBOL_VERSION(is_nothrow_default_constructible, std::, <type_traits>, "c++11")
+SYMBOL_VERSION(is_nothrow_default_constructible_v, std::, <type_traits>, "c++17")
+SYMBOL_VERSION(is_nothrow_destructible, std::, <type_traits>, "c++11")
+SYMBOL_VERSION(is_nothrow_destructible_v, std::, <type_traits>, "c++17")
+SYMBOL_VERSION(is_nothrow_invocable, std::, <type_traits>, "c++17")
+SYMBOL_VERSION(is_nothrow_invocable_r, std::, <type_traits>, "c++17")
+SYMBOL_VERSION(is_nothrow_invocable_r_v, std::, <type_traits>, "c++17")
+SYMBOL_VERSION(is_nothrow_invocable_v, std::, <type_traits>, "c++17")
+SYMBOL_VERSION(is_nothrow_move_assignable, std::, <type_traits>, "c++11")
+SYMBOL_VERSION(is_nothrow_move_assignable_v, std::, <type_traits>, "c++17")
+SYMBOL_VERSION(is_nothrow_move_constructible, std::, <type_traits>, "c++11")
+SYMBOL_VERSION(is_nothrow_move_constructible_v, std::, <type_traits>, "c++17")
+SYMBOL_VERSION(is_nothrow_swappable, std::, <type_traits>, "c++17")
+SYMBOL_VERSION(is_nothrow_swappable_v, std::, <type_traits>, "c++17")
+SYMBOL_VERSION(is_nothrow_swappable_with, std::, <type_traits>, "c++17")
+SYMBOL_VERSION(is_nothrow_swappable_with_v, std::, <type_traits>, "c++17")
+SYMBOL_VERSION(is_null_pointer, std::, <type_traits>, "c++11")
+SYMBOL_VERSION(is_null_pointer_v, std::, <type_traits>, "c++17")
+SYMBOL_VERSION(is_object, std::, <type_traits>, "c++11")
+SYMBOL_VERSION(is_object_v, std::, <type_traits>, "c++17")
+SYMBOL_VERSION(is_partitioned, std::, <algorithm>, "c++11")
+SYMBOL_VERSION(is_permutation, std::, <algorithm>, "c++11")
+SYMBOL_VERSION(is_placeholder, std::, <functional>, "c++11")
+SYMBOL_VERSION(is_placeholder_v, std::, <functional>, "c++17")
+SYMBOL_VERSION(is_pod, std::, <type_traits>, "c++11")
+SYMBOL_VERSION(is_pod_v, std::, <type_traits>, "c++17")
+SYMBOL_VERSION(is_pointer, std::, <type_traits>, "c++11")
+SYMBOL_VERSION(is_pointer_interconvertible_base_of, std::, <type_traits>, "c++20")
+SYMBOL_VERSION(is_pointer_interconvertible_base_of_v, std::, <type_traits>, "c++20")
+SYMBOL_VERSION(is_pointer_interconvertible_with_class, std::, <type_traits>, "c++20")
+SYMBOL_VERSION(is_pointer_v, std::, <type_traits>, "c++17")
+SYMBOL_VERSION(is_polymorphic, std::, <type_traits>, "c++11")
+SYMBOL_VERSION(is_polymorphic_v, std::, <type_traits>, "c++17")
+SYMBOL_VERSION(is_reference, std::, <type_traits>, "c++11")
+SYMBOL_VERSION(is_reference_v, std::, <type_traits>, "c++17")
+SYMBOL_VERSION(is_rvalue_reference, std::, <type_traits>, "c++11")
+SYMBOL_VERSION(is_rvalue_reference_v, std::, <type_traits>, "c++17")
+SYMBOL_VERSION(is_same, std::, <type_traits>, "c++11")
+SYMBOL_VERSION(is_same_v, std::, <type_traits>, "c++17")
+SYMBOL_VERSION(is_scalar, std::, <type_traits>, "c++11")
+SYMBOL_VERSION(is_scalar_v, std::, <type_traits>, "c++17")
+SYMBOL_VERSION(is_scoped_enum, std::, <type_traits>, "c++23")
+SYMBOL_VERSION(is_scoped_enum_v, std::, <type_traits>, "c++23")
+SYMBOL_VERSION(is_signed, std::, <type_traits>, "c++11")
+SYMBOL_VERSION(is_signed_v, std::, <type_traits>, "c++17")
+SYMBOL_VERSION(is_sorted, std::, <algorithm>, "c++11")
+SYMBOL_VERSION(is_sorted_until, std::, <algorithm>, "c++11")
+SYMBOL_VERSION(is_standard_layout, std::, <type_traits>, "c++11")
+SYMBOL_VERSION(is_standard_layout_v, std::, <type_traits>, "c++17")
+SYMBOL_VERSION(is_swappable, std::, <type_traits>, "c++17")
+SYMBOL_VERSION(is_swappable_v, std::, <type_traits>, "c++17")
+SYMBOL_VERSION(is_swappable_with, std::, <type_traits>, "c++17")
+SYMBOL_VERSION(is_swappable_with_v, std::, <type_traits>, "c++17")
+SYMBOL_VERSION(is_trivial, std::, <type_traits>, "c++11")
+SYMBOL_VERSION(is_trivial_v, std::, <type_traits>, "c++17")
+SYMBOL_VERSION(is_trivially_assignable, std::, <type_traits>, "c++11")
+SYMBOL_VERSION(is_trivially_assignable_v, std::, <type_traits>, "c++17")
+SYMBOL_VERSION(is_trivially_constructible, std::, <type_traits>, "c++11")
+SYMBOL_VERSION(is_trivially_constructible_v, std::, <type_traits>, "c++17")
+SYMBOL_VERSION(is_trivially_copy_assignable, std::, <type_traits>, "c++11")
+SYMBOL_VERSION(is_trivially_copy_assignable_v, std::, <type_traits>, "c++17")
+SYMBOL_VERSION(is_trivially_copy_constructible, std::, <type_traits>, "c++11")
+SYMBOL_VERSION(is_trivially_copy_constructible_v, std::, <type_traits>, "c++17")
+SYMBOL_VERSION(is_trivially_copyable, std::, <type_traits>, "c++11")
+SYMBOL_VERSION(is_trivially_copyable_v, std::, <type_traits>, "c++17")
+SYMBOL_VERSION(is_trivially_default_constructible, std::, <type_traits>, "c++11")
+SYMBOL_VERSION(is_trivially_default_constructible_v, std::, <type_traits>, "c++17")
+SYMBOL_VERSION(is_trivially_destructible, std::, <type_traits>, "c++11")
+SYMBOL_VERSION(is_trivially_destructible_v, std::, <type_traits>, "c++17")
+SYMBOL_VERSION(is_trivially_move_assignable, std::, <type_traits>, "c++11")
+SYMBOL_VERSION(is_trivially_move_assignable_v, std::, <type_traits>, "c++17")
+SYMBOL_VERSION(is_trivially_move_constructible, std::, <type_traits>, "c++11")
+SYMBOL_VERSION(is_trivially_move_constructible_v, std::, <type_traits>, "c++17")
+SYMBOL_VERSION(is_unbounded_array, std::, <type_traits>, "c++20")
+SYMBOL_VERSION(is_unbounded_array_v, std::, <type_traits>, "c++20")
+SYMBOL_VERSION(is_union, std::, <type_traits>, "c++11")
+SYMBOL_VERSION(is_union_v, std::, <type_traits>, "c++17")
+SYMBOL_VERSION(is_unsigned, std::, <type_traits>, "c++11")
+SYMBOL_VERSION(is_unsigned_v, std::, <type_traits>, "c++17")
+SYMBOL_VERSION(is_virtual_base_of, std::, <type_traits>, "c++26")
+SYMBOL_VERSION(is_virtual_base_of_v, std::, <type_traits>, "c++26")
+SYMBOL_VERSION(is_void, std::, <type_traits>, "c++11")
+SYMBOL_VERSION(is_void_v, std::, <type_traits>, "c++17")
+SYMBOL_VERSION(is_volatile, std::, <type_traits>, "c++11")
+SYMBOL_VERSION(is_volatile_v, std::, <type_traits>, "c++17")
+SYMBOL_VERSION(is_within_lifetime, std::, <type_traits>, "c++26")
SYMBOL(isalnum, std::, <cctype>)
SYMBOL(isalnum, None, <cctype>)
SYMBOL(isalnum, None, <ctype.h>)
SYMBOL(isalpha, std::, <cctype>)
SYMBOL(isalpha, None, <cctype>)
SYMBOL(isalpha, None, <ctype.h>)
-SYMBOL(isblank, std::, <cctype>)
+SYMBOL_VERSION(isblank, std::, <cctype>, "c++11")
SYMBOL(isblank, None, <cctype>)
SYMBOL(isblank, None, <ctype.h>)
SYMBOL(iscntrl, std::, <cctype>)
@@ -1828,41 +1763,29 @@ SYMBOL(iscntrl, None, <ctype.h>)
SYMBOL(isdigit, std::, <cctype>)
SYMBOL(isdigit, None, <cctype>)
SYMBOL(isdigit, None, <ctype.h>)
-SYMBOL(isfinite, std::, <cmath>)
-SYMBOL(isfinite, None, <cmath>)
-SYMBOL(isfinite, None, <math.h>)
SYMBOL(isgraph, std::, <cctype>)
SYMBOL(isgraph, None, <cctype>)
SYMBOL(isgraph, None, <ctype.h>)
-SYMBOL(isgreater, std::, <cmath>)
+SYMBOL_VERSION(isgreater, std::, <cmath>, "c++11")
SYMBOL(isgreater, None, <cmath>)
SYMBOL(isgreater, None, <math.h>)
-SYMBOL(isgreaterequal, std::, <cmath>)
+SYMBOL_VERSION(isgreaterequal, std::, <cmath>, "c++11")
SYMBOL(isgreaterequal, None, <cmath>)
SYMBOL(isgreaterequal, None, <math.h>)
-SYMBOL(isinf, std::, <cmath>)
-SYMBOL(isinf, None, <cmath>)
-SYMBOL(isinf, None, <math.h>)
-SYMBOL(isless, std::, <cmath>)
+SYMBOL_VERSION(isless, std::, <cmath>, "c++11")
SYMBOL(isless, None, <cmath>)
SYMBOL(isless, None, <math.h>)
-SYMBOL(islessequal, std::, <cmath>)
+SYMBOL_VERSION(islessequal, std::, <cmath>, "c++11")
SYMBOL(islessequal, None, <cmath>)
SYMBOL(islessequal, None, <math.h>)
-SYMBOL(islessgreater, std::, <cmath>)
+SYMBOL_VERSION(islessgreater, std::, <cmath>, "c++11")
SYMBOL(islessgreater, None, <cmath>)
SYMBOL(islessgreater, None, <math.h>)
SYMBOL(islower, std::, <cctype>)
SYMBOL(islower, None, <cctype>)
SYMBOL(islower, None, <ctype.h>)
-SYMBOL(isnan, std::, <cmath>)
-SYMBOL(isnan, None, <cmath>)
-SYMBOL(isnan, None, <math.h>)
-SYMBOL(isnormal, std::, <cmath>)
-SYMBOL(isnormal, None, <cmath>)
-SYMBOL(isnormal, None, <math.h>)
-SYMBOL(ispanstream, std::, <spanstream>)
-SYMBOL(ispanstream, std::, <iosfwd>)
+SYMBOL_VERSION(ispanstream, std::, <spanstream>, "c++23")
+SYMBOL_VERSION(ispanstream, std::, <iosfwd>, "c++23")
SYMBOL(isprint, std::, <cctype>)
SYMBOL(isprint, None, <cctype>)
SYMBOL(isprint, None, <ctype.h>)
@@ -1881,8 +1804,7 @@ SYMBOL(istreambuf_iterator, std::, <iosfwd>)
SYMBOL(istringstream, std::, <sstream>)
SYMBOL(istringstream, std::, <iosfwd>)
SYMBOL(istrstream, std::, <strstream>)
-SYMBOL(istrstream, std::, <strstream>)
-SYMBOL(isunordered, std::, <cmath>)
+SYMBOL_VERSION(isunordered, std::, <cmath>, "c++11")
SYMBOL(isunordered, None, <cmath>)
SYMBOL(isunordered, None, <math.h>)
SYMBOL(isupper, std::, <cctype>)
@@ -1894,7 +1816,7 @@ SYMBOL(iswalnum, None, <wctype.h>)
SYMBOL(iswalpha, std::, <cwctype>)
SYMBOL(iswalpha, None, <cwctype>)
SYMBOL(iswalpha, None, <wctype.h>)
-SYMBOL(iswblank, std::, <cwctype>)
+SYMBOL_VERSION(iswblank, std::, <cwctype>, "c++11")
SYMBOL(iswblank, None, <cwctype>)
SYMBOL(iswblank, None, <wctype.h>)
SYMBOL(iswcntrl, std::, <cwctype>)
@@ -1930,47 +1852,47 @@ SYMBOL(iswxdigit, None, <wctype.h>)
SYMBOL(isxdigit, std::, <cctype>)
SYMBOL(isxdigit, None, <cctype>)
SYMBOL(isxdigit, None, <ctype.h>)
-SYMBOL(iter_common_reference_t, std::, <iterator>)
-SYMBOL(iter_const_reference_t, std::, <iterator>)
-SYMBOL(iter_difference_t, std::, <iterator>)
-SYMBOL(iter_reference_t, std::, <iterator>)
-SYMBOL(iter_rvalue_reference_t, std::, <iterator>)
+SYMBOL_VERSION(iter_common_reference_t, std::, <iterator>, "c++20")
+SYMBOL_VERSION(iter_const_reference_t, std::, <iterator>, "c++23")
+SYMBOL_VERSION(iter_difference_t, std::, <iterator>, "c++20")
+SYMBOL_VERSION(iter_reference_t, std::, <iterator>, "c++20")
+SYMBOL_VERSION(iter_rvalue_reference_t, std::, <iterator>, "c++20")
SYMBOL(iter_swap, std::, <algorithm>)
-SYMBOL(iter_value_t, std::, <iterator>)
+SYMBOL_VERSION(iter_value_t, std::, <iterator>, "c++20")
SYMBOL(iterator, std::, <iterator>)
SYMBOL(iterator_traits, std::, <iterator>)
SYMBOL(jmp_buf, std::, <csetjmp>)
SYMBOL(jmp_buf, None, <csetjmp>)
SYMBOL(jmp_buf, None, <setjmp.h>)
-SYMBOL(jthread, std::, <thread>)
-SYMBOL(kill_dependency, std::, <atomic>)
-SYMBOL(kilo, std::, <ratio>)
-SYMBOL(knuth_b, std::, <random>)
+SYMBOL_VERSION(jthread, std::, <thread>, "c++20")
+SYMBOL_VERSION(kill_dependency, std::, <atomic>, "c++11")
+SYMBOL_VERSION(kilo, std::, <ratio>, "c++11")
+SYMBOL_VERSION(knuth_b, std::, <random>, "c++11")
SYMBOL(labs, std::, <cstdlib>)
SYMBOL(labs, None, <cstdlib>)
SYMBOL(labs, None, <stdlib.h>)
-SYMBOL(laguerre, std::, <cmath>)
-SYMBOL(laguerref, std::, <cmath>)
-SYMBOL(laguerrel, std::, <cmath>)
-SYMBOL(latch, std::, <latch>)
-SYMBOL(launch, std::, <future>)
-SYMBOL(launder, std::, <new>)
-SYMBOL(layout_left, std::, <mdspan>)
-SYMBOL(layout_left_padded, std::, <mdspan>)
-SYMBOL(layout_right, std::, <mdspan>)
-SYMBOL(layout_right_padded, std::, <mdspan>)
-SYMBOL(layout_stride, std::, <mdspan>)
-SYMBOL(lcm, std::, <numeric>)
+SYMBOL_VERSION(laguerre, std::, <cmath>, "c++17")
+SYMBOL_VERSION(laguerref, std::, <cmath>, "c++17")
+SYMBOL_VERSION(laguerrel, std::, <cmath>, "c++17")
+SYMBOL_VERSION(latch, std::, <latch>, "c++20")
+SYMBOL_VERSION(launch, std::, <future>, "c++11")
+SYMBOL_VERSION(launder, std::, <new>, "c++17")
+SYMBOL_VERSION(layout_left, std::, <mdspan>, "c++23")
+SYMBOL_VERSION(layout_left_padded, std::, <mdspan>, "c++26")
+SYMBOL_VERSION(layout_right, std::, <mdspan>, "c++23")
+SYMBOL_VERSION(layout_right_padded, std::, <mdspan>, "c++26")
+SYMBOL_VERSION(layout_stride, std::, <mdspan>, "c++23")
+SYMBOL_VERSION(lcm, std::, <numeric>, "c++17")
SYMBOL(lconv, std::, <clocale>)
SYMBOL(lconv, None, <clocale>)
SYMBOL(lconv, None, <locale.h>)
SYMBOL(ldexp, std::, <cmath>)
SYMBOL(ldexp, None, <cmath>)
SYMBOL(ldexp, None, <math.h>)
-SYMBOL(ldexpf, std::, <cmath>)
+SYMBOL_VERSION(ldexpf, std::, <cmath>, "c++11")
SYMBOL(ldexpf, None, <cmath>)
SYMBOL(ldexpf, None, <math.h>)
-SYMBOL(ldexpl, std::, <cmath>)
+SYMBOL_VERSION(ldexpl, std::, <cmath>, "c++11")
SYMBOL(ldexpl, None, <cmath>)
SYMBOL(ldexpl, None, <math.h>)
SYMBOL(ldiv, std::, <cstdlib>)
@@ -1981,51 +1903,48 @@ SYMBOL(ldiv_t, None, <cstdlib>)
SYMBOL(ldiv_t, None, <stdlib.h>)
SYMBOL(left, std::, <ios>)
SYMBOL(left, std::, <iostream>)
-SYMBOL(legendre, std::, <cmath>)
-SYMBOL(legendref, std::, <cmath>)
-SYMBOL(legendrel, std::, <cmath>)
+SYMBOL_VERSION(legendre, std::, <cmath>, "c++17")
+SYMBOL_VERSION(legendref, std::, <cmath>, "c++17")
+SYMBOL_VERSION(legendrel, std::, <cmath>, "c++17")
SYMBOL(length_error, std::, <stdexcept>)
-SYMBOL(lerp, std::, <cmath>)
+SYMBOL_VERSION(lerp, std::, <cmath>, "c++20")
SYMBOL(less, std::, <functional>)
SYMBOL(less_equal, std::, <functional>)
SYMBOL(lexicographical_compare, std::, <algorithm>)
-SYMBOL(lexicographical_compare_three_way, std::, <algorithm>)
-SYMBOL(lgamma, std::, <cmath>)
-SYMBOL(lgamma, None, <cmath>)
-SYMBOL(lgamma, None, <math.h>)
-SYMBOL(lgammaf, std::, <cmath>)
+SYMBOL_VERSION(lexicographical_compare_three_way, std::, <algorithm>, "c++20")
+SYMBOL_VERSION(lgammaf, std::, <cmath>, "c++11")
SYMBOL(lgammaf, None, <cmath>)
SYMBOL(lgammaf, None, <math.h>)
-SYMBOL(lgammal, std::, <cmath>)
+SYMBOL_VERSION(lgammal, std::, <cmath>, "c++11")
SYMBOL(lgammal, None, <cmath>)
SYMBOL(lgammal, None, <math.h>)
-SYMBOL(linear_congruential_engine, std::, <random>)
+SYMBOL_VERSION(linear_congruential_engine, std::, <random>, "c++11")
SYMBOL(list, std::, <list>)
-SYMBOL(llabs, std::, <cstdlib>)
+SYMBOL_VERSION(llabs, std::, <cstdlib>, "c++11")
SYMBOL(llabs, None, <cstdlib>)
SYMBOL(llabs, None, <stdlib.h>)
-SYMBOL(lldiv, std::, <cstdlib>)
+SYMBOL_VERSION(lldiv, std::, <cstdlib>, "c++11")
SYMBOL(lldiv, None, <cstdlib>)
SYMBOL(lldiv, None, <stdlib.h>)
-SYMBOL(lldiv_t, std::, <cstdlib>)
+SYMBOL_VERSION(lldiv_t, std::, <cstdlib>, "c++11")
SYMBOL(lldiv_t, None, <cstdlib>)
SYMBOL(lldiv_t, None, <stdlib.h>)
-SYMBOL(llrint, std::, <cmath>)
+SYMBOL_VERSION(llrint, std::, <cmath>, "c++11")
SYMBOL(llrint, None, <cmath>)
SYMBOL(llrint, None, <math.h>)
-SYMBOL(llrintf, std::, <cmath>)
+SYMBOL_VERSION(llrintf, std::, <cmath>, "c++11")
SYMBOL(llrintf, None, <cmath>)
SYMBOL(llrintf, None, <math.h>)
-SYMBOL(llrintl, std::, <cmath>)
+SYMBOL_VERSION(llrintl, std::, <cmath>, "c++11")
SYMBOL(llrintl, None, <cmath>)
SYMBOL(llrintl, None, <math.h>)
-SYMBOL(llround, std::, <cmath>)
+SYMBOL_VERSION(llround, std::, <cmath>, "c++11")
SYMBOL(llround, None, <cmath>)
SYMBOL(llround, None, <math.h>)
-SYMBOL(llroundf, std::, <cmath>)
+SYMBOL_VERSION(llroundf, std::, <cmath>, "c++11")
SYMBOL(llroundf, None, <cmath>)
SYMBOL(llroundf, None, <math.h>)
-SYMBOL(llroundl, std::, <cmath>)
+SYMBOL_VERSION(llroundl, std::, <cmath>, "c++11")
SYMBOL(llroundl, None, <cmath>)
SYMBOL(llroundl, None, <math.h>)
SYMBOL(locale, std::, <locale>)
@@ -2035,112 +1954,97 @@ SYMBOL(localeconv, None, <locale.h>)
SYMBOL(localtime, std::, <ctime>)
SYMBOL(localtime, None, <ctime>)
SYMBOL(localtime, None, <time.h>)
-SYMBOL(lock, std::, <mutex>)
-SYMBOL(lock_guard, std::, <mutex>)
-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(log10f, std::, <cmath>)
+SYMBOL_VERSION(lock, std::, <mutex>, "c++11")
+SYMBOL_VERSION(lock_guard, std::, <mutex>, "c++11")
+SYMBOL_VERSION(log10f, std::, <cmath>, "c++11")
SYMBOL(log10f, None, <cmath>)
SYMBOL(log10f, None, <math.h>)
-SYMBOL(log10l, std::, <cmath>)
+SYMBOL_VERSION(log10l, std::, <cmath>, "c++11")
SYMBOL(log10l, None, <cmath>)
SYMBOL(log10l, None, <math.h>)
-SYMBOL(log1p, std::, <cmath>)
-SYMBOL(log1p, None, <cmath>)
-SYMBOL(log1p, None, <math.h>)
-SYMBOL(log1pf, std::, <cmath>)
+SYMBOL_VERSION(log1pf, std::, <cmath>, "c++11")
SYMBOL(log1pf, None, <cmath>)
SYMBOL(log1pf, None, <math.h>)
-SYMBOL(log1pl, std::, <cmath>)
+SYMBOL_VERSION(log1pl, std::, <cmath>, "c++11")
SYMBOL(log1pl, None, <cmath>)
SYMBOL(log1pl, None, <math.h>)
-SYMBOL(log2, std::, <cmath>)
-SYMBOL(log2, None, <cmath>)
-SYMBOL(log2, None, <math.h>)
-SYMBOL(log2f, std::, <cmath>)
+SYMBOL_VERSION(log2f, std::, <cmath>, "c++11")
SYMBOL(log2f, None, <cmath>)
SYMBOL(log2f, None, <math.h>)
-SYMBOL(log2l, std::, <cmath>)
+SYMBOL_VERSION(log2l, std::, <cmath>, "c++11")
SYMBOL(log2l, None, <cmath>)
SYMBOL(log2l, None, <math.h>)
-SYMBOL(logb, std::, <cmath>)
-SYMBOL(logb, None, <cmath>)
-SYMBOL(logb, None, <math.h>)
-SYMBOL(logbf, std::, <cmath>)
+SYMBOL_VERSION(logbf, std::, <cmath>, "c++11")
SYMBOL(logbf, None, <cmath>)
SYMBOL(logbf, None, <math.h>)
-SYMBOL(logbl, std::, <cmath>)
+SYMBOL_VERSION(logbl, std::, <cmath>, "c++11")
SYMBOL(logbl, None, <cmath>)
SYMBOL(logbl, None, <math.h>)
-SYMBOL(logf, std::, <cmath>)
+SYMBOL_VERSION(logf, std::, <cmath>, "c++11")
SYMBOL(logf, None, <cmath>)
SYMBOL(logf, None, <math.h>)
SYMBOL(logic_error, std::, <stdexcept>)
SYMBOL(logical_and, std::, <functional>)
SYMBOL(logical_not, std::, <functional>)
SYMBOL(logical_or, std::, <functional>)
-SYMBOL(logl, std::, <cmath>)
+SYMBOL_VERSION(logl, std::, <cmath>, "c++11")
SYMBOL(logl, None, <cmath>)
SYMBOL(logl, None, <math.h>)
-SYMBOL(lognormal_distribution, std::, <random>)
+SYMBOL_VERSION(lognormal_distribution, std::, <random>, "c++11")
SYMBOL(longjmp, std::, <csetjmp>)
SYMBOL(longjmp, None, <csetjmp>)
SYMBOL(longjmp, None, <setjmp.h>)
SYMBOL(lower_bound, std::, <algorithm>)
-SYMBOL(lrint, std::, <cmath>)
+SYMBOL_VERSION(lrint, std::, <cmath>, "c++11")
SYMBOL(lrint, None, <cmath>)
SYMBOL(lrint, None, <math.h>)
-SYMBOL(lrintf, std::, <cmath>)
+SYMBOL_VERSION(lrintf, std::, <cmath>, "c++11")
SYMBOL(lrintf, None, <cmath>)
SYMBOL(lrintf, None, <math.h>)
-SYMBOL(lrintl, std::, <cmath>)
+SYMBOL_VERSION(lrintl, std::, <cmath>, "c++11")
SYMBOL(lrintl, None, <cmath>)
SYMBOL(lrintl, None, <math.h>)
-SYMBOL(lround, std::, <cmath>)
+SYMBOL_VERSION(lround, std::, <cmath>, "c++11")
SYMBOL(lround, None, <cmath>)
SYMBOL(lround, None, <math.h>)
-SYMBOL(lroundf, std::, <cmath>)
+SYMBOL_VERSION(lroundf, std::, <cmath>, "c++11")
SYMBOL(lroundf, None, <cmath>)
SYMBOL(lroundf, None, <math.h>)
-SYMBOL(lroundl, std::, <cmath>)
+SYMBOL_VERSION(lroundl, std::, <cmath>, "c++11")
SYMBOL(lroundl, None, <cmath>)
SYMBOL(lroundl, None, <math.h>)
-SYMBOL(make_any, std::, <any>)
-SYMBOL(make_const_iterator, std::, <iterator>)
-SYMBOL(make_const_sentinel, std::, <iterator>)
-SYMBOL(make_exception_ptr, std::, <exception>)
-SYMBOL(make_format_args, std::, <format>)
-SYMBOL(make_from_tuple, std::, <tuple>)
+SYMBOL_VERSION(make_any, std::, <any>, "c++17")
+SYMBOL_VERSION(make_const_iterator, std::, <iterator>, "c++23")
+SYMBOL_VERSION(make_const_sentinel, std::, <iterator>, "c++23")
+SYMBOL_VERSION(make_exception_ptr, std::, <exception>, "c++11")
+SYMBOL_VERSION(make_format_args, std::, <format>, "c++20")
+SYMBOL_VERSION(make_from_tuple, std::, <tuple>, "c++17")
SYMBOL(make_heap, std::, <algorithm>)
-SYMBOL(make_index_sequence, std::, <utility>)
-SYMBOL(make_integer_sequence, std::, <utility>)
-SYMBOL(make_move_iterator, std::, <iterator>)
-SYMBOL(make_obj_using_allocator, std::, <memory>)
-SYMBOL(make_optional, std::, <optional>)
+SYMBOL_VERSION(make_index_sequence, std::, <utility>, "c++14")
+SYMBOL_VERSION(make_integer_sequence, std::, <utility>, "c++14")
+SYMBOL_VERSION(make_move_iterator, std::, <iterator>, "c++11")
+SYMBOL_VERSION(make_obj_using_allocator, std::, <memory>, "c++20")
+SYMBOL_VERSION(make_optional, std::, <optional>, "c++17")
SYMBOL(make_pair, std::, <utility>)
-SYMBOL(make_reverse_iterator, std::, <iterator>)
-SYMBOL(make_shared, std::, <memory>)
-SYMBOL(make_shared_for_overwrite, std::, <memory>)
-SYMBOL(make_signed, std::, <type_traits>)
-SYMBOL(make_signed_t, std::, <type_traits>)
-SYMBOL(make_tuple, std::, <tuple>)
-SYMBOL(make_unique, std::, <memory>)
-SYMBOL(make_unique_for_overwrite, std::, <memory>)
-SYMBOL(make_unsigned, std::, <type_traits>)
-SYMBOL(make_unsigned_t, std::, <type_traits>)
-SYMBOL(make_wformat_args, std::, <format>)
+SYMBOL_VERSION(make_reverse_iterator, std::, <iterator>, "c++14")
+SYMBOL_VERSION(make_shared, std::, <memory>, "c++11")
+SYMBOL_VERSION(make_shared_for_overwrite, std::, <memory>, "c++20")
+SYMBOL_VERSION(make_signed, std::, <type_traits>, "c++11")
+SYMBOL_VERSION(make_signed_t, std::, <type_traits>, "c++14")
+SYMBOL_VERSION(make_tuple, std::, <tuple>, "c++11")
+SYMBOL_VERSION(make_unique, std::, <memory>, "c++14")
+SYMBOL_VERSION(make_unique_for_overwrite, std::, <memory>, "c++20")
+SYMBOL_VERSION(make_unsigned, std::, <type_traits>, "c++11")
+SYMBOL_VERSION(make_unsigned_t, std::, <type_traits>, "c++14")
+SYMBOL_VERSION(make_wformat_args, std::, <format>, "c++20")
SYMBOL(malloc, std::, <cstdlib>)
SYMBOL(malloc, None, <cstdlib>)
SYMBOL(malloc, None, <stdlib.h>)
SYMBOL(map, std::, <map>)
SYMBOL(mask_array, std::, <valarray>)
-SYMBOL(match_results, std::, <regex>)
+SYMBOL_VERSION(match_results, std::, <regex>, "c++11")
SYMBOL(max, std::, <algorithm>)
-SYMBOL(max_align_t, std::, <cstddef>)
+SYMBOL_VERSION(max_align_t, std::, <cstddef>, "c++11")
SYMBOL(max_align_t, None, <cstddef>)
SYMBOL(max_align_t, None, <stddef.h>)
SYMBOL(max_element, std::, <algorithm>)
@@ -2150,13 +2054,13 @@ SYMBOL(mblen, None, <stdlib.h>)
SYMBOL(mbrlen, std::, <cwchar>)
SYMBOL(mbrlen, None, <cwchar>)
SYMBOL(mbrlen, None, <wchar.h>)
-SYMBOL(mbrtoc16, std::, <cuchar>)
+SYMBOL_VERSION(mbrtoc16, std::, <cuchar>, "c++11")
SYMBOL(mbrtoc16, None, <cuchar>)
SYMBOL(mbrtoc16, None, <uchar.h>)
-SYMBOL(mbrtoc32, std::, <cuchar>)
+SYMBOL_VERSION(mbrtoc32, std::, <cuchar>, "c++11")
SYMBOL(mbrtoc32, None, <cuchar>)
SYMBOL(mbrtoc32, None, <uchar.h>)
-SYMBOL(mbrtoc8, std::, <cuchar>)
+SYMBOL_VERSION(mbrtoc8, std::, <cuchar>, "c++20")
SYMBOL(mbrtoc8, None, <cuchar>)
SYMBOL(mbrtoc8, None, <uchar.h>)
SYMBOL(mbrtowc, std::, <cwchar>)
@@ -2174,9 +2078,9 @@ SYMBOL(mbstowcs, None, <stdlib.h>)
SYMBOL(mbtowc, std::, <cstdlib>)
SYMBOL(mbtowc, None, <cstdlib>)
SYMBOL(mbtowc, None, <stdlib.h>)
-SYMBOL(mdspan, std::, <mdspan>)
-SYMBOL(mega, std::, <ratio>)
-SYMBOL(mem_fn, std::, <functional>)
+SYMBOL_VERSION(mdspan, std::, <mdspan>, "c++23")
+SYMBOL_VERSION(mega, std::, <ratio>, "c++11")
+SYMBOL_VERSION(mem_fn, std::, <functional>, "c++11")
SYMBOL(mem_fun, std::, <functional>)
SYMBOL(mem_fun1_ref_t, std::, <functional>)
SYMBOL(mem_fun1_t, std::, <functional>)
@@ -2195,31 +2099,31 @@ SYMBOL(memcpy, None, <string.h>)
SYMBOL(memmove, std::, <cstring>)
SYMBOL(memmove, None, <cstring>)
SYMBOL(memmove, None, <string.h>)
-SYMBOL(memory_order, std::, <atomic>)
-SYMBOL(memory_order_acq_rel, std::, <atomic>)
-SYMBOL(memory_order_acquire, std::, <atomic>)
-SYMBOL(memory_order_consume, std::, <atomic>)
-SYMBOL(memory_order_relaxed, std::, <atomic>)
-SYMBOL(memory_order_release, std::, <atomic>)
-SYMBOL(memory_order_seq_cst, std::, <atomic>)
+SYMBOL_VERSION(memory_order, std::, <atomic>, "c++11")
+SYMBOL_VERSION(memory_order_acq_rel, std::, <atomic>, "c++11")
+SYMBOL_VERSION(memory_order_acquire, std::, <atomic>, "c++11")
+SYMBOL_VERSION(memory_order_consume, std::, <atomic>, "c++11")
+SYMBOL_VERSION(memory_order_relaxed, std::, <atomic>, "c++11")
+SYMBOL_VERSION(memory_order_release, std::, <atomic>, "c++11")
+SYMBOL_VERSION(memory_order_seq_cst, std::, <atomic>, "c++11")
SYMBOL(memset, std::, <cstring>)
SYMBOL(memset, None, <cstring>)
SYMBOL(memset, None, <string.h>)
SYMBOL(merge, std::, <algorithm>)
-SYMBOL(mergeable, std::, <iterator>)
-SYMBOL(mersenne_twister_engine, std::, <random>)
+SYMBOL_VERSION(mergeable, std::, <iterator>, "c++20")
+SYMBOL_VERSION(mersenne_twister_engine, std::, <random>, "c++11")
SYMBOL(messages, std::, <locale>)
SYMBOL(messages_base, std::, <locale>)
SYMBOL(messages_byname, std::, <locale>)
-SYMBOL(micro, std::, <ratio>)
-SYMBOL(midpoint, std::, <numeric>)
-SYMBOL(milli, std::, <ratio>)
+SYMBOL_VERSION(micro, std::, <ratio>, "c++11")
+SYMBOL_VERSION(midpoint, std::, <numeric>, "c++20")
+SYMBOL_VERSION(milli, std::, <ratio>, "c++11")
SYMBOL(min, std::, <algorithm>)
SYMBOL(min_element, std::, <algorithm>)
-SYMBOL(minmax, std::, <algorithm>)
-SYMBOL(minmax_element, std::, <algorithm>)
-SYMBOL(minstd_rand, std::, <random>)
-SYMBOL(minstd_rand0, std::, <random>)
+SYMBOL_VERSION(minmax, std::, <algorithm>, "c++11")
+SYMBOL_VERSION(minmax_element, std::, <algorithm>, "c++11")
+SYMBOL_VERSION(minstd_rand, std::, <random>, "c++11")
+SYMBOL_VERSION(minstd_rand0, std::, <random>, "c++11")
SYMBOL(minus, std::, <functional>)
SYMBOL(mismatch, std::, <algorithm>)
SYMBOL(mktime, std::, <ctime>)
@@ -2228,10 +2132,10 @@ SYMBOL(mktime, None, <time.h>)
SYMBOL(modf, std::, <cmath>)
SYMBOL(modf, None, <cmath>)
SYMBOL(modf, None, <math.h>)
-SYMBOL(modff, std::, <cmath>)
+SYMBOL_VERSION(modff, std::, <cmath>, "c++11")
SYMBOL(modff, None, <cmath>)
SYMBOL(modff, None, <math.h>)
-SYMBOL(modfl, std::, <cmath>)
+SYMBOL_VERSION(modfl, std::, <cmath>, "c++11")
SYMBOL(modfl, None, <cmath>)
SYMBOL(modfl, None, <math.h>)
SYMBOL(modulus, std::, <functional>)
@@ -2240,78 +2144,74 @@ SYMBOL(money_get, std::, <locale>)
SYMBOL(money_put, std::, <locale>)
SYMBOL(moneypunct, std::, <locale>)
SYMBOL(moneypunct_byname, std::, <locale>)
-SYMBOL(monostate, std::, <variant>)
-SYMBOL(movable, std::, <concepts>)
-SYMBOL(move_backward, std::, <algorithm>)
-SYMBOL(move_constructible, std::, <concepts>)
-SYMBOL(move_if_noexcept, std::, <utility>)
-SYMBOL(move_iterator, std::, <iterator>)
-SYMBOL(move_only_function, std::, <functional>)
-SYMBOL(move_sentinel, std::, <iterator>)
-SYMBOL(mt19937, std::, <random>)
-SYMBOL(mt19937_64, std::, <random>)
-SYMBOL(mul_sat, std::, <numeric>)
+SYMBOL_VERSION(movable, std::, <concepts>, "c++20")
+SYMBOL_VERSION(move_backward, std::, <algorithm>, "c++11")
+SYMBOL_VERSION(move_constructible, std::, <concepts>, "c++20")
+SYMBOL_VERSION(move_if_noexcept, std::, <utility>, "c++11")
+SYMBOL_VERSION(move_iterator, std::, <iterator>, "c++11")
+SYMBOL_VERSION(move_only_function, std::, <functional>, "c++23")
+SYMBOL_VERSION(move_sentinel, std::, <iterator>, "c++20")
+SYMBOL_VERSION(mt19937, std::, <random>, "c++11")
+SYMBOL_VERSION(mt19937_64, std::, <random>, "c++11")
+SYMBOL_VERSION(mul_sat, std::, <numeric>, "c++26")
SYMBOL(multimap, std::, <map>)
SYMBOL(multiplies, std::, <functional>)
SYMBOL(multiset, std::, <set>)
-SYMBOL(mutex, std::, <mutex>)
-SYMBOL(nan, std::, <cmath>)
+SYMBOL_VERSION(mutex, std::, <mutex>, "c++11")
+SYMBOL_VERSION(nan, std::, <cmath>, "c++11")
SYMBOL(nan, None, <cmath>)
SYMBOL(nan, None, <math.h>)
-SYMBOL(nanf, std::, <cmath>)
+SYMBOL_VERSION(nanf, std::, <cmath>, "c++11")
SYMBOL(nanf, None, <cmath>)
SYMBOL(nanf, None, <math.h>)
-SYMBOL(nanl, std::, <cmath>)
+SYMBOL_VERSION(nanl, std::, <cmath>, "c++11")
SYMBOL(nanl, None, <cmath>)
SYMBOL(nanl, None, <math.h>)
-SYMBOL(nano, std::, <ratio>)
-SYMBOL(nearbyint, std::, <cmath>)
-SYMBOL(nearbyint, None, <cmath>)
-SYMBOL(nearbyint, None, <math.h>)
-SYMBOL(nearbyintf, std::, <cmath>)
+SYMBOL_VERSION(nano, std::, <ratio>, "c++11")
+SYMBOL_VERSION(nearbyintf, std::, <cmath>, "c++11")
SYMBOL(nearbyintf, None, <cmath>)
SYMBOL(nearbyintf, None, <math.h>)
-SYMBOL(nearbyintl, std::, <cmath>)
+SYMBOL_VERSION(nearbyintl, std::, <cmath>, "c++11")
SYMBOL(nearbyintl, None, <cmath>)
SYMBOL(nearbyintl, None, <math.h>)
SYMBOL(negate, std::, <functional>)
-SYMBOL(negation, std::, <type_traits>)
-SYMBOL(negation_v, std::, <type_traits>)
-SYMBOL(negative_binomial_distribution, std::, <random>)
-SYMBOL(nested_exception, std::, <exception>)
+SYMBOL_VERSION(negation, std::, <type_traits>, "c++17")
+SYMBOL_VERSION(negation_v, std::, <type_traits>, "c++17")
+SYMBOL_VERSION(negative_binomial_distribution, std::, <random>, "c++11")
+SYMBOL_VERSION(nested_exception, std::, <exception>, "c++11")
SYMBOL(new_handler, std::, <new>)
-SYMBOL(next, std::, <iterator>)
+SYMBOL_VERSION(next, std::, <iterator>, "c++11")
SYMBOL(next_permutation, std::, <algorithm>)
-SYMBOL(nextafter, std::, <cmath>)
+SYMBOL_VERSION(nextafter, std::, <cmath>, "c++11")
SYMBOL(nextafter, None, <cmath>)
SYMBOL(nextafter, None, <math.h>)
-SYMBOL(nextafterf, std::, <cmath>)
+SYMBOL_VERSION(nextafterf, std::, <cmath>, "c++11")
SYMBOL(nextafterf, None, <cmath>)
SYMBOL(nextafterf, None, <math.h>)
-SYMBOL(nextafterl, std::, <cmath>)
+SYMBOL_VERSION(nextafterl, std::, <cmath>, "c++11")
SYMBOL(nextafterl, None, <cmath>)
SYMBOL(nextafterl, None, <math.h>)
-SYMBOL(nexttoward, std::, <cmath>)
+SYMBOL_VERSION(nexttoward, std::, <cmath>, "c++11")
SYMBOL(nexttoward, None, <cmath>)
SYMBOL(nexttoward, None, <math.h>)
-SYMBOL(nexttowardf, std::, <cmath>)
+SYMBOL_VERSION(nexttowardf, std::, <cmath>, "c++11")
SYMBOL(nexttowardf, None, <cmath>)
SYMBOL(nexttowardf, None, <math.h>)
-SYMBOL(nexttowardl, std::, <cmath>)
+SYMBOL_VERSION(nexttowardl, std::, <cmath>, "c++11")
SYMBOL(nexttowardl, None, <cmath>)
SYMBOL(nexttowardl, None, <math.h>)
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(nontype, std::, <utility>)
-SYMBOL(nontype_t, std::, <utility>)
-SYMBOL(noop_coroutine, std::, <coroutine>)
-SYMBOL(noop_coroutine_handle, std::, <coroutine>)
-SYMBOL(noop_coroutine_promise, std::, <coroutine>)
+SYMBOL_VERSION(noemit_on_flush, std::, <ostream>, "c++20")
+SYMBOL_VERSION(noemit_on_flush, std::, <iostream>, "c++20")
+SYMBOL_VERSION(none_of, std::, <algorithm>, "c++11")
+SYMBOL_VERSION(nontype, std::, <utility>, "c++26")
+SYMBOL_VERSION(nontype_t, std::, <utility>, "c++26")
+SYMBOL_VERSION(noop_coroutine, std::, <coroutine>, "c++20")
+SYMBOL_VERSION(noop_coroutine_handle, std::, <coroutine>, "c++20")
+SYMBOL_VERSION(noop_coroutine_promise, std::, <coroutine>, "c++20")
SYMBOL(norm, std::, <complex>)
-SYMBOL(normal_distribution, std::, <random>)
+SYMBOL_VERSION(normal_distribution, std::, <random>, "c++11")
SYMBOL(noshowbase, std::, <ios>)
SYMBOL(noshowbase, std::, <iostream>)
SYMBOL(noshowpoint, std::, <ios>)
@@ -2320,23 +2220,23 @@ 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_VERSION(nostopstate, std::, <stop_token>, "c++20")
+SYMBOL_VERSION(nostopstate_t, std::, <stop_token>, "c++20")
SYMBOL(not1, std::, <functional>)
SYMBOL(not2, std::, <functional>)
SYMBOL(not_equal_to, std::, <functional>)
-SYMBOL(not_fn, std::, <functional>)
+SYMBOL_VERSION(not_fn, std::, <functional>, "c++17")
SYMBOL(nothrow, std::, <new>)
SYMBOL(nothrow_t, std::, <new>)
-SYMBOL(notify_all_at_thread_exit, std::, <condition_variable>)
+SYMBOL_VERSION(notify_all_at_thread_exit, std::, <condition_variable>, "c++11")
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_VERSION(nullopt, std::, <optional>, "c++17")
+SYMBOL_VERSION(nullopt_t, std::, <optional>, "c++17")
+SYMBOL_VERSION(nullptr_t, std::, <cstddef>, "c++11")
SYMBOL(nullptr_t, None, <cstddef>)
SYMBOL(nullptr_t, None, <stddef.h>)
SYMBOL(num_get, std::, <locale>)
@@ -2348,13 +2248,13 @@ SYMBOL(oct, std::, <ios>)
SYMBOL(oct, std::, <iostream>)
SYMBOL(ofstream, std::, <fstream>)
SYMBOL(ofstream, std::, <iosfwd>)
-SYMBOL(once_flag, std::, <mutex>)
+SYMBOL_VERSION(once_flag, std::, <mutex>, "c++11")
SYMBOL(op, std::, <functional>)
SYMBOL(open_mode, std::, <ios>)
SYMBOL(open_mode, std::, <iostream>)
-SYMBOL(optional, std::, <optional>)
-SYMBOL(ospanstream, std::, <spanstream>)
-SYMBOL(ospanstream, std::, <iosfwd>)
+SYMBOL_VERSION(optional, std::, <optional>, "c++17")
+SYMBOL_VERSION(ospanstream, std::, <spanstream>, "c++23")
+SYMBOL_VERSION(ospanstream, std::, <iosfwd>, "c++23")
SYMBOL(ostream, std::, <ostream>)
SYMBOL(ostream, std::, <iostream>)
SYMBOL(ostream, std::, <iosfwd>)
@@ -2364,72 +2264,71 @@ SYMBOL(ostreambuf_iterator, std::, <iosfwd>)
SYMBOL(ostringstream, std::, <sstream>)
SYMBOL(ostringstream, std::, <iosfwd>)
SYMBOL(ostrstream, std::, <strstream>)
-SYMBOL(ostrstream, std::, <strstream>)
-SYMBOL(osyncstream, std::, <syncstream>)
-SYMBOL(osyncstream, std::, <iosfwd>)
+SYMBOL_VERSION(osyncstream, std::, <syncstream>, "c++20")
+SYMBOL_VERSION(osyncstream, std::, <iosfwd>, "c++20")
SYMBOL(out_of_range, std::, <stdexcept>)
-SYMBOL(out_ptr, std::, <memory>)
-SYMBOL(out_ptr_t, std::, <memory>)
-SYMBOL(output_iterator, std::, <iterator>)
+SYMBOL_VERSION(out_ptr, std::, <memory>, "c++23")
+SYMBOL_VERSION(out_ptr_t, std::, <memory>, "c++23")
+SYMBOL_VERSION(output_iterator, std::, <iterator>, "c++20")
SYMBOL(output_iterator_tag, std::, <iterator>)
SYMBOL(overflow_error, std::, <stdexcept>)
-SYMBOL(owner_less, std::, <memory>)
-SYMBOL(packaged_task, std::, <future>)
+SYMBOL_VERSION(owner_less, std::, <memory>, "c++11")
+SYMBOL_VERSION(packaged_task, std::, <future>, "c++11")
SYMBOL(pair, std::, <utility>)
-SYMBOL(partial_order, std::, <compare>)
-SYMBOL(partial_ordering, std::, <compare>)
+SYMBOL_VERSION(partial_order, std::, <compare>, "c++20")
+SYMBOL_VERSION(partial_ordering, std::, <compare>, "c++20")
SYMBOL(partial_sort, std::, <algorithm>)
SYMBOL(partial_sort_copy, std::, <algorithm>)
SYMBOL(partial_sum, std::, <numeric>)
SYMBOL(partition, std::, <algorithm>)
-SYMBOL(partition_copy, std::, <algorithm>)
-SYMBOL(partition_point, std::, <algorithm>)
-SYMBOL(permutable, std::, <iterator>)
+SYMBOL_VERSION(partition_copy, std::, <algorithm>, "c++11")
+SYMBOL_VERSION(partition_point, std::, <algorithm>, "c++11")
+SYMBOL_VERSION(permutable, std::, <iterator>, "c++20")
SYMBOL(perror, std::, <cstdio>)
SYMBOL(perror, None, <cstdio>)
SYMBOL(perror, None, <stdio.h>)
-SYMBOL(peta, std::, <ratio>)
-SYMBOL(pico, std::, <ratio>)
-SYMBOL(piecewise_constant_distribution, std::, <random>)
-SYMBOL(piecewise_construct, std::, <utility>)
-SYMBOL(piecewise_construct_t, std::, <utility>)
-SYMBOL(piecewise_linear_distribution, std::, <random>)
+SYMBOL_VERSION(peta, std::, <ratio>, "c++11")
+SYMBOL_VERSION(pico, std::, <ratio>, "c++11")
+SYMBOL_VERSION(piecewise_constant_distribution, std::, <random>, "c++11")
+SYMBOL_VERSION(piecewise_construct, std::, <utility>, "c++11")
+SYMBOL_VERSION(piecewise_construct_t, std::, <utility>, "c++11")
+SYMBOL_VERSION(piecewise_linear_distribution, std::, <random>, "c++11")
SYMBOL(plus, std::, <functional>)
-SYMBOL(pointer_safety, std::, <memory>)
-SYMBOL(pointer_traits, std::, <memory>)
-SYMBOL(poisson_distribution, std::, <random>)
+SYMBOL_VERSION(pointer_safety, std::, <memory>, "c++11")
+SYMBOL_VERSION(pointer_traits, std::, <memory>, "c++11")
+SYMBOL_VERSION(poisson_distribution, std::, <random>, "c++11")
SYMBOL(polar, std::, <complex>)
SYMBOL(pop_heap, std::, <algorithm>)
-SYMBOL(popcount, std::, <bit>)
+SYMBOL_VERSION(popcount, std::, <bit>, "c++20")
SYMBOL(pow, std::, <cmath>)
SYMBOL(pow, None, <cmath>)
SYMBOL(pow, None, <math.h>)
-SYMBOL(powf, std::, <cmath>)
+SYMBOL_VERSION(powf, std::, <cmath>, "c++11")
SYMBOL(powf, None, <cmath>)
SYMBOL(powf, None, <math.h>)
-SYMBOL(powl, std::, <cmath>)
+SYMBOL_VERSION(powl, std::, <cmath>, "c++11")
SYMBOL(powl, None, <cmath>)
SYMBOL(powl, None, <math.h>)
-SYMBOL(predicate, std::, <concepts>)
-SYMBOL(preferred, std::, <memory>)
-SYMBOL(prev, std::, <iterator>)
+SYMBOL_VERSION(predicate, std::, <concepts>, "c++20")
+SYMBOL_VERSION(preferred, std::, <memory>, "c++11")
+SYMBOL_VERSION(prev, std::, <iterator>, "c++11")
SYMBOL(prev_permutation, std::, <algorithm>)
-SYMBOL(print, std::, <print>)
+SYMBOL_VERSION(print, std::, <print>, "c++23")
SYMBOL(printf, std::, <cstdio>)
SYMBOL(printf, None, <cstdio>)
SYMBOL(printf, None, <stdio.h>)
-SYMBOL(println, std::, <print>)
+SYMBOL_VERSION(println, std::, <print>, "c++23")
SYMBOL(priority_queue, std::, <queue>)
-SYMBOL(proj, std::, <complex>)
-SYMBOL(projected, std::, <iterator>)
-SYMBOL(promise, std::, <future>)
+SYMBOL_VERSION(proj, std::, <complex>, "c++11")
+SYMBOL_VERSION(projected, std::, <iterator>, "c++20")
+SYMBOL_VERSION(promise, std::, <future>, "c++11")
SYMBOL(ptr_fun, std::, <functional>)
SYMBOL(ptrdiff_t, std::, <cstddef>)
SYMBOL(ptrdiff_t, None, <cstddef>)
SYMBOL(ptrdiff_t, None, <stddef.h>)
SYMBOL(push_heap, std::, <algorithm>)
-SYMBOL(put_money, std::, <iomanip>)
-SYMBOL(put_time, std::, <iomanip>)
+SYMBOL_VERSION(put_money, std::, <iomanip>, "c++11")
+SYMBOL_VERSION(put_time, std::, <iomanip>, "c++11")
SYMBOL(putc, std::, <cstdio>)
SYMBOL(putc, None, <cstdio>)
SYMBOL(putc, None, <stdio.h>)
@@ -2448,109 +2347,106 @@ SYMBOL(putwchar, None, <wchar.h>)
SYMBOL(qsort, std::, <cstdlib>)
SYMBOL(qsort, None, <cstdlib>)
SYMBOL(qsort, None, <stdlib.h>)
-SYMBOL(quecto, std::, <ratio>)
-SYMBOL(quetta, std::, <ratio>)
+SYMBOL_VERSION(quecto, std::, <ratio>, "c++26")
+SYMBOL_VERSION(quetta, std::, <ratio>, "c++26")
SYMBOL(queue, std::, <queue>)
-SYMBOL(quick_exit, std::, <cstdlib>)
+SYMBOL_VERSION(quick_exit, std::, <cstdlib>, "c++11")
SYMBOL(quick_exit, None, <cstdlib>)
SYMBOL(quick_exit, None, <stdlib.h>)
-SYMBOL(quoted, std::, <iomanip>)
+SYMBOL_VERSION(quoted, std::, <iomanip>, "c++14")
SYMBOL(raise, std::, <csignal>)
SYMBOL(raise, None, <csignal>)
SYMBOL(raise, None, <signal.h>)
SYMBOL(rand, std::, <cstdlib>)
SYMBOL(rand, None, <cstdlib>)
SYMBOL(rand, None, <stdlib.h>)
-SYMBOL(random_access_iterator, std::, <iterator>)
+SYMBOL_VERSION(random_access_iterator, std::, <iterator>, "c++20")
SYMBOL(random_access_iterator_tag, std::, <iterator>)
-SYMBOL(random_device, std::, <random>)
+SYMBOL_VERSION(random_device, std::, <random>, "c++11")
SYMBOL(random_shuffle, std::, <algorithm>)
SYMBOL(range_error, std::, <stdexcept>)
-SYMBOL(range_format, std::, <format>)
-SYMBOL(range_formatter, std::, <format>)
-SYMBOL(rank, std::, <type_traits>)
-SYMBOL(rank_v, std::, <type_traits>)
-SYMBOL(ranlux24, std::, <random>)
-SYMBOL(ranlux24_base, std::, <random>)
-SYMBOL(ranlux48, std::, <random>)
-SYMBOL(ranlux48_base, std::, <random>)
-SYMBOL(ratio, std::, <ratio>)
-SYMBOL(ratio_add, std::, <ratio>)
-SYMBOL(ratio_divide, std::, <ratio>)
-SYMBOL(ratio_equal, std::, <ratio>)
-SYMBOL(ratio_equal_v, std::, <ratio>)
-SYMBOL(ratio_greater, std::, <ratio>)
-SYMBOL(ratio_greater_equal, std::, <ratio>)
-SYMBOL(ratio_greater_equal_v, std::, <ratio>)
-SYMBOL(ratio_greater_v, std::, <ratio>)
-SYMBOL(ratio_less, std::, <ratio>)
-SYMBOL(ratio_less_equal, std::, <ratio>)
-SYMBOL(ratio_less_equal_v, std::, <ratio>)
-SYMBOL(ratio_less_v, std::, <ratio>)
-SYMBOL(ratio_multiply, std::, <ratio>)
-SYMBOL(ratio_not_equal, std::, <ratio>)
-SYMBOL(ratio_not_equal_v, std::, <ratio>)
-SYMBOL(ratio_subtract, std::, <ratio>)
+SYMBOL_VERSION(range_format, std::, <format>, "c++23")
+SYMBOL_VERSION(range_formatter, std::, <format>, "c++23")
+SYMBOL_VERSION(rank, std::, <type_traits>, "c++11")
+SYMBOL_VERSION(rank_v, std::, <type_traits>, "c++17")
+SYMBOL_VERSION(ranlux24, std::, <random>, "c++11")
+SYMBOL_VERSION(ranlux24_base, std::, <random>, "c++11")
+SYMBOL_VERSION(ranlux48, std::, <random>, "c++11")
+SYMBOL_VERSION(ranlux48_base, std::, <random>, "c++11")
+SYMBOL_VERSION(ratio, std::, <ratio>, "c++11")
+SYMBOL_VERSION(ratio_add, std::, <ratio>, "c++11")
+SYMBOL_VERSION(ratio_divide, std::, <ratio>, "c++11")
+SYMBOL_VERSION(ratio_equal, std::, <ratio>, "c++11")
+SYMBOL_VERSION(ratio_equal_v, std::, <ratio>, "c++17")
+SYMBOL_VERSION(ratio_greater, std::, <ratio>, "c++11")
+SYMBOL_VERSION(ratio_greater_equal, std::, <ratio>, "c++11")
+SYMBOL_VERSION(ratio_greater_equal_v, std::, <ratio>, "c++17")
+SYMBOL_VERSION(ratio_greater_v, std::, <ratio>, "c++17")
+SYMBOL_VERSION(ratio_less, std::, <ratio>, "c++11")
+SYMBOL_VERSION(ratio_less_equal, std::, <ratio>, "c++11")
+SYMBOL_VERSION(ratio_less_equal_v, std::, <ratio>, "c++17")
+SYMBOL_VERSION(ratio_less_v, std::, <ratio>, "c++17")
+SYMBOL_VERSION(ratio_multiply, std::, <ratio>, "c++11")
+SYMBOL_VERSION(ratio_not_equal, std::, <ratio>, "c++11")
+SYMBOL_VERSION(ratio_not_equal_v, std::, <ratio>, "c++17")
+SYMBOL_VERSION(ratio_subtract, std::, <ratio>, "c++11")
SYMBOL(raw_storage_iterator, std::, <memory>)
SYMBOL(real, std::, <complex>)
SYMBOL(realloc, std::, <cstdlib>)
SYMBOL(realloc, None, <cstdlib>)
SYMBOL(realloc, None, <stdlib.h>)
-SYMBOL(recursive_mutex, std::, <mutex>)
-SYMBOL(recursive_timed_mutex, std::, <mutex>)
-SYMBOL(reduce, std::, <numeric>)
-SYMBOL(ref, std::, <functional>)
-SYMBOL(reference_constructs_from_temporary, std::, <type_traits>)
-SYMBOL(reference_converts_from_temporary, std::, <type_traits>)
-SYMBOL(reference_wrapper, std::, <functional>)
-SYMBOL(regex, std::, <regex>)
-SYMBOL(regex_error, std::, <regex>)
-SYMBOL(regex_iterator, std::, <regex>)
-SYMBOL(regex_match, std::, <regex>)
-SYMBOL(regex_replace, std::, <regex>)
-SYMBOL(regex_search, std::, <regex>)
-SYMBOL(regex_token_iterator, std::, <regex>)
-SYMBOL(regex_traits, std::, <regex>)
-SYMBOL(regular, std::, <concepts>)
-SYMBOL(regular_invocable, std::, <concepts>)
-SYMBOL(reinterpret_pointer_cast, std::, <memory>)
-SYMBOL(relation, std::, <concepts>)
-SYMBOL(relaxed, std::, <memory>)
-SYMBOL(remainder, std::, <cmath>)
-SYMBOL(remainder, None, <cmath>)
-SYMBOL(remainder, None, <math.h>)
-SYMBOL(remainderf, std::, <cmath>)
+SYMBOL_VERSION(recursive_mutex, std::, <mutex>, "c++11")
+SYMBOL_VERSION(recursive_timed_mutex, std::, <mutex>, "c++11")
+SYMBOL_VERSION(reduce, std::, <numeric>, "c++17")
+SYMBOL_VERSION(ref, std::, <functional>, "c++11")
+SYMBOL_VERSION(reference_constructs_from_temporary, std::, <type_traits>, "c++23")
+SYMBOL_VERSION(reference_converts_from_temporary, std::, <type_traits>, "c++23")
+SYMBOL_VERSION(reference_wrapper, std::, <functional>, "c++11")
+SYMBOL_VERSION(regex, std::, <regex>, "c++11")
+SYMBOL_VERSION(regex_error, std::, <regex>, "c++11")
+SYMBOL_VERSION(regex_iterator, std::, <regex>, "c++11")
+SYMBOL_VERSION(regex_match, std::, <regex>, "c++11")
+SYMBOL_VERSION(regex_replace, std::, <regex>, "c++11")
+SYMBOL_VERSION(regex_search, std::, <regex>, "c++11")
+SYMBOL_VERSION(regex_token_iterator, std::, <regex>, "c++11")
+SYMBOL_VERSION(regex_traits, std::, <regex>, "c++11")
+SYMBOL_VERSION(regular, std::, <concepts>, "c++20")
+SYMBOL_VERSION(regular_invocable, std::, <concepts>, "c++20")
+SYMBOL_VERSION(reinterpret_pointer_cast, std::, <memory>, "c++11")
+SYMBOL_VERSION(relation, std::, <concepts>, "c++20")
+SYMBOL_VERSION(relaxed, std::, <memory>, "c++11")
+SYMBOL_VERSION(remainderf, std::, <cmath>, "c++11")
SYMBOL(remainderf, None, <cmath>)
SYMBOL(remainderf, None, <math.h>)
-SYMBOL(remainderl, std::, <cmath>)
+SYMBOL_VERSION(remainderl, std::, <cmath>, "c++11")
SYMBOL(remainderl, None, <cmath>)
SYMBOL(remainderl, None, <math.h>)
-SYMBOL(remove_all_extents, std::, <type_traits>)
-SYMBOL(remove_all_extents_t, std::, <type_traits>)
-SYMBOL(remove_const, std::, <type_traits>)
-SYMBOL(remove_const_t, std::, <type_traits>)
+SYMBOL_VERSION(remove_all_extents, std::, <type_traits>, "c++11")
+SYMBOL_VERSION(remove_all_extents_t, std::, <type_traits>, "c++14")
+SYMBOL_VERSION(remove_const, std::, <type_traits>, "c++11")
+SYMBOL_VERSION(remove_const_t, std::, <type_traits>, "c++14")
SYMBOL(remove_copy, std::, <algorithm>)
SYMBOL(remove_copy_if, std::, <algorithm>)
-SYMBOL(remove_cv, std::, <type_traits>)
-SYMBOL(remove_cv_t, std::, <type_traits>)
-SYMBOL(remove_cvref, std::, <type_traits>)
-SYMBOL(remove_cvref_t, std::, <type_traits>)
-SYMBOL(remove_extent, std::, <type_traits>)
-SYMBOL(remove_extent_t, std::, <type_traits>)
+SYMBOL_VERSION(remove_cv, std::, <type_traits>, "c++11")
+SYMBOL_VERSION(remove_cv_t, std::, <type_traits>, "c++14")
+SYMBOL_VERSION(remove_cvref, std::, <type_traits>, "c++20")
+SYMBOL_VERSION(remove_cvref_t, std::, <type_traits>, "c++20")
+SYMBOL_VERSION(remove_extent, std::, <type_traits>, "c++11")
+SYMBOL_VERSION(remove_extent_t, std::, <type_traits>, "c++14")
SYMBOL(remove_if, std::, <algorithm>)
-SYMBOL(remove_pointer, std::, <type_traits>)
-SYMBOL(remove_pointer_t, std::, <type_traits>)
-SYMBOL(remove_reference, std::, <type_traits>)
-SYMBOL(remove_reference_t, std::, <type_traits>)
-SYMBOL(remove_volatile, std::, <type_traits>)
-SYMBOL(remove_volatile_t, std::, <type_traits>)
-SYMBOL(remquo, std::, <cmath>)
+SYMBOL_VERSION(remove_pointer, std::, <type_traits>, "c++11")
+SYMBOL_VERSION(remove_pointer_t, std::, <type_traits>, "c++14")
+SYMBOL_VERSION(remove_reference, std::, <type_traits>, "c++11")
+SYMBOL_VERSION(remove_reference_t, std::, <type_traits>, "c++14")
+SYMBOL_VERSION(remove_volatile, std::, <type_traits>, "c++11")
+SYMBOL_VERSION(remove_volatile_t, std::, <type_traits>, "c++14")
+SYMBOL_VERSION(remquo, std::, <cmath>, "c++11")
SYMBOL(remquo, None, <cmath>)
SYMBOL(remquo, None, <math.h>)
-SYMBOL(remquof, std::, <cmath>)
+SYMBOL_VERSION(remquof, std::, <cmath>, "c++11")
SYMBOL(remquof, None, <cmath>)
SYMBOL(remquof, None, <math.h>)
-SYMBOL(remquol, std::, <cmath>)
+SYMBOL_VERSION(remquol, std::, <cmath>, "c++11")
SYMBOL(remquol, None, <cmath>)
SYMBOL(remquol, None, <math.h>)
SYMBOL(rename, std::, <cstdio>)
@@ -2561,10 +2457,10 @@ SYMBOL(replace_copy, std::, <algorithm>)
SYMBOL(replace_copy_if, std::, <algorithm>)
SYMBOL(replace_if, std::, <algorithm>)
SYMBOL(resetiosflags, std::, <iomanip>)
-SYMBOL(result_of, std::, <type_traits>)
-SYMBOL(result_of_t, std::, <type_traits>)
-SYMBOL(rethrow_exception, std::, <exception>)
-SYMBOL(rethrow_if_nested, std::, <exception>)
+SYMBOL_VERSION(result_of, std::, <type_traits>, "c++11")
+SYMBOL_VERSION(result_of_t, std::, <type_traits>, "c++14")
+SYMBOL_VERSION(rethrow_exception, std::, <exception>, "c++11")
+SYMBOL_VERSION(rethrow_if_nested, std::, <exception>, "c++11")
SYMBOL(return_temporary_buffer, std::, <memory>)
SYMBOL(reverse, std::, <algorithm>)
SYMBOL(reverse_copy, std::, <algorithm>)
@@ -2572,27 +2468,27 @@ SYMBOL(reverse_iterator, std::, <iterator>)
SYMBOL(rewind, std::, <cstdio>)
SYMBOL(rewind, None, <cstdio>)
SYMBOL(rewind, None, <stdio.h>)
-SYMBOL(riemann_zeta, std::, <cmath>)
-SYMBOL(riemann_zetaf, std::, <cmath>)
-SYMBOL(riemann_zetal, std::, <cmath>)
+SYMBOL_VERSION(riemann_zeta, std::, <cmath>, "c++17")
+SYMBOL_VERSION(riemann_zetaf, std::, <cmath>, "c++17")
+SYMBOL_VERSION(riemann_zetal, std::, <cmath>, "c++17")
SYMBOL(right, std::, <ios>)
SYMBOL(right, std::, <iostream>)
-SYMBOL(rint, std::, <cmath>)
+SYMBOL_VERSION(rint, std::, <cmath>, "c++11")
SYMBOL(rint, None, <cmath>)
SYMBOL(rint, None, <math.h>)
-SYMBOL(rintf, std::, <cmath>)
+SYMBOL_VERSION(rintf, std::, <cmath>, "c++11")
SYMBOL(rintf, None, <cmath>)
SYMBOL(rintf, None, <math.h>)
-SYMBOL(rintl, std::, <cmath>)
+SYMBOL_VERSION(rintl, std::, <cmath>, "c++11")
SYMBOL(rintl, None, <cmath>)
SYMBOL(rintl, None, <math.h>)
-SYMBOL(ronna, std::, <ratio>)
-SYMBOL(ronto, std::, <ratio>)
+SYMBOL_VERSION(ronna, std::, <ratio>, "c++26")
+SYMBOL_VERSION(ronto, std::, <ratio>, "c++26")
SYMBOL(rotate, std::, <algorithm>)
SYMBOL(rotate_copy, std::, <algorithm>)
-SYMBOL(rotl, std::, <bit>)
-SYMBOL(rotr, std::, <bit>)
-SYMBOL(round, std::, <cmath>)
+SYMBOL_VERSION(rotl, std::, <bit>, "c++20")
+SYMBOL_VERSION(rotr, std::, <bit>, "c++20")
+SYMBOL_VERSION(round, std::, <cmath>, "c++11")
SYMBOL(round, None, <cmath>)
SYMBOL(round, None, <math.h>)
SYMBOL(round_indeterminate, std::, <limits>)
@@ -2600,33 +2496,33 @@ SYMBOL(round_to_nearest, std::, <limits>)
SYMBOL(round_toward_infinity, std::, <limits>)
SYMBOL(round_toward_neg_infinity, std::, <limits>)
SYMBOL(round_toward_zero, std::, <limits>)
-SYMBOL(roundf, std::, <cmath>)
+SYMBOL_VERSION(roundf, std::, <cmath>, "c++11")
SYMBOL(roundf, None, <cmath>)
SYMBOL(roundf, None, <math.h>)
-SYMBOL(roundl, std::, <cmath>)
+SYMBOL_VERSION(roundl, std::, <cmath>, "c++11")
SYMBOL(roundl, None, <cmath>)
SYMBOL(roundl, None, <math.h>)
SYMBOL(runtime_error, std::, <stdexcept>)
-SYMBOL(runtime_format, std::, <format>)
-SYMBOL(same_as, std::, <concepts>)
-SYMBOL(sample, std::, <algorithm>)
-SYMBOL(saturate_cast, std::, <numeric>)
-SYMBOL(scalbln, std::, <cmath>)
+SYMBOL_VERSION(runtime_format, std::, <format>, "c++26")
+SYMBOL_VERSION(same_as, std::, <concepts>, "c++20")
+SYMBOL_VERSION(sample, std::, <algorithm>, "c++17")
+SYMBOL_VERSION(saturate_cast, std::, <numeric>, "c++26")
+SYMBOL_VERSION(scalbln, std::, <cmath>, "c++11")
SYMBOL(scalbln, None, <cmath>)
SYMBOL(scalbln, None, <math.h>)
-SYMBOL(scalblnf, std::, <cmath>)
+SYMBOL_VERSION(scalblnf, std::, <cmath>, "c++11")
SYMBOL(scalblnf, None, <cmath>)
SYMBOL(scalblnf, None, <math.h>)
-SYMBOL(scalblnl, std::, <cmath>)
+SYMBOL_VERSION(scalblnl, std::, <cmath>, "c++11")
SYMBOL(scalblnl, None, <cmath>)
SYMBOL(scalblnl, None, <math.h>)
-SYMBOL(scalbn, std::, <cmath>)
+SYMBOL_VERSION(scalbn, std::, <cmath>, "c++11")
SYMBOL(scalbn, None, <cmath>)
SYMBOL(scalbn, None, <math.h>)
-SYMBOL(scalbnf, std::, <cmath>)
+SYMBOL_VERSION(scalbnf, std::, <cmath>, "c++11")
SYMBOL(scalbnf, None, <cmath>)
SYMBOL(scalbnf, None, <math.h>)
-SYMBOL(scalbnl, std::, <cmath>)
+SYMBOL_VERSION(scalbnl, std::, <cmath>, "c++11")
SYMBOL(scalbnl, None, <cmath>)
SYMBOL(scalbnl, None, <math.h>)
SYMBOL(scanf, std::, <cstdio>)
@@ -2634,15 +2530,15 @@ SYMBOL(scanf, None, <cstdio>)
SYMBOL(scanf, None, <stdio.h>)
SYMBOL(scientific, std::, <ios>)
SYMBOL(scientific, std::, <iostream>)
-SYMBOL(scoped_allocator_adaptor, std::, <scoped_allocator>)
-SYMBOL(scoped_lock, std::, <mutex>)
+SYMBOL_VERSION(scoped_allocator_adaptor, std::, <scoped_allocator>, "c++11")
+SYMBOL_VERSION(scoped_lock, std::, <mutex>, "c++17")
SYMBOL(search, std::, <algorithm>)
SYMBOL(search_n, std::, <algorithm>)
-SYMBOL(seed_seq, std::, <random>)
+SYMBOL_VERSION(seed_seq, std::, <random>, "c++11")
SYMBOL(seek_dir, std::, <ios>)
SYMBOL(seek_dir, std::, <iostream>)
-SYMBOL(semiregular, std::, <concepts>)
-SYMBOL(sentinel_for, std::, <iterator>)
+SYMBOL_VERSION(semiregular, std::, <concepts>, "c++20")
+SYMBOL_VERSION(sentinel_for, std::, <iterator>, "c++20")
SYMBOL(set, std::, <set>)
SYMBOL(set_difference, std::, <algorithm>)
SYMBOL(set_intersection, std::, <algorithm>)
@@ -2665,121 +2561,109 @@ SYMBOL(setvbuf, std::, <cstdio>)
SYMBOL(setvbuf, None, <cstdio>)
SYMBOL(setvbuf, None, <stdio.h>)
SYMBOL(setw, std::, <iomanip>)
-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_VERSION(shared_future, std::, <future>, "c++11")
+SYMBOL_VERSION(shared_lock, std::, <shared_mutex>, "c++14")
+SYMBOL_VERSION(shared_mutex, std::, <shared_mutex>, "c++17")
+SYMBOL_VERSION(shared_ptr, std::, <memory>, "c++11")
+SYMBOL_VERSION(shared_timed_mutex, std::, <shared_mutex>, "c++14")
+SYMBOL_VERSION(shift_left, std::, <algorithm>, "c++20")
+SYMBOL_VERSION(shift_right, std::, <algorithm>, "c++20")
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_VERSION(shuffle, std::, <algorithm>, "c++11")
+SYMBOL_VERSION(shuffle_order_engine, std::, <random>, "c++11")
SYMBOL(sig_atomic_t, std::, <csignal>)
SYMBOL(sig_atomic_t, None, <csignal>)
SYMBOL(sig_atomic_t, None, <signal.h>)
SYMBOL(signal, std::, <csignal>)
SYMBOL(signal, None, <csignal>)
SYMBOL(signal, None, <signal.h>)
-SYMBOL(signbit, std::, <cmath>)
-SYMBOL(signbit, None, <cmath>)
-SYMBOL(signbit, None, <math.h>)
-SYMBOL(signed_integral, std::, <concepts>)
-SYMBOL(sin, std::, <cmath>)
-SYMBOL(sin, None, <cmath>)
-SYMBOL(sin, None, <math.h>)
-SYMBOL(sinf, std::, <cmath>)
+SYMBOL_VERSION(signed_integral, std::, <concepts>, "c++20")
+SYMBOL_VERSION(sinf, std::, <cmath>, "c++11")
SYMBOL(sinf, None, <cmath>)
SYMBOL(sinf, None, <math.h>)
-SYMBOL(sinh, std::, <cmath>)
-SYMBOL(sinh, None, <cmath>)
-SYMBOL(sinh, None, <math.h>)
-SYMBOL(sinhf, std::, <cmath>)
+SYMBOL_VERSION(sinhf, std::, <cmath>, "c++11")
SYMBOL(sinhf, None, <cmath>)
SYMBOL(sinhf, None, <math.h>)
-SYMBOL(sinhl, std::, <cmath>)
+SYMBOL_VERSION(sinhl, std::, <cmath>, "c++11")
SYMBOL(sinhl, None, <cmath>)
SYMBOL(sinhl, None, <math.h>)
-SYMBOL(sinl, std::, <cmath>)
+SYMBOL_VERSION(sinl, std::, <cmath>, "c++11")
SYMBOL(sinl, None, <cmath>)
SYMBOL(sinl, None, <math.h>)
-SYMBOL(sized_sentinel_for, std::, <iterator>)
+SYMBOL_VERSION(sized_sentinel_for, std::, <iterator>, "c++20")
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_VERSION(smatch, std::, <regex>, "c++11")
+SYMBOL_VERSION(snprintf, std::, <cstdio>, "c++11")
SYMBOL(snprintf, None, <cstdio>)
SYMBOL(snprintf, None, <stdio.h>)
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_VERSION(sortable, std::, <iterator>, "c++20")
+SYMBOL_VERSION(source_location, std::, <source_location>, "c++20")
+SYMBOL_VERSION(span, std::, <span>, "c++20")
+SYMBOL_VERSION(spanbuf, std::, <spanstream>, "c++23")
+SYMBOL_VERSION(spanbuf, std::, <iosfwd>, "c++23")
+SYMBOL_VERSION(spanstream, std::, <spanstream>, "c++23")
+SYMBOL_VERSION(spanstream, std::, <iosfwd>, "c++23")
+SYMBOL_VERSION(sph_bessel, std::, <cmath>, "c++17")
SYMBOL(sph_bessel, None, <cmath>)
SYMBOL(sph_bessel, None, <math.h>)
-SYMBOL(sph_besself, std::, <cmath>)
+SYMBOL_VERSION(sph_besself, std::, <cmath>, "c++17")
SYMBOL(sph_besself, None, <cmath>)
SYMBOL(sph_besself, None, <math.h>)
-SYMBOL(sph_bessell, std::, <cmath>)
+SYMBOL_VERSION(sph_bessell, std::, <cmath>, "c++17")
SYMBOL(sph_bessell, None, <cmath>)
SYMBOL(sph_bessell, None, <math.h>)
-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(sph_neumannl, std::, <cmath>)
+SYMBOL_VERSION(sph_legendre, std::, <cmath>, "c++17")
+SYMBOL_VERSION(sph_legendref, std::, <cmath>, "c++17")
+SYMBOL_VERSION(sph_legendrel, std::, <cmath>, "c++17")
+SYMBOL_VERSION(sph_neumann, std::, <cmath>, "c++17")
+SYMBOL_VERSION(sph_neumannf, std::, <cmath>, "c++17")
+SYMBOL_VERSION(sph_neumannl, std::, <cmath>, "c++17")
SYMBOL(sprintf, std::, <cstdio>)
SYMBOL(sprintf, None, <cstdio>)
SYMBOL(sprintf, None, <stdio.h>)
-SYMBOL(sqrt, std::, <cmath>)
-SYMBOL(sqrt, None, <cmath>)
-SYMBOL(sqrt, None, <math.h>)
-SYMBOL(sqrtf, std::, <cmath>)
+SYMBOL_VERSION(sqrtf, std::, <cmath>, "c++11")
SYMBOL(sqrtf, None, <cmath>)
SYMBOL(sqrtf, None, <math.h>)
-SYMBOL(sqrtl, std::, <cmath>)
+SYMBOL_VERSION(sqrtl, std::, <cmath>, "c++11")
SYMBOL(sqrtl, None, <cmath>)
SYMBOL(sqrtl, None, <math.h>)
SYMBOL(srand, std::, <cstdlib>)
SYMBOL(srand, None, <cstdlib>)
SYMBOL(srand, None, <stdlib.h>)
-SYMBOL(sregex_iterator, std::, <regex>)
-SYMBOL(sregex_token_iterator, std::, <regex>)
+SYMBOL_VERSION(sregex_iterator, std::, <regex>, "c++11")
+SYMBOL_VERSION(sregex_token_iterator, std::, <regex>, "c++11")
SYMBOL(sscanf, std::, <cstdio>)
SYMBOL(sscanf, None, <cstdio>)
SYMBOL(sscanf, None, <stdio.h>)
-SYMBOL(ssub_match, std::, <regex>)
+SYMBOL_VERSION(ssub_match, std::, <regex>, "c++11")
SYMBOL(stable_partition, std::, <algorithm>)
SYMBOL(stable_sort, std::, <algorithm>)
SYMBOL(stack, std::, <stack>)
-SYMBOL(stacktrace, std::, <stacktrace>)
-SYMBOL(stacktrace_entry, std::, <stacktrace>)
-SYMBOL(start_lifetime_as, std::, <memory>)
-SYMBOL(static_pointer_cast, std::, <memory>)
-SYMBOL(stod, std::, <string>)
-SYMBOL(stof, std::, <string>)
-SYMBOL(stoi, std::, <string>)
-SYMBOL(stol, std::, <string>)
-SYMBOL(stold, std::, <string>)
-SYMBOL(stoll, std::, <string>)
-SYMBOL(stop_callback, std::, <stop_token>)
-SYMBOL(stop_source, std::, <stop_token>)
-SYMBOL(stop_token, std::, <stop_token>)
-SYMBOL(stoul, std::, <string>)
-SYMBOL(stoull, std::, <string>)
+SYMBOL_VERSION(stacktrace, std::, <stacktrace>, "c++23")
+SYMBOL_VERSION(stacktrace_entry, std::, <stacktrace>, "c++23")
+SYMBOL_VERSION(start_lifetime_as, std::, <memory>, "c++23")
+SYMBOL_VERSION(static_pointer_cast, std::, <memory>, "c++11")
+SYMBOL_VERSION(stod, std::, <string>, "c++11")
+SYMBOL_VERSION(stof, std::, <string>, "c++11")
+SYMBOL_VERSION(stoi, std::, <string>, "c++11")
+SYMBOL_VERSION(stol, std::, <string>, "c++11")
+SYMBOL_VERSION(stold, std::, <string>, "c++11")
+SYMBOL_VERSION(stoll, std::, <string>, "c++11")
+SYMBOL_VERSION(stop_callback, std::, <stop_token>, "c++20")
+SYMBOL_VERSION(stop_source, std::, <stop_token>, "c++20")
+SYMBOL_VERSION(stop_token, std::, <stop_token>, "c++20")
+SYMBOL_VERSION(stoul, std::, <string>, "c++11")
+SYMBOL_VERSION(stoull, std::, <string>, "c++11")
SYMBOL(strcat, std::, <cstring>)
SYMBOL(strcat, None, <cstring>)
SYMBOL(strcat, None, <string.h>)
@@ -2813,11 +2697,11 @@ SYMBOL(strerror, None, <string.h>)
SYMBOL(strftime, std::, <ctime>)
SYMBOL(strftime, None, <ctime>)
SYMBOL(strftime, None, <time.h>)
-SYMBOL(strict, std::, <memory>)
-SYMBOL(strict_weak_order, std::, <concepts>)
-SYMBOL(strided_slice, std::, <mdspan>)
+SYMBOL_VERSION(strict, std::, <memory>, "c++11")
+SYMBOL_VERSION(strict_weak_order, std::, <concepts>, "c++20")
+SYMBOL_VERSION(strided_slice, std::, <mdspan>, "c++26")
SYMBOL(string, std::, <string>)
-SYMBOL(string_view, std::, <string_view>)
+SYMBOL_VERSION(string_view, std::, <string_view>, "c++17")
SYMBOL(stringbuf, std::, <sstream>)
SYMBOL(stringbuf, std::, <iosfwd>)
SYMBOL(stringstream, std::, <sstream>)
@@ -2834,8 +2718,8 @@ SYMBOL(strncmp, None, <string.h>)
SYMBOL(strncpy, std::, <cstring>)
SYMBOL(strncpy, None, <cstring>)
SYMBOL(strncpy, None, <string.h>)
-SYMBOL(strong_order, std::, <compare>)
-SYMBOL(strong_ordering, std::, <compare>)
+SYMBOL_VERSION(strong_order, std::, <compare>, "c++20")
+SYMBOL_VERSION(strong_ordering, std::, <compare>, "c++20")
SYMBOL(strpbrk, std::, <cstring>)
SYMBOL(strpbrk, None, <cstring>)
SYMBOL(strpbrk, None, <string.h>)
@@ -2849,16 +2733,14 @@ SYMBOL(strstr, std::, <cstring>)
SYMBOL(strstr, None, <cstring>)
SYMBOL(strstr, None, <string.h>)
SYMBOL(strstream, std::, <strstream>)
-SYMBOL(strstream, std::, <strstream>)
-SYMBOL(strstreambuf, std::, <strstream>)
SYMBOL(strstreambuf, std::, <strstream>)
SYMBOL(strtod, std::, <cstdlib>)
SYMBOL(strtod, None, <cstdlib>)
SYMBOL(strtod, None, <stdlib.h>)
-SYMBOL(strtof, std::, <cstdlib>)
+SYMBOL_VERSION(strtof, std::, <cstdlib>, "c++11")
SYMBOL(strtof, None, <cstdlib>)
SYMBOL(strtof, None, <stdlib.h>)
-SYMBOL(strtoimax, std::, <cinttypes>)
+SYMBOL_VERSION(strtoimax, std::, <cinttypes>, "c++11")
SYMBOL(strtoimax, None, <cinttypes>)
SYMBOL(strtoimax, None, <inttypes.h>)
SYMBOL(strtok, std::, <cstring>)
@@ -2870,80 +2752,71 @@ SYMBOL(strtol, None, <stdlib.h>)
SYMBOL(strtold, std::, <cstdlib>)
SYMBOL(strtold, None, <cstdlib>)
SYMBOL(strtold, None, <stdlib.h>)
-SYMBOL(strtoll, std::, <cstdlib>)
+SYMBOL_VERSION(strtoll, std::, <cstdlib>, "c++11")
SYMBOL(strtoll, None, <cstdlib>)
SYMBOL(strtoll, None, <stdlib.h>)
SYMBOL(strtoul, std::, <cstdlib>)
SYMBOL(strtoul, None, <cstdlib>)
SYMBOL(strtoul, None, <stdlib.h>)
-SYMBOL(strtoull, std::, <cstdlib>)
+SYMBOL_VERSION(strtoull, std::, <cstdlib>, "c++11")
SYMBOL(strtoull, None, <cstdlib>)
SYMBOL(strtoull, None, <stdlib.h>)
-SYMBOL(strtoumax, std::, <cinttypes>)
+SYMBOL_VERSION(strtoumax, std::, <cinttypes>, "c++11")
SYMBOL(strtoumax, None, <cinttypes>)
SYMBOL(strtoumax, None, <inttypes.h>)
SYMBOL(strxfrm, std::, <cstring>)
SYMBOL(strxfrm, None, <cstring>)
SYMBOL(strxfrm, None, <string.h>)
-SYMBOL(student_t_distribution, std::, <random>)
-SYMBOL(sub_match, std::, <regex>)
-SYMBOL(sub_sat, std::, <numeric>)
-SYMBOL(submdspan_mapping_result, std::, <mdspan>)
-SYMBOL(subtract_with_carry_engine, std::, <random>)
-SYMBOL(suspend_always, std::, <coroutine>)
-SYMBOL(suspend_never, std::, <coroutine>)
+SYMBOL_VERSION(student_t_distribution, std::, <random>, "c++11")
+SYMBOL_VERSION(sub_match, std::, <regex>, "c++11")
+SYMBOL_VERSION(sub_sat, std::, <numeric>, "c++26")
+SYMBOL_VERSION(submdspan_mapping_result, std::, <mdspan>, "c++26")
+SYMBOL_VERSION(subtract_with_carry_engine, std::, <random>, "c++11")
+SYMBOL_VERSION(suspend_always, std::, <coroutine>, "c++20")
+SYMBOL_VERSION(suspend_never, std::, <coroutine>, "c++20")
SYMBOL(swap_ranges, std::, <algorithm>)
-SYMBOL(swappable, std::, <concepts>)
-SYMBOL(swappable_with, std::, <concepts>)
+SYMBOL_VERSION(swappable, std::, <concepts>, "c++20")
+SYMBOL_VERSION(swappable_with, std::, <concepts>, "c++20")
SYMBOL(swprintf, std::, <cwchar>)
SYMBOL(swprintf, None, <cwchar>)
SYMBOL(swprintf, None, <wchar.h>)
SYMBOL(swscanf, std::, <cwchar>)
SYMBOL(swscanf, None, <cwchar>)
SYMBOL(swscanf, None, <wchar.h>)
-SYMBOL(syncbuf, std::, <syncstream>)
-SYMBOL(syncbuf, std::, <iosfwd>)
+SYMBOL_VERSION(syncbuf, std::, <syncstream>, "c++20")
+SYMBOL_VERSION(syncbuf, std::, <iosfwd>, "c++20")
SYMBOL(system, std::, <cstdlib>)
SYMBOL(system, None, <cstdlib>)
SYMBOL(system, None, <stdlib.h>)
-SYMBOL(system_category, std::, <system_error>)
-SYMBOL(system_error, std::, <system_error>)
-SYMBOL(tan, std::, <cmath>)
-SYMBOL(tan, None, <cmath>)
-SYMBOL(tan, None, <math.h>)
-SYMBOL(tanf, std::, <cmath>)
+SYMBOL_VERSION(system_category, std::, <system_error>, "c++11")
+SYMBOL_VERSION(system_error, std::, <system_error>, "c++11")
+SYMBOL_VERSION(tanf, std::, <cmath>, "c++11")
SYMBOL(tanf, None, <cmath>)
SYMBOL(tanf, None, <math.h>)
-SYMBOL(tanh, std::, <cmath>)
-SYMBOL(tanh, None, <cmath>)
-SYMBOL(tanh, None, <math.h>)
-SYMBOL(tanhf, std::, <cmath>)
+SYMBOL_VERSION(tanhf, std::, <cmath>, "c++11")
SYMBOL(tanhf, None, <cmath>)
SYMBOL(tanhf, None, <math.h>)
-SYMBOL(tanhl, std::, <cmath>)
+SYMBOL_VERSION(tanhl, std::, <cmath>, "c++11")
SYMBOL(tanhl, None, <cmath>)
SYMBOL(tanhl, None, <math.h>)
-SYMBOL(tanl, std::, <cmath>)
+SYMBOL_VERSION(tanl, std::, <cmath>, "c++11")
SYMBOL(tanl, None, <cmath>)
SYMBOL(tanl, None, <math.h>)
-SYMBOL(tera, std::, <ratio>)
+SYMBOL_VERSION(tera, std::, <ratio>, "c++11")
SYMBOL(terminate, std::, <exception>)
SYMBOL(terminate_handler, std::, <exception>)
-SYMBOL(text_encoding, std::, <text_encoding>)
-SYMBOL(tgamma, std::, <cmath>)
-SYMBOL(tgamma, None, <cmath>)
-SYMBOL(tgamma, None, <math.h>)
-SYMBOL(tgammaf, std::, <cmath>)
+SYMBOL_VERSION(text_encoding, std::, <text_encoding>, "c++26")
+SYMBOL_VERSION(tgammaf, std::, <cmath>, "c++11")
SYMBOL(tgammaf, None, <cmath>)
SYMBOL(tgammaf, None, <math.h>)
-SYMBOL(tgammal, std::, <cmath>)
+SYMBOL_VERSION(tgammal, std::, <cmath>, "c++11")
SYMBOL(tgammal, None, <cmath>)
SYMBOL(tgammal, None, <math.h>)
-SYMBOL(thread, std::, <thread>)
-SYMBOL(three_way_comparable, std::, <compare>)
-SYMBOL(three_way_comparable_with, std::, <compare>)
-SYMBOL(throw_with_nested, std::, <exception>)
-SYMBOL(tie, std::, <tuple>)
+SYMBOL_VERSION(thread, std::, <thread>, "c++11")
+SYMBOL_VERSION(three_way_comparable, std::, <compare>, "c++20")
+SYMBOL_VERSION(three_way_comparable_with, std::, <compare>, "c++20")
+SYMBOL_VERSION(throw_with_nested, std::, <exception>, "c++11")
+SYMBOL_VERSION(tie, std::, <tuple>, "c++11")
SYMBOL(time, std::, <ctime>)
SYMBOL(time, None, <ctime>)
SYMBOL(time, None, <time.h>)
@@ -2955,11 +2828,11 @@ SYMBOL(time_put_byname, std::, <locale>)
SYMBOL(time_t, std::, <ctime>)
SYMBOL(time_t, None, <ctime>)
SYMBOL(time_t, None, <time.h>)
-SYMBOL(timed_mutex, std::, <mutex>)
-SYMBOL(timespec, std::, <ctime>)
+SYMBOL_VERSION(timed_mutex, std::, <mutex>, "c++11")
+SYMBOL_VERSION(timespec, std::, <ctime>, "c++17")
SYMBOL(timespec, None, <ctime>)
SYMBOL(timespec, None, <time.h>)
-SYMBOL(timespec_get, std::, <ctime>)
+SYMBOL_VERSION(timespec_get, std::, <ctime>, "c++17")
SYMBOL(timespec_get, None, <ctime>)
SYMBOL(timespec_get, None, <time.h>)
SYMBOL(tm, std::, <ctime>)
@@ -2971,21 +2844,21 @@ SYMBOL(tmpfile, None, <stdio.h>)
SYMBOL(tmpnam, std::, <cstdio>)
SYMBOL(tmpnam, None, <cstdio>)
SYMBOL(tmpnam, None, <stdio.h>)
-SYMBOL(to_address, std::, <memory>)
-SYMBOL(to_array, std::, <array>)
-SYMBOL(to_chars, std::, <charconv>)
-SYMBOL(to_chars_result, std::, <charconv>)
-SYMBOL(to_integer, std::, <cstddef>)
+SYMBOL_VERSION(to_address, std::, <memory>, "c++20")
+SYMBOL_VERSION(to_array, std::, <array>, "c++20")
+SYMBOL_VERSION(to_chars, std::, <charconv>, "c++17")
+SYMBOL_VERSION(to_chars_result, std::, <charconv>, "c++17")
+SYMBOL_VERSION(to_integer, std::, <cstddef>, "c++17")
SYMBOL(to_integer, None, <cstddef>)
SYMBOL(to_integer, None, <stddef.h>)
-SYMBOL(to_string, std::, <string>)
-SYMBOL(to_underlying, std::, <utility>)
-SYMBOL(to_wstring, std::, <string>)
+SYMBOL_VERSION(to_string, std::, <string>, "c++11")
+SYMBOL_VERSION(to_underlying, std::, <utility>, "c++23")
+SYMBOL_VERSION(to_wstring, std::, <string>, "c++11")
SYMBOL(tolower, std::, <cctype>)
SYMBOL(tolower, None, <cctype>)
SYMBOL(tolower, None, <ctype.h>)
-SYMBOL(totally_ordered, std::, <concepts>)
-SYMBOL(totally_ordered_with, std::, <concepts>)
+SYMBOL_VERSION(totally_ordered, std::, <concepts>, "c++20")
+SYMBOL_VERSION(totally_ordered_with, std::, <concepts>, "c++20")
SYMBOL(toupper, std::, <cctype>)
SYMBOL(toupper, None, <cctype>)
SYMBOL(toupper, None, <ctype.h>)
@@ -2999,96 +2872,93 @@ SYMBOL(towupper, std::, <cwctype>)
SYMBOL(towupper, None, <cwctype>)
SYMBOL(towupper, None, <wctype.h>)
SYMBOL(transform, std::, <algorithm>)
-SYMBOL(transform_exclusive_scan, std::, <numeric>)
-SYMBOL(transform_inclusive_scan, std::, <numeric>)
-SYMBOL(transform_reduce, std::, <numeric>)
-SYMBOL(true_type, std::, <type_traits>)
-SYMBOL(trunc, std::, <cmath>)
-SYMBOL(trunc, None, <cmath>)
-SYMBOL(trunc, None, <math.h>)
-SYMBOL(truncf, std::, <cmath>)
+SYMBOL_VERSION(transform_exclusive_scan, std::, <numeric>, "c++17")
+SYMBOL_VERSION(transform_inclusive_scan, std::, <numeric>, "c++17")
+SYMBOL_VERSION(transform_reduce, std::, <numeric>, "c++17")
+SYMBOL_VERSION(true_type, std::, <type_traits>, "c++11")
+SYMBOL_VERSION(truncf, std::, <cmath>, "c++11")
SYMBOL(truncf, None, <cmath>)
SYMBOL(truncf, None, <math.h>)
-SYMBOL(truncl, std::, <cmath>)
+SYMBOL_VERSION(truncl, std::, <cmath>, "c++11")
SYMBOL(truncl, None, <cmath>)
SYMBOL(truncl, None, <math.h>)
-SYMBOL(try_lock, std::, <mutex>)
-SYMBOL(try_to_lock, std::, <mutex>)
-SYMBOL(try_to_lock_t, std::, <mutex>)
-SYMBOL(tuple, std::, <tuple>)
-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_VERSION(try_lock, std::, <mutex>, "c++11")
+SYMBOL_VERSION(try_to_lock, std::, <mutex>, "c++11")
+SYMBOL_VERSION(try_to_lock_t, std::, <mutex>, "c++11")
+SYMBOL_VERSION(tuple, std::, <tuple>, "c++11")
+SYMBOL_VERSION(tuple_cat, std::, <tuple>, "c++11")
+SYMBOL_VERSION(tuple_element_t, std::, <tuple>, "c++14")
+SYMBOL_VERSION(tuple_size_v, std::, <tuple>, "c++17")
+SYMBOL_VERSION(type_identity, std::, <type_traits>, "c++20")
+SYMBOL_VERSION(type_identity_t, std::, <type_traits>, "c++20")
+SYMBOL_VERSION(type_index, std::, <typeindex>, "c++11")
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_VERSION(u16streampos, std::, <iosfwd>, "c++11")
+SYMBOL_VERSION(u16streampos, std::, <iosfwd>, "c++11")
+SYMBOL_VERSION(u16string, std::, <string>, "c++11")
+SYMBOL_VERSION(u16string_view, std::, <string_view>, "c++17")
+SYMBOL_VERSION(u32streampos, std::, <iosfwd>, "c++11")
+SYMBOL_VERSION(u32streampos, std::, <iosfwd>, "c++11")
+SYMBOL_VERSION(u32string, std::, <string>, "c++11")
+SYMBOL_VERSION(u32string_view, std::, <string_view>, "c++17")
+SYMBOL_VERSION(u8streampos, std::, <iosfwd>, "c++20")
+SYMBOL_VERSION(u8streampos, std::, <iosfwd>, "c++20")
+SYMBOL_VERSION(u8string, std::, <string>, "c++20")
+SYMBOL_VERSION(u8string_view, std::, <string_view>, "c++20")
+SYMBOL_VERSION(uint16_t, std::, <cstdint>, "c++11")
SYMBOL(uint16_t, None, <cstdint>)
SYMBOL(uint16_t, None, <stdint.h>)
-SYMBOL(uint32_t, std::, <cstdint>)
+SYMBOL_VERSION(uint32_t, std::, <cstdint>, "c++11")
SYMBOL(uint32_t, None, <cstdint>)
SYMBOL(uint32_t, None, <stdint.h>)
-SYMBOL(uint64_t, std::, <cstdint>)
+SYMBOL_VERSION(uint64_t, std::, <cstdint>, "c++11")
SYMBOL(uint64_t, None, <cstdint>)
SYMBOL(uint64_t, None, <stdint.h>)
-SYMBOL(uint8_t, std::, <cstdint>)
+SYMBOL_VERSION(uint8_t, std::, <cstdint>, "c++11")
SYMBOL(uint8_t, None, <cstdint>)
SYMBOL(uint8_t, None, <stdint.h>)
-SYMBOL(uint_fast16_t, std::, <cstdint>)
+SYMBOL_VERSION(uint_fast16_t, std::, <cstdint>, "c++11")
SYMBOL(uint_fast16_t, None, <cstdint>)
SYMBOL(uint_fast16_t, None, <stdint.h>)
-SYMBOL(uint_fast32_t, std::, <cstdint>)
+SYMBOL_VERSION(uint_fast32_t, std::, <cstdint>, "c++11")
SYMBOL(uint_fast32_t, None, <cstdint>)
SYMBOL(uint_fast32_t, None, <stdint.h>)
-SYMBOL(uint_fast64_t, std::, <cstdint>)
+SYMBOL_VERSION(uint_fast64_t, std::, <cstdint>, "c++11")
SYMBOL(uint_fast64_t, None, <cstdint>)
SYMBOL(uint_fast64_t, None, <stdint.h>)
-SYMBOL(uint_fast8_t, std::, <cstdint>)
+SYMBOL_VERSION(uint_fast8_t, std::, <cstdint>, "c++11")
SYMBOL(uint_fast8_t, None, <cstdint>)
SYMBOL(uint_fast8_t, None, <stdint.h>)
-SYMBOL(uint_least16_t, std::, <cstdint>)
+SYMBOL_VERSION(uint_least16_t, std::, <cstdint>, "c++11")
SYMBOL(uint_least16_t, None, <cstdint>)
SYMBOL(uint_least16_t, None, <stdint.h>)
-SYMBOL(uint_least32_t, std::, <cstdint>)
+SYMBOL_VERSION(uint_least32_t, std::, <cstdint>, "c++11")
SYMBOL(uint_least32_t, None, <cstdint>)
SYMBOL(uint_least32_t, None, <stdint.h>)
-SYMBOL(uint_least64_t, std::, <cstdint>)
+SYMBOL_VERSION(uint_least64_t, std::, <cstdint>, "c++11")
SYMBOL(uint_least64_t, None, <cstdint>)
SYMBOL(uint_least64_t, None, <stdint.h>)
-SYMBOL(uint_least8_t, std::, <cstdint>)
+SYMBOL_VERSION(uint_least8_t, std::, <cstdint>, "c++11")
SYMBOL(uint_least8_t, None, <cstdint>)
SYMBOL(uint_least8_t, None, <stdint.h>)
-SYMBOL(uintmax_t, std::, <cstdint>)
+SYMBOL_VERSION(uintmax_t, std::, <cstdint>, "c++11")
SYMBOL(uintmax_t, None, <cstdint>)
SYMBOL(uintmax_t, None, <stdint.h>)
-SYMBOL(uintptr_t, std::, <cstdint>)
+SYMBOL_VERSION(uintptr_t, std::, <cstdint>, "c++11")
SYMBOL(uintptr_t, None, <cstdint>)
SYMBOL(uintptr_t, None, <stdint.h>)
SYMBOL(unary_function, std::, <functional>)
SYMBOL(unary_negate, std::, <functional>)
SYMBOL(uncaught_exception, std::, <exception>)
-SYMBOL(uncaught_exceptions, std::, <exception>)
-SYMBOL(undeclare_no_pointers, std::, <memory>)
-SYMBOL(undeclare_reachable, std::, <memory>)
+SYMBOL_VERSION(uncaught_exceptions, std::, <exception>, "c++17")
+SYMBOL_VERSION(undeclare_no_pointers, std::, <memory>, "c++11")
+SYMBOL_VERSION(undeclare_reachable, std::, <memory>, "c++11")
SYMBOL(underflow_error, std::, <stdexcept>)
-SYMBOL(underlying_type, std::, <type_traits>)
-SYMBOL(underlying_type_t, std::, <type_traits>)
-SYMBOL(unexpect, std::, <expected>)
-SYMBOL(unexpect_t, std::, <expected>)
-SYMBOL(unexpected, std::, <expected>)
+SYMBOL_VERSION(underlying_type, std::, <type_traits>, "c++11")
+SYMBOL_VERSION(underlying_type_t, std::, <type_traits>, "c++14")
+SYMBOL_VERSION(unexpect, std::, <expected>, "c++23")
+SYMBOL_VERSION(unexpect_t, std::, <expected>, "c++23")
+SYMBOL_VERSION(unexpected, std::, <expected>, "c++23")
SYMBOL(unexpected_handler, std::, <exception>)
SYMBOL(ungetc, std::, <cstdio>)
SYMBOL(ungetc, None, <cstdio>)
@@ -3096,109 +2966,109 @@ SYMBOL(ungetc, None, <stdio.h>)
SYMBOL(ungetwc, std::, <cwchar>)
SYMBOL(ungetwc, None, <cwchar>)
SYMBOL(ungetwc, None, <wchar.h>)
-SYMBOL(uniform_int_distribution, std::, <random>)
-SYMBOL(uniform_random_bit_generator, std::, <random>)
-SYMBOL(uniform_real_distribution, std::, <random>)
-SYMBOL(uninitialized_construct_using_allocator, std::, <memory>)
+SYMBOL_VERSION(uniform_int_distribution, std::, <random>, "c++11")
+SYMBOL_VERSION(uniform_random_bit_generator, std::, <random>, "c++20")
+SYMBOL_VERSION(uniform_real_distribution, std::, <random>, "c++11")
+SYMBOL_VERSION(uninitialized_construct_using_allocator, std::, <memory>, "c++20")
SYMBOL(uninitialized_copy, std::, <memory>)
-SYMBOL(uninitialized_copy_n, std::, <memory>)
-SYMBOL(uninitialized_default_construct, std::, <memory>)
-SYMBOL(uninitialized_default_construct_n, std::, <memory>)
+SYMBOL_VERSION(uninitialized_copy_n, std::, <memory>, "c++11")
+SYMBOL_VERSION(uninitialized_default_construct, std::, <memory>, "c++17")
+SYMBOL_VERSION(uninitialized_default_construct_n, std::, <memory>, "c++17")
SYMBOL(uninitialized_fill, std::, <memory>)
SYMBOL(uninitialized_fill_n, std::, <memory>)
-SYMBOL(uninitialized_move, std::, <memory>)
-SYMBOL(uninitialized_move_n, std::, <memory>)
-SYMBOL(uninitialized_value_construct, std::, <memory>)
-SYMBOL(uninitialized_value_construct_n, std::, <memory>)
+SYMBOL_VERSION(uninitialized_move, std::, <memory>, "c++17")
+SYMBOL_VERSION(uninitialized_move_n, std::, <memory>, "c++17")
+SYMBOL_VERSION(uninitialized_value_construct, std::, <memory>, "c++17")
+SYMBOL_VERSION(uninitialized_value_construct_n, std::, <memory>, "c++17")
SYMBOL(unique, std::, <algorithm>)
SYMBOL(unique_copy, std::, <algorithm>)
-SYMBOL(unique_lock, std::, <mutex>)
-SYMBOL(unique_ptr, std::, <memory>)
+SYMBOL_VERSION(unique_lock, std::, <mutex>, "c++11")
+SYMBOL_VERSION(unique_ptr, std::, <memory>, "c++11")
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_VERSION(unordered_map, std::, <unordered_map>, "c++11")
+SYMBOL_VERSION(unordered_multimap, std::, <unordered_map>, "c++11")
+SYMBOL_VERSION(unordered_multiset, std::, <unordered_set>, "c++11")
+SYMBOL_VERSION(unordered_set, std::, <unordered_set>, "c++11")
+SYMBOL_VERSION(unreachable, std::, <utility>, "c++23")
+SYMBOL_VERSION(unreachable_sentinel, std::, <iterator>, "c++20")
+SYMBOL_VERSION(unreachable_sentinel_t, std::, <iterator>, "c++20")
+SYMBOL_VERSION(unsigned_integral, std::, <concepts>, "c++20")
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_VERSION(uses_allocator, std::, <memory>, "c++11")
+SYMBOL_VERSION(uses_allocator_construction_args, std::, <memory>, "c++20")
+SYMBOL_VERSION(uses_allocator_v, std::, <memory>, "c++17")
SYMBOL(va_list, std::, <cstdarg>)
SYMBOL(va_list, None, <cstdarg>)
SYMBOL(va_list, None, <stdarg.h>)
SYMBOL(valarray, std::, <valarray>)
-SYMBOL(variant, std::, <variant>)
-SYMBOL(variant_alternative, std::, <variant>)
-SYMBOL(variant_alternative_t, std::, <variant>)
-SYMBOL(variant_npos, std::, <variant>)
-SYMBOL(variant_size, std::, <variant>)
-SYMBOL(variant_size_v, std::, <variant>)
+SYMBOL_VERSION(variant, std::, <variant>, "c++17")
+SYMBOL_VERSION(variant_alternative, std::, <variant>, "c++17")
+SYMBOL_VERSION(variant_alternative_t, std::, <variant>, "c++17")
+SYMBOL_VERSION(variant_npos, std::, <variant>, "c++17")
+SYMBOL_VERSION(variant_size, std::, <variant>, "c++17")
+SYMBOL_VERSION(variant_size_v, std::, <variant>, "c++17")
SYMBOL(vector, std::, <vector>)
-SYMBOL(vformat, std::, <format>)
-SYMBOL(vformat_to, std::, <format>)
+SYMBOL_VERSION(vformat, std::, <format>, "c++20")
+SYMBOL_VERSION(vformat_to, std::, <format>, "c++20")
SYMBOL(vfprintf, std::, <cstdio>)
SYMBOL(vfprintf, None, <cstdio>)
SYMBOL(vfprintf, None, <stdio.h>)
-SYMBOL(vfscanf, std::, <cstdio>)
+SYMBOL_VERSION(vfscanf, std::, <cstdio>, "c++11")
SYMBOL(vfscanf, None, <cstdio>)
SYMBOL(vfscanf, None, <stdio.h>)
SYMBOL(vfwprintf, std::, <cwchar>)
SYMBOL(vfwprintf, None, <cwchar>)
SYMBOL(vfwprintf, None, <wchar.h>)
-SYMBOL(vfwscanf, std::, <cwchar>)
+SYMBOL_VERSION(vfwscanf, std::, <cwchar>, "c++11")
SYMBOL(vfwscanf, None, <cwchar>)
SYMBOL(vfwscanf, None, <wchar.h>)
-SYMBOL(visit, std::, <variant>)
-SYMBOL(visit_format_arg, std::, <format>)
-SYMBOL(void_t, std::, <type_traits>)
-SYMBOL(vprint_nonunicode, std::, <print>)
-SYMBOL(vprint_nonunicode_buffered, std::, <print>)
-SYMBOL(vprint_unicode, std::, <print>)
-SYMBOL(vprint_unicode_buffered, std::, <print>)
+SYMBOL_VERSION(visit, std::, <variant>, "c++17")
+SYMBOL_VERSION(visit_format_arg, std::, <format>, "c++20")
+SYMBOL_VERSION(void_t, std::, <type_traits>, "c++17")
+SYMBOL_VERSION(vprint_nonunicode, std::, <print>, "c++23")
+SYMBOL_VERSION(vprint_nonunicode_buffered, std::, <print>, "c++23")
+SYMBOL_VERSION(vprint_unicode, std::, <print>, "c++23")
+SYMBOL_VERSION(vprint_unicode_buffered, std::, <print>, "c++23")
SYMBOL(vprintf, std::, <cstdio>)
SYMBOL(vprintf, None, <cstdio>)
SYMBOL(vprintf, None, <stdio.h>)
-SYMBOL(vscanf, std::, <cstdio>)
+SYMBOL_VERSION(vscanf, std::, <cstdio>, "c++11")
SYMBOL(vscanf, None, <cstdio>)
SYMBOL(vscanf, None, <stdio.h>)
-SYMBOL(vsnprintf, std::, <cstdio>)
+SYMBOL_VERSION(vsnprintf, std::, <cstdio>, "c++11")
SYMBOL(vsnprintf, None, <cstdio>)
SYMBOL(vsnprintf, None, <stdio.h>)
SYMBOL(vsprintf, std::, <cstdio>)
SYMBOL(vsprintf, None, <cstdio>)
SYMBOL(vsprintf, None, <stdio.h>)
-SYMBOL(vsscanf, std::, <cstdio>)
+SYMBOL_VERSION(vsscanf, std::, <cstdio>, "c++11")
SYMBOL(vsscanf, None, <cstdio>)
SYMBOL(vsscanf, None, <stdio.h>)
SYMBOL(vswprintf, std::, <cwchar>)
SYMBOL(vswprintf, None, <cwchar>)
SYMBOL(vswprintf, None, <wchar.h>)
-SYMBOL(vswscanf, std::, <cwchar>)
+SYMBOL_VERSION(vswscanf, std::, <cwchar>, "c++11")
SYMBOL(vswscanf, None, <cwchar>)
SYMBOL(vswscanf, None, <wchar.h>)
SYMBOL(vwprintf, std::, <cwchar>)
SYMBOL(vwprintf, None, <cwchar>)
SYMBOL(vwprintf, None, <wchar.h>)
-SYMBOL(vwscanf, std::, <cwchar>)
+SYMBOL_VERSION(vwscanf, std::, <cwchar>, "c++11")
SYMBOL(vwscanf, None, <cwchar>)
SYMBOL(vwscanf, None, <wchar.h>)
-SYMBOL(wbuffer_convert, std::, <locale>)
+SYMBOL_VERSION(wbuffer_convert, std::, <locale>, "c++11")
SYMBOL(wbuffer_convert, std::, <locale>)
SYMBOL(wcerr, std::, <iostream>)
SYMBOL(wcin, std::, <iostream>)
SYMBOL(wclog, std::, <iostream>)
-SYMBOL(wcmatch, std::, <regex>)
+SYMBOL_VERSION(wcmatch, std::, <regex>, "c++11")
SYMBOL(wcout, std::, <iostream>)
-SYMBOL(wcregex_iterator, std::, <regex>)
-SYMBOL(wcregex_token_iterator, std::, <regex>)
+SYMBOL_VERSION(wcregex_iterator, std::, <regex>, "c++11")
+SYMBOL_VERSION(wcregex_token_iterator, std::, <regex>, "c++11")
SYMBOL(wcrtomb, std::, <cwchar>)
SYMBOL(wcrtomb, None, <cwchar>)
SYMBOL(wcrtomb, None, <wchar.h>)
@@ -3253,10 +3123,10 @@ SYMBOL(wcsstr, None, <wchar.h>)
SYMBOL(wcstod, std::, <cwchar>)
SYMBOL(wcstod, None, <cwchar>)
SYMBOL(wcstod, None, <wchar.h>)
-SYMBOL(wcstof, std::, <cwchar>)
+SYMBOL_VERSION(wcstof, std::, <cwchar>, "c++11")
SYMBOL(wcstof, None, <cwchar>)
SYMBOL(wcstof, None, <wchar.h>)
-SYMBOL(wcstoimax, std::, <cinttypes>)
+SYMBOL_VERSION(wcstoimax, std::, <cinttypes>, "c++11")
SYMBOL(wcstoimax, None, <cinttypes>)
SYMBOL(wcstoimax, None, <inttypes.h>)
SYMBOL(wcstok, std::, <cwchar>)
@@ -3265,10 +3135,10 @@ SYMBOL(wcstok, None, <wchar.h>)
SYMBOL(wcstol, std::, <cwchar>)
SYMBOL(wcstol, None, <cwchar>)
SYMBOL(wcstol, None, <wchar.h>)
-SYMBOL(wcstold, std::, <cwchar>)
+SYMBOL_VERSION(wcstold, std::, <cwchar>, "c++11")
SYMBOL(wcstold, None, <cwchar>)
SYMBOL(wcstold, None, <wchar.h>)
-SYMBOL(wcstoll, std::, <cwchar>)
+SYMBOL_VERSION(wcstoll, std::, <cwchar>, "c++11")
SYMBOL(wcstoll, None, <cwchar>)
SYMBOL(wcstoll, None, <wchar.h>)
SYMBOL(wcstombs, std::, <cstdlib>)
@@ -3277,13 +3147,13 @@ SYMBOL(wcstombs, None, <stdlib.h>)
SYMBOL(wcstoul, std::, <cwchar>)
SYMBOL(wcstoul, None, <cwchar>)
SYMBOL(wcstoul, None, <wchar.h>)
-SYMBOL(wcstoull, std::, <cwchar>)
+SYMBOL_VERSION(wcstoull, std::, <cwchar>, "c++11")
SYMBOL(wcstoull, None, <cwchar>)
SYMBOL(wcstoull, None, <wchar.h>)
-SYMBOL(wcstoumax, std::, <cinttypes>)
+SYMBOL_VERSION(wcstoumax, std::, <cinttypes>, "c++11")
SYMBOL(wcstoumax, None, <cinttypes>)
SYMBOL(wcstoumax, None, <inttypes.h>)
-SYMBOL(wcsub_match, std::, <regex>)
+SYMBOL_VERSION(wcsub_match, std::, <regex>, "c++11")
SYMBOL(wcsxfrm, std::, <cwchar>)
SYMBOL(wcsxfrm, None, <cwchar>)
SYMBOL(wcsxfrm, None, <wchar.h>)
@@ -3305,17 +3175,17 @@ SYMBOL(wctype, None, <wctype.h>)
SYMBOL(wctype_t, std::, <cwctype>)
SYMBOL(wctype_t, None, <cwctype>)
SYMBOL(wctype_t, None, <wctype.h>)
-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_VERSION(weak_order, std::, <compare>, "c++20")
+SYMBOL_VERSION(weak_ordering, std::, <compare>, "c++20")
+SYMBOL_VERSION(weak_ptr, std::, <memory>, "c++11")
+SYMBOL_VERSION(weakly_incrementable, std::, <iterator>, "c++20")
+SYMBOL_VERSION(weibull_distribution, std::, <random>, "c++11")
SYMBOL(wfilebuf, std::, <fstream>)
SYMBOL(wfilebuf, std::, <iosfwd>)
-SYMBOL(wformat_args, std::, <format>)
-SYMBOL(wformat_context, std::, <format>)
-SYMBOL(wformat_parse_context, std::, <format>)
-SYMBOL(wformat_string, std::, <format>)
+SYMBOL_VERSION(wformat_args, std::, <format>, "c++20")
+SYMBOL_VERSION(wformat_context, std::, <format>, "c++20")
+SYMBOL_VERSION(wformat_parse_context, std::, <format>, "c++20")
+SYMBOL_VERSION(wformat_string, std::, <format>, "c++20")
SYMBOL(wfstream, std::, <fstream>)
SYMBOL(wfstream, std::, <iosfwd>)
SYMBOL(wifstream, std::, <fstream>)
@@ -3326,8 +3196,8 @@ 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_VERSION(wispanstream, std::, <spanstream>, "c++23")
+SYMBOL_VERSION(wispanstream, std::, <iosfwd>, "c++23")
SYMBOL(wistream, std::, <istream>)
SYMBOL(wistream, std::, <iostream>)
SYMBOL(wistream, std::, <iosfwd>)
@@ -3350,638 +3220,643 @@ SYMBOL(wmemset, None, <cwchar>)
SYMBOL(wmemset, None, <wchar.h>)
SYMBOL(wofstream, std::, <fstream>)
SYMBOL(wofstream, std::, <iosfwd>)
-SYMBOL(wospanstream, std::, <spanstream>)
-SYMBOL(wospanstream, std::, <iosfwd>)
+SYMBOL_VERSION(wospanstream, std::, <spanstream>, "c++23")
+SYMBOL_VERSION(wospanstream, std::, <iosfwd>, "c++23")
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_VERSION(wosyncstream, std::, <syncstream>, "c++20")
+SYMBOL_VERSION(wosyncstream, std::, <iosfwd>, "c++20")
SYMBOL(wprintf, std::, <cwchar>)
SYMBOL(wprintf, None, <cwchar>)
SYMBOL(wprintf, None, <wchar.h>)
-SYMBOL(wregex, std::, <regex>)
+SYMBOL_VERSION(wregex, std::, <regex>, "c++11")
SYMBOL(ws, std::, <istream>)
SYMBOL(ws, std::, <iostream>)
SYMBOL(wscanf, std::, <cwchar>)
SYMBOL(wscanf, None, <cwchar>)
SYMBOL(wscanf, None, <wchar.h>)
-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_VERSION(wsmatch, std::, <regex>, "c++11")
+SYMBOL_VERSION(wspanbuf, std::, <spanstream>, "c++23")
+SYMBOL_VERSION(wspanbuf, std::, <iosfwd>, "c++23")
+SYMBOL_VERSION(wspanstream, std::, <spanstream>, "c++23")
+SYMBOL_VERSION(wspanstream, std::, <iosfwd>, "c++23")
+SYMBOL_VERSION(wsregex_iterator, std::, <regex>, "c++11")
+SYMBOL_VERSION(wsregex_token_iterator, std::, <regex>, "c++11")
+SYMBOL_VERSION(wssub_match, std::, <regex>, "c++11")
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_VERSION(wstring_convert, std::, <locale>, "c++11")
SYMBOL(wstring_convert, std::, <locale>)
-SYMBOL(wstring_convert, std::, <locale>)
-SYMBOL(wstring_view, std::, <string_view>)
+SYMBOL_VERSION(wstring_view, std::, <string_view>, "c++17")
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(Friday, std::chrono::, <chrono>)
-SYMBOL(January, std::chrono::, <chrono>)
-SYMBOL(July, std::chrono::, <chrono>)
-SYMBOL(June, std::chrono::, <chrono>)
-SYMBOL(March, std::chrono::, <chrono>)
-SYMBOL(May, std::chrono::, <chrono>)
-SYMBOL(Monday, std::chrono::, <chrono>)
-SYMBOL(November, std::chrono::, <chrono>)
-SYMBOL(October, std::chrono::, <chrono>)
-SYMBOL(Saturday, std::chrono::, <chrono>)
-SYMBOL(September, std::chrono::, <chrono>)
-SYMBOL(Sunday, std::chrono::, <chrono>)
-SYMBOL(Thursday, std::chrono::, <chrono>)
-SYMBOL(Tuesday, std::chrono::, <chrono>)
-SYMBOL(Wednesday, std::chrono::, <chrono>)
+SYMBOL_VERSION(wsyncbuf, std::, <syncstream>, "c++20")
+SYMBOL_VERSION(wsyncbuf, std::, <iosfwd>, "c++20")
+SYMBOL_VERSION(yocto, std::, <ratio>, "c++11")
+SYMBOL_VERSION(yotta, std::, <ratio>, "c++11")
+SYMBOL_VERSION(zepto, std::, <ratio>, "c++11")
+SYMBOL_VERSION(zetta, std::, <ratio>, "c++11")
+SYMBOL_VERSION(April, std::chrono::, <chrono>, "c++20")
+SYMBOL_VERSION(August, std::chrono::, <chrono>, "c++20")
+SYMBOL_VERSION(December, std::chrono::, <chrono>, "c++20")
+SYMBOL_VERSION(February, std::chrono::, <chrono>, "c++20")
+SYMBOL_VERSION(Friday, std::chrono::, <chrono>, "c++20")
+SYMBOL_VERSION(January, std::chrono::, <chrono>, "c++20")
+SYMBOL_VERSION(July, std::chrono::, <chrono>, "c++20")
+SYMBOL_VERSION(June, std::chrono::, <chrono>, "c++20")
+SYMBOL_VERSION(March, std::chrono::, <chrono>, "c++20")
+SYMBOL_VERSION(May, std::chrono::, <chrono>, "c++20")
+SYMBOL_VERSION(Monday, std::chrono::, <chrono>, "c++20")
+SYMBOL_VERSION(November, std::chrono::, <chrono>, "c++20")
+SYMBOL_VERSION(October, std::chrono::, <chrono>, "c++20")
+SYMBOL_VERSION(Saturday, std::chrono::, <chrono>, "c++20")
+SYMBOL_VERSION(September, std::chrono::, <chrono>, "c++20")
+SYMBOL_VERSION(Sunday, std::chrono::, <chrono>, "c++20")
+SYMBOL_VERSION(Thursday, std::chrono::, <chrono>, "c++20")
+SYMBOL_VERSION(Tuesday, std::chrono::, <chrono>, "c++20")
+SYMBOL_VERSION(Wednesday, std::chrono::, <chrono>, "c++20")
SYMBOL(abs, std::chrono::, <chrono>)
-SYMBOL(ambiguous_local_time, std::chrono::, <chrono>)
+SYMBOL_VERSION(ambiguous_local_time, std::chrono::, <chrono>, "c++20")
SYMBOL(ceil, std::chrono::, <chrono>)
-SYMBOL(choose, std::chrono::, <chrono>)
-SYMBOL(clock_cast, std::chrono::, <chrono>)
-SYMBOL(clock_time_conversion, std::chrono::, <chrono>)
-SYMBOL(current_zone, std::chrono::, <chrono>)
-SYMBOL(day, std::chrono::, <chrono>)
-SYMBOL(duration, std::chrono::, <chrono>)
-SYMBOL(duration_cast, std::chrono::, <chrono>)
-SYMBOL(duration_values, std::chrono::, <chrono>)
-SYMBOL(file_clock, std::chrono::, <chrono>)
-SYMBOL(file_seconds, std::chrono::, <chrono>)
-SYMBOL(file_time, std::chrono::, <chrono>)
+SYMBOL_VERSION(choose, std::chrono::, <chrono>, "c++20")
+SYMBOL_VERSION(clock_cast, std::chrono::, <chrono>, "c++20")
+SYMBOL_VERSION(clock_time_conversion, std::chrono::, <chrono>, "c++20")
+SYMBOL_VERSION(current_zone, std::chrono::, <chrono>, "c++20")
+SYMBOL_VERSION(day, std::chrono::, <chrono>, "c++20")
+SYMBOL_VERSION(duration, std::chrono::, <chrono>, "c++11")
+SYMBOL_VERSION(duration_cast, std::chrono::, <chrono>, "c++11")
+SYMBOL_VERSION(duration_values, std::chrono::, <chrono>, "c++11")
+SYMBOL_VERSION(file_clock, std::chrono::, <chrono>, "c++20")
+SYMBOL_VERSION(file_seconds, std::chrono::, <chrono>, "c++20")
+SYMBOL_VERSION(file_time, std::chrono::, <chrono>, "c++20")
SYMBOL(floor, std::chrono::, <chrono>)
SYMBOL(from_stream, std::chrono::, <chrono>)
-SYMBOL(get_leap_second_info, std::chrono::, <chrono>)
-SYMBOL(gps_clock, std::chrono::, <chrono>)
-SYMBOL(gps_seconds, std::chrono::, <chrono>)
-SYMBOL(gps_time, std::chrono::, <chrono>)
-SYMBOL(hh_mm_ss, std::chrono::, <chrono>)
-SYMBOL(high_resolution_clock, std::chrono::, <chrono>)
-SYMBOL(hours, std::chrono::, <chrono>)
-SYMBOL(is_am, std::chrono::, <chrono>)
-SYMBOL(is_clock, std::chrono::, <chrono>)
-SYMBOL(is_clock_v, std::chrono::, <chrono>)
-SYMBOL(is_pm, std::chrono::, <chrono>)
-SYMBOL(last, std::chrono::, <chrono>)
-SYMBOL(last_spec, std::chrono::, <chrono>)
-SYMBOL(leap_second, std::chrono::, <chrono>)
-SYMBOL(leap_second_info, std::chrono::, <chrono>)
-SYMBOL(local_info, std::chrono::, <chrono>)
-SYMBOL(local_seconds, std::chrono::, <chrono>)
-SYMBOL(local_t, std::chrono::, <chrono>)
-SYMBOL(local_time, std::chrono::, <chrono>)
-SYMBOL(local_time_format, std::chrono::, <chrono>)
-SYMBOL(locate_zone, std::chrono::, <chrono>)
-SYMBOL(make12, std::chrono::, <chrono>)
-SYMBOL(make24, std::chrono::, <chrono>)
-SYMBOL(microseconds, std::chrono::, <chrono>)
-SYMBOL(milliseconds, std::chrono::, <chrono>)
-SYMBOL(minutes, std::chrono::, <chrono>)
-SYMBOL(month, std::chrono::, <chrono>)
-SYMBOL(month_day, std::chrono::, <chrono>)
-SYMBOL(month_day_last, std::chrono::, <chrono>)
-SYMBOL(month_weekday, std::chrono::, <chrono>)
-SYMBOL(month_weekday_last, std::chrono::, <chrono>)
-SYMBOL(nanoseconds, std::chrono::, <chrono>)
-SYMBOL(nonexistent_local_time, std::chrono::, <chrono>)
-SYMBOL(parse, std::chrono::, <chrono>)
+SYMBOL_VERSION(get_leap_second_info, std::chrono::, <chrono>, "c++20")
+SYMBOL_VERSION(gps_clock, std::chrono::, <chrono>, "c++20")
+SYMBOL_VERSION(gps_seconds, std::chrono::, <chrono>, "c++20")
+SYMBOL_VERSION(gps_time, std::chrono::, <chrono>, "c++20")
+SYMBOL_VERSION(hh_mm_ss, std::chrono::, <chrono>, "c++20")
+SYMBOL_VERSION(high_resolution_clock, std::chrono::, <chrono>, "c++11")
+SYMBOL_VERSION(hours, std::chrono::, <chrono>, "c++11")
+SYMBOL_VERSION(is_am, std::chrono::, <chrono>, "c++20")
+SYMBOL_VERSION(is_clock, std::chrono::, <chrono>, "c++20")
+SYMBOL_VERSION(is_clock_v, std::chrono::, <chrono>, "c++20")
+SYMBOL_VERSION(is_pm, std::chrono::, <chrono>, "c++20")
+SYMBOL_VERSION(last, std::chrono::, <chrono>, "c++20")
+SYMBOL_VERSION(last_spec, std::chrono::, <chrono>, "c++20")
+SYMBOL_VERSION(leap_second, std::chrono::, <chrono>, "c++20")
+SYMBOL_VERSION(leap_second_info, std::chrono::, <chrono>, "c++20")
+SYMBOL_VERSION(local_info, std::chrono::, <chrono>, "c++20")
+SYMBOL_VERSION(local_seconds, std::chrono::, <chrono>, "c++20")
+SYMBOL_VERSION(local_t, std::chrono::, <chrono>, "c++20")
+SYMBOL_VERSION(local_time, std::chrono::, <chrono>, "c++20")
+SYMBOL_VERSION(local_time_format, std::chrono::, <chrono>, "c++20")
+SYMBOL_VERSION(locate_zone, std::chrono::, <chrono>, "c++20")
+SYMBOL_VERSION(make12, std::chrono::, <chrono>, "c++20")
+SYMBOL_VERSION(make24, std::chrono::, <chrono>, "c++20")
+SYMBOL_VERSION(microseconds, std::chrono::, <chrono>, "c++11")
+SYMBOL_VERSION(milliseconds, std::chrono::, <chrono>, "c++11")
+SYMBOL_VERSION(minutes, std::chrono::, <chrono>, "c++11")
+SYMBOL_VERSION(month, std::chrono::, <chrono>, "c++20")
+SYMBOL_VERSION(month_day, std::chrono::, <chrono>, "c++20")
+SYMBOL_VERSION(month_day_last, std::chrono::, <chrono>, "c++20")
+SYMBOL_VERSION(month_weekday, std::chrono::, <chrono>, "c++20")
+SYMBOL_VERSION(month_weekday_last, std::chrono::, <chrono>, "c++20")
+SYMBOL_VERSION(nanoseconds, std::chrono::, <chrono>, "c++11")
+SYMBOL_VERSION(nonexistent_local_time, std::chrono::, <chrono>, "c++20")
+SYMBOL_VERSION(parse, std::chrono::, <chrono>, "c++20")
SYMBOL(round, std::chrono::, <chrono>)
-SYMBOL(seconds, std::chrono::, <chrono>)
-SYMBOL(steady_clock, std::chrono::, <chrono>)
-SYMBOL(sys_days, std::chrono::, <chrono>)
-SYMBOL(sys_info, std::chrono::, <chrono>)
-SYMBOL(sys_seconds, std::chrono::, <chrono>)
-SYMBOL(sys_time, std::chrono::, <chrono>)
-SYMBOL(system_clock, std::chrono::, <chrono>)
-SYMBOL(tai_clock, std::chrono::, <chrono>)
-SYMBOL(tai_seconds, std::chrono::, <chrono>)
-SYMBOL(tai_time, std::chrono::, <chrono>)
-SYMBOL(time_point, std::chrono::, <chrono>)
-SYMBOL(time_point_cast, std::chrono::, <chrono>)
-SYMBOL(time_zone, std::chrono::, <chrono>)
-SYMBOL(time_zone_link, std::chrono::, <chrono>)
-SYMBOL(treat_as_floating_point, std::chrono::, <chrono>)
-SYMBOL(treat_as_floating_point_v, std::chrono::, <chrono>)
-SYMBOL(tzdb, std::chrono::, <chrono>)
-SYMBOL(tzdb_list, std::chrono::, <chrono>)
-SYMBOL(utc_clock, std::chrono::, <chrono>)
-SYMBOL(utc_seconds, std::chrono::, <chrono>)
-SYMBOL(utc_time, std::chrono::, <chrono>)
-SYMBOL(weekday, std::chrono::, <chrono>)
-SYMBOL(weekday_indexed, std::chrono::, <chrono>)
-SYMBOL(weekday_last, std::chrono::, <chrono>)
-SYMBOL(year, std::chrono::, <chrono>)
-SYMBOL(year_month, std::chrono::, <chrono>)
-SYMBOL(year_month_day, std::chrono::, <chrono>)
-SYMBOL(year_month_day_last, std::chrono::, <chrono>)
-SYMBOL(year_month_weekday, std::chrono::, <chrono>)
-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_VERSION(seconds, std::chrono::, <chrono>, "c++11")
+SYMBOL_VERSION(steady_clock, std::chrono::, <chrono>, "c++11")
+SYMBOL_VERSION(sys_days, std::chrono::, <chrono>, "c++20")
+SYMBOL_VERSION(sys_info, std::chrono::, <chrono>, "c++20")
+SYMBOL_VERSION(sys_seconds, std::chrono::, <chrono>, "c++20")
+SYMBOL_VERSION(sys_time, std::chrono::, <chrono>, "c++20")
+SYMBOL_VERSION(system_clock, std::chrono::, <chrono>, "c++11")
+SYMBOL_VERSION(tai_clock, std::chrono::, <chrono>, "c++20")
+SYMBOL_VERSION(tai_seconds, std::chrono::, <chrono>, "c++20")
+SYMBOL_VERSION(tai_time, std::chrono::, <chrono>, "c++20")
+SYMBOL_VERSION(time_point, std::chrono::, <chrono>, "c++11")
+SYMBOL_VERSION(time_point_cast, std::chrono::, <chrono>, "c++11")
+SYMBOL_VERSION(time_zone, std::chrono::, <chrono>, "c++20")
+SYMBOL_VERSION(time_zone_link, std::chrono::, <chrono>, "c++20")
+SYMBOL_VERSION(treat_as_floating_point, std::chrono::, <chrono>, "c++11")
+SYMBOL_VERSION(treat_as_floating_point_v, std::chrono::, <chrono>, "c++17")
+SYMBOL_VERSION(tzdb, std::chrono::, <chrono>, "c++20")
+SYMBOL_VERSION(tzdb_list, std::chrono::, <chrono>, "c++20")
+SYMBOL_VERSION(utc_clock, std::chrono::, <chrono>, "c++20")
+SYMBOL_VERSION(utc_seconds, std::chrono::, <chrono>, "c++20")
+SYMBOL_VERSION(utc_time, std::chrono::, <chrono>, "c++20")
+SYMBOL_VERSION(weekday, std::chrono::, <chrono>, "c++20")
+SYMBOL_VERSION(weekday_indexed, std::chrono::, <chrono>, "c++20")
+SYMBOL_VERSION(weekday_last, std::chrono::, <chrono>, "c++20")
+SYMBOL_VERSION(year, std::chrono::, <chrono>, "c++20")
+SYMBOL_VERSION(year_month, std::chrono::, <chrono>, "c++20")
+SYMBOL_VERSION(year_month_day, std::chrono::, <chrono>, "c++20")
+SYMBOL_VERSION(year_month_day_last, std::chrono::, <chrono>, "c++20")
+SYMBOL_VERSION(year_month_weekday, std::chrono::, <chrono>, "c++20")
+SYMBOL_VERSION(year_month_weekday_last, std::chrono::, <chrono>, "c++20")
+SYMBOL_VERSION(zoned_seconds, std::chrono::, <chrono>, "c++20")
+SYMBOL_VERSION(zoned_time, std::chrono::, <chrono>, "c++20")
+SYMBOL_VERSION(zoned_traits, std::chrono::, <chrono>, "c++20")
+SYMBOL_VERSION(par, std::execution::, <execution>, "c++17")
+SYMBOL_VERSION(par_unseq, std::execution::, <execution>, "c++17")
+SYMBOL_VERSION(parallel_policy, std::execution::, <execution>, "c++17")
+SYMBOL_VERSION(parallel_unsequenced_policy, std::execution::, <execution>, "c++17")
+SYMBOL_VERSION(seq, std::execution::, <execution>, "c++17")
+SYMBOL_VERSION(sequenced_policy, std::execution::, <execution>, "c++17")
+SYMBOL_VERSION(unseq, std::execution::, <execution>, "c++20")
+SYMBOL_VERSION(unsequenced_policy, std::execution::, <execution>, "c++20")
+SYMBOL_VERSION(absolute, std::filesystem::, <filesystem>, "c++17")
SYMBOL(begin, std::filesystem::, <filesystem>)
-SYMBOL(canonical, std::filesystem::, <filesystem>)
-SYMBOL(copy, std::filesystem::, <filesystem>)
-SYMBOL(copy_file, std::filesystem::, <filesystem>)
-SYMBOL(copy_options, std::filesystem::, <filesystem>)
-SYMBOL(copy_symlink, std::filesystem::, <filesystem>)
-SYMBOL(create_directories, std::filesystem::, <filesystem>)
-SYMBOL(create_directory, std::filesystem::, <filesystem>)
-SYMBOL(create_directory_symlink, std::filesystem::, <filesystem>)
-SYMBOL(create_hard_link, std::filesystem::, <filesystem>)
-SYMBOL(create_symlink, std::filesystem::, <filesystem>)
-SYMBOL(current_path, std::filesystem::, <filesystem>)
-SYMBOL(directory_entry, std::filesystem::, <filesystem>)
-SYMBOL(directory_iterator, std::filesystem::, <filesystem>)
-SYMBOL(directory_options, std::filesystem::, <filesystem>)
+SYMBOL_VERSION(canonical, std::filesystem::, <filesystem>, "c++17")
+SYMBOL_VERSION(copy, std::filesystem::, <filesystem>, "c++17")
+SYMBOL_VERSION(copy_file, std::filesystem::, <filesystem>, "c++17")
+SYMBOL_VERSION(copy_options, std::filesystem::, <filesystem>, "c++17")
+SYMBOL_VERSION(copy_symlink, std::filesystem::, <filesystem>, "c++17")
+SYMBOL_VERSION(create_directories, std::filesystem::, <filesystem>, "c++17")
+SYMBOL_VERSION(create_directory, std::filesystem::, <filesystem>, "c++17")
+SYMBOL_VERSION(create_directory_symlink, std::filesystem::, <filesystem>, "c++17")
+SYMBOL_VERSION(create_hard_link, std::filesystem::, <filesystem>, "c++17")
+SYMBOL_VERSION(create_symlink, std::filesystem::, <filesystem>, "c++17")
+SYMBOL_VERSION(current_path, std::filesystem::, <filesystem>, "c++17")
+SYMBOL_VERSION(directory_entry, std::filesystem::, <filesystem>, "c++17")
+SYMBOL_VERSION(directory_iterator, std::filesystem::, <filesystem>, "c++17")
+SYMBOL_VERSION(directory_options, std::filesystem::, <filesystem>, "c++17")
SYMBOL(end, std::filesystem::, <filesystem>)
-SYMBOL(equivalent, std::filesystem::, <filesystem>)
-SYMBOL(exists, std::filesystem::, <filesystem>)
-SYMBOL(file_size, std::filesystem::, <filesystem>)
-SYMBOL(file_status, std::filesystem::, <filesystem>)
-SYMBOL(file_time_type, std::filesystem::, <filesystem>)
-SYMBOL(file_type, std::filesystem::, <filesystem>)
-SYMBOL(filesystem_error, std::filesystem::, <filesystem>)
-SYMBOL(hard_link_count, std::filesystem::, <filesystem>)
-SYMBOL(hash_value, std::filesystem::, <filesystem>)
-SYMBOL(is_block_file, std::filesystem::, <filesystem>)
-SYMBOL(is_character_file, std::filesystem::, <filesystem>)
-SYMBOL(is_directory, std::filesystem::, <filesystem>)
-SYMBOL(is_empty, std::filesystem::, <filesystem>)
-SYMBOL(is_fifo, std::filesystem::, <filesystem>)
-SYMBOL(is_other, std::filesystem::, <filesystem>)
-SYMBOL(is_regular_file, std::filesystem::, <filesystem>)
-SYMBOL(is_socket, std::filesystem::, <filesystem>)
-SYMBOL(is_symlink, std::filesystem::, <filesystem>)
-SYMBOL(last_write_time, std::filesystem::, <filesystem>)
-SYMBOL(path, std::filesystem::, <filesystem>)
-SYMBOL(perm_options, std::filesystem::, <filesystem>)
-SYMBOL(permissions, std::filesystem::, <filesystem>)
-SYMBOL(perms, std::filesystem::, <filesystem>)
-SYMBOL(proximate, std::filesystem::, <filesystem>)
-SYMBOL(read_symlink, std::filesystem::, <filesystem>)
-SYMBOL(recursive_directory_iterator, std::filesystem::, <filesystem>)
-SYMBOL(relative, std::filesystem::, <filesystem>)
-SYMBOL(remove, std::filesystem::, <filesystem>)
-SYMBOL(remove_all, std::filesystem::, <filesystem>)
-SYMBOL(rename, std::filesystem::, <filesystem>)
-SYMBOL(resize_file, std::filesystem::, <filesystem>)
-SYMBOL(space, std::filesystem::, <filesystem>)
-SYMBOL(space_info, std::filesystem::, <filesystem>)
-SYMBOL(status, std::filesystem::, <filesystem>)
-SYMBOL(status_known, std::filesystem::, <filesystem>)
-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>)
-SYMBOL(forward_list, std::pmr::, <forward_list>)
-SYMBOL(get_default_resource, std::pmr::, <memory_resource>)
-SYMBOL(list, std::pmr::, <list>)
-SYMBOL(map, std::pmr::, <map>)
-SYMBOL(match_results, std::pmr::, <regex>)
-SYMBOL(memory_resource, std::pmr::, <memory_resource>)
-SYMBOL(monotonic_buffer_resource, std::pmr::, <memory_resource>)
-SYMBOL(multimap, std::pmr::, <map>)
-SYMBOL(multiset, std::pmr::, <set>)
-SYMBOL(new_delete_resource, std::pmr::, <memory_resource>)
-SYMBOL(null_memory_resource, std::pmr::, <memory_resource>)
-SYMBOL(polymorphic_allocator, std::pmr::, <memory_resource>)
-SYMBOL(pool_options, std::pmr::, <memory_resource>)
-SYMBOL(set, std::pmr::, <set>)
-SYMBOL(set_default_resource, std::pmr::, <memory_resource>)
-SYMBOL(smatch, std::pmr::, <regex>)
-SYMBOL(stacktrace, std::pmr::, <stacktrace>)
-SYMBOL(string, std::pmr::, <string>)
-SYMBOL(synchronized_pool_resource, std::pmr::, <memory_resource>)
-SYMBOL(u16string, std::pmr::, <string>)
-SYMBOL(u32string, std::pmr::, <string>)
-SYMBOL(u8string, std::pmr::, <string>)
-SYMBOL(unordered_map, std::pmr::, <unordered_map>)
-SYMBOL(unordered_multimap, std::pmr::, <unordered_map>)
-SYMBOL(unordered_multiset, std::pmr::, <unordered_set>)
-SYMBOL(unordered_set, std::pmr::, <unordered_set>)
-SYMBOL(unsynchronized_pool_resource, std::pmr::, <memory_resource>)
-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(adjacent_transform_view, std::ranges::, <ranges>)
-SYMBOL(adjacent_view, std::ranges::, <ranges>)
-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(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(cartesian_product_view, std::ranges::, <ranges>)
-SYMBOL(chunk_by_view, std::ranges::, <ranges>)
-SYMBOL(chunk_view, std::ranges::, <ranges>)
-SYMBOL(clamp, std::ranges::, <algorithm>)
-SYMBOL(common_range, std::ranges::, <ranges>)
-SYMBOL(common_view, std::ranges::, <ranges>)
-SYMBOL(concat_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(dangling, 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_of, std::ranges::, <ranges>)
-SYMBOL(elements_view, std::ranges::, <ranges>)
-SYMBOL(empty_view, std::ranges::, <ranges>)
-SYMBOL(enable_borrowed_range, std::ranges::, <ranges>)
-SYMBOL(enable_view, std::ranges::, <ranges>)
-SYMBOL(ends_with, std::ranges::, <algorithm>)
-SYMBOL(enumerate_view, std::ranges::, <ranges>)
-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(fold_left, std::ranges::, <algorithm>)
-SYMBOL(fold_left_first, std::ranges::, <algorithm>)
-SYMBOL(fold_left_first_with_iter, std::ranges::, <algorithm>)
-SYMBOL(fold_left_with_iter, std::ranges::, <algorithm>)
-SYMBOL(fold_right, std::ranges::, <algorithm>)
-SYMBOL(fold_right_last, 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_VERSION(equivalent, std::filesystem::, <filesystem>, "c++17")
+SYMBOL_VERSION(exists, std::filesystem::, <filesystem>, "c++17")
+SYMBOL_VERSION(file_size, std::filesystem::, <filesystem>, "c++17")
+SYMBOL_VERSION(file_status, std::filesystem::, <filesystem>, "c++17")
+SYMBOL_VERSION(file_time_type, std::filesystem::, <filesystem>, "c++17")
+SYMBOL_VERSION(file_type, std::filesystem::, <filesystem>, "c++17")
+SYMBOL_VERSION(filesystem_error, std::filesystem::, <filesystem>, "c++17")
+SYMBOL_VERSION(hard_link_count, std::filesystem::, <filesystem>, "c++17")
+SYMBOL_VERSION(hash_value, std::filesystem::, <filesystem>, "c++17")
+SYMBOL_VERSION(is_block_file, std::filesystem::, <filesystem>, "c++17")
+SYMBOL_VERSION(is_character_file, std::filesystem::, <filesystem>, "c++17")
+SYMBOL_VERSION(is_directory, std::filesystem::, <filesystem>, "c++17")
+SYMBOL_VERSION(is_empty, std::filesystem::, <filesystem>, "c++17")
+SYMBOL_VERSION(is_fifo, std::filesystem::, <filesystem>, "c++17")
+SYMBOL_VERSION(is_other, std::filesystem::, <filesystem>, "c++17")
+SYMBOL_VERSION(is_regular_file, std::filesystem::, <filesystem>, "c++17")
+SYMBOL_VERSION(is_socket, std::filesystem::, <filesystem>, "c++17")
+SYMBOL_VERSION(is_symlink, std::filesystem::, <filesystem>, "c++17")
+SYMBOL_VERSION(last_write_time, std::filesystem::, <filesystem>, "c++17")
+SYMBOL_VERSION(path, std::filesystem::, <filesystem>, "c++17")
+SYMBOL_VERSION(perm_options, std::filesystem::, <filesystem>, "c++17")
+SYMBOL_VERSION(permissions, std::filesystem::, <filesystem>, "c++17")
+SYMBOL_VERSION(perms, std::filesystem::, <filesystem>, "c++17")
+SYMBOL_VERSION(proximate, std::filesystem::, <filesystem>, "c++17")
+SYMBOL_VERSION(read_symlink, std::filesystem::, <filesystem>, "c++17")
+SYMBOL_VERSION(recursive_directory_iterator, std::filesystem::, <filesystem>, "c++17")
+SYMBOL_VERSION(relative, std::filesystem::, <filesystem>, "c++17")
+SYMBOL_VERSION(remove, std::filesystem::, <filesystem>, "c++17")
+SYMBOL_VERSION(remove_all, std::filesystem::, <filesystem>, "c++17")
+SYMBOL_VERSION(rename, std::filesystem::, <filesystem>, "c++17")
+SYMBOL_VERSION(resize_file, std::filesystem::, <filesystem>, "c++17")
+SYMBOL_VERSION(space, std::filesystem::, <filesystem>, "c++17")
+SYMBOL_VERSION(space_info, std::filesystem::, <filesystem>, "c++17")
+SYMBOL_VERSION(status, std::filesystem::, <filesystem>, "c++17")
+SYMBOL_VERSION(status_known, std::filesystem::, <filesystem>, "c++17")
+SYMBOL_VERSION(symlink_status, std::filesystem::, <filesystem>, "c++17")
+SYMBOL_VERSION(temp_directory_path, std::filesystem::, <filesystem>, "c++17")
+SYMBOL_VERSION(u8path, std::filesystem::, <filesystem>, "c++17")
+SYMBOL_VERSION(weakly_canonical, std::filesystem::, <filesystem>, "c++17")
+SYMBOL_VERSION(e, std::numbers::, <numbers>, "c++20")
+SYMBOL_VERSION(e_v, std::numbers::, <numbers>, "c++20")
+SYMBOL_VERSION(egamma, std::numbers::, <numbers>, "c++20")
+SYMBOL_VERSION(egamma_v, std::numbers::, <numbers>, "c++20")
+SYMBOL_VERSION(inv_pi, std::numbers::, <numbers>, "c++20")
+SYMBOL_VERSION(inv_pi_v, std::numbers::, <numbers>, "c++20")
+SYMBOL_VERSION(inv_sqrt3, std::numbers::, <numbers>, "c++20")
+SYMBOL_VERSION(inv_sqrt3_v, std::numbers::, <numbers>, "c++20")
+SYMBOL_VERSION(inv_sqrtpi, std::numbers::, <numbers>, "c++20")
+SYMBOL_VERSION(inv_sqrtpi_v, std::numbers::, <numbers>, "c++20")
+SYMBOL_VERSION(ln10, std::numbers::, <numbers>, "c++20")
+SYMBOL_VERSION(ln10_v, std::numbers::, <numbers>, "c++20")
+SYMBOL_VERSION(ln2, std::numbers::, <numbers>, "c++20")
+SYMBOL_VERSION(ln2_v, std::numbers::, <numbers>, "c++20")
+SYMBOL_VERSION(log10e, std::numbers::, <numbers>, "c++20")
+SYMBOL_VERSION(log10e_v, std::numbers::, <numbers>, "c++20")
+SYMBOL_VERSION(log2e, std::numbers::, <numbers>, "c++20")
+SYMBOL_VERSION(log2e_v, std::numbers::, <numbers>, "c++20")
+SYMBOL_VERSION(phi, std::numbers::, <numbers>, "c++20")
+SYMBOL_VERSION(phi_v, std::numbers::, <numbers>, "c++20")
+SYMBOL_VERSION(pi, std::numbers::, <numbers>, "c++20")
+SYMBOL_VERSION(pi_v, std::numbers::, <numbers>, "c++20")
+SYMBOL_VERSION(sqrt2, std::numbers::, <numbers>, "c++20")
+SYMBOL_VERSION(sqrt2_v, std::numbers::, <numbers>, "c++20")
+SYMBOL_VERSION(sqrt3, std::numbers::, <numbers>, "c++20")
+SYMBOL_VERSION(sqrt3_v, std::numbers::, <numbers>, "c++20")
+SYMBOL_VERSION(basic_string, std::pmr::, <string>, "c++17")
+SYMBOL_VERSION(cmatch, std::pmr::, <regex>, "c++17")
+SYMBOL_VERSION(deque, std::pmr::, <deque>, "c++17")
+SYMBOL_VERSION(forward_list, std::pmr::, <forward_list>, "c++17")
+SYMBOL_VERSION(get_default_resource, std::pmr::, <memory_resource>, "c++17")
+SYMBOL_VERSION(list, std::pmr::, <list>, "c++17")
+SYMBOL_VERSION(map, std::pmr::, <map>, "c++17")
+SYMBOL_VERSION(match_results, std::pmr::, <regex>, "c++17")
+SYMBOL_VERSION(memory_resource, std::pmr::, <memory_resource>, "c++17")
+SYMBOL_VERSION(monotonic_buffer_resource, std::pmr::, <memory_resource>, "c++17")
+SYMBOL_VERSION(multimap, std::pmr::, <map>, "c++17")
+SYMBOL_VERSION(multiset, std::pmr::, <set>, "c++17")
+SYMBOL_VERSION(new_delete_resource, std::pmr::, <memory_resource>, "c++17")
+SYMBOL_VERSION(null_memory_resource, std::pmr::, <memory_resource>, "c++17")
+SYMBOL_VERSION(polymorphic_allocator, std::pmr::, <memory_resource>, "c++17")
+SYMBOL_VERSION(pool_options, std::pmr::, <memory_resource>, "c++17")
+SYMBOL_VERSION(set, std::pmr::, <set>, "c++17")
+SYMBOL_VERSION(set_default_resource, std::pmr::, <memory_resource>, "c++17")
+SYMBOL_VERSION(smatch, std::pmr::, <regex>, "c++17")
+SYMBOL_VERSION(stacktrace, std::pmr::, <stacktrace>, "c++23")
+SYMBOL_VERSION(string, std::pmr::, <string>, "c++17")
+SYMBOL_VERSION(synchronized_pool_resource, std::pmr::, <memory_resource>, "c++17")
+SYMBOL_VERSION(u16string, std::pmr::, <string>, "c++17")
+SYMBOL_VERSION(u32string, std::pmr::, <string>, "c++17")
+SYMBOL_VERSION(u8string, std::pmr::, <string>, "c++17")
+SYMBOL_VERSION(unordered_map, std::pmr::, <unordered_map>, "c++17")
+SYMBOL_VERSION(unordered_multimap, std::pmr::, <unordered_map>, "c++17")
+SYMBOL_VERSION(unordered_multiset, std::pmr::, <unordered_set>, "c++17")
+SYMBOL_VERSION(unordered_set, std::pmr::, <unordered_set>, "c++17")
+SYMBOL_VERSION(unsynchronized_pool_resource, std::pmr::, <memory_resource>, "c++17")
+SYMBOL_VERSION(vector, std::pmr::, <vector>, "c++17")
+SYMBOL_VERSION(wcmatch, std::pmr::, <regex>, "c++17")
+SYMBOL_VERSION(wsmatch, std::pmr::, <regex>, "c++17")
+SYMBOL_VERSION(wstring, std::pmr::, <string>, "c++17")
+SYMBOL_VERSION(adjacent_find, std::ranges::, <algorithm>, "c++23")
+SYMBOL_VERSION(adjacent_transform_view, std::ranges::, <ranges>, "c++23")
+SYMBOL_VERSION(adjacent_view, std::ranges::, <ranges>, "c++23")
+SYMBOL_VERSION(advance, std::ranges::, <iterator>, "c++20")
+SYMBOL_VERSION(all_of, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(any_of, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(as_const_view, std::ranges::, <ranges>, "c++23")
+SYMBOL_VERSION(as_rvalue_view, std::ranges::, <ranges>, "c++23")
+SYMBOL_VERSION(basic_istream_view, std::ranges::, <ranges>, "c++20")
+SYMBOL_VERSION(bidirectional_range, std::ranges::, <ranges>, "c++20")
+SYMBOL_VERSION(binary_search, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(binary_transform_result, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(borrowed_iterator_t, std::ranges::, <ranges>, "c++20")
+SYMBOL_VERSION(borrowed_range, std::ranges::, <ranges>, "c++20")
+SYMBOL_VERSION(borrowed_subrange_t, std::ranges::, <ranges>, "c++20")
+SYMBOL_VERSION(cartesian_product_view, std::ranges::, <ranges>, "c++23")
+SYMBOL_VERSION(chunk_by_view, std::ranges::, <ranges>, "c++23")
+SYMBOL_VERSION(chunk_view, std::ranges::, <ranges>, "c++23")
+SYMBOL_VERSION(clamp, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(common_range, std::ranges::, <ranges>, "c++20")
+SYMBOL_VERSION(common_view, std::ranges::, <ranges>, "c++20")
+SYMBOL_VERSION(concat_view, std::ranges::, <ranges>, "c++26")
+SYMBOL_VERSION(const_iterator_t, std::ranges::, <ranges>, "c++23")
+SYMBOL_VERSION(constant_range, std::ranges::, <ranges>, "c++23")
+SYMBOL_VERSION(construct_at, std::ranges::, <memory>, "c++20")
+SYMBOL_VERSION(contains, std::ranges::, <algorithm>, "c++23")
+SYMBOL_VERSION(contains_subrange, std::ranges::, <algorithm>, "c++23")
+SYMBOL_VERSION(contiguous_range, std::ranges::, <ranges>, "c++20")
+SYMBOL_VERSION(copy, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(copy_backward, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(copy_backward_result, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(copy_if, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(copy_if_result, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(copy_n, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(copy_n_result, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(copy_result, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(count, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(count_if, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(dangling, std::ranges::, <ranges>, "c++20")
+SYMBOL_VERSION(destroy, std::ranges::, <memory>, "c++20")
+SYMBOL_VERSION(destroy_at, std::ranges::, <memory>, "c++20")
+SYMBOL_VERSION(destroy_n, std::ranges::, <memory>, "c++20")
+SYMBOL_VERSION(disable_sized_range, std::ranges::, <ranges>, "c++20")
+SYMBOL_VERSION(distance, std::ranges::, <iterator>, "c++20")
+SYMBOL_VERSION(drop_view, std::ranges::, <ranges>, "c++20")
+SYMBOL_VERSION(drop_while_view, std::ranges::, <ranges>, "c++20")
+SYMBOL_VERSION(elements_of, std::ranges::, <ranges>, "c++23")
+SYMBOL_VERSION(elements_view, std::ranges::, <ranges>, "c++20")
+SYMBOL_VERSION(empty_view, std::ranges::, <ranges>, "c++20")
+SYMBOL_VERSION(enable_borrowed_range, std::ranges::, <ranges>, "c++20")
+SYMBOL_VERSION(enable_view, std::ranges::, <ranges>, "c++20")
+SYMBOL_VERSION(ends_with, std::ranges::, <algorithm>, "c++23")
+SYMBOL_VERSION(enumerate_view, std::ranges::, <ranges>, "c++23")
+SYMBOL_VERSION(equal, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(equal_range, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(equal_to, std::ranges::, <functional>, "c++20")
+SYMBOL_VERSION(fill, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(fill_n, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(filter_view, std::ranges::, <ranges>, "c++20")
+SYMBOL_VERSION(find, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(find_end, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(find_first_of, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(find_if, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(find_if_not, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(find_last, std::ranges::, <algorithm>, "c++23")
+SYMBOL_VERSION(find_last_if, std::ranges::, <algorithm>, "c++23")
+SYMBOL_VERSION(find_last_if_not, std::ranges::, <algorithm>, "c++23")
+SYMBOL_VERSION(fold_left, std::ranges::, <algorithm>, "c++23")
+SYMBOL_VERSION(fold_left_first, std::ranges::, <algorithm>, "c++23")
+SYMBOL_VERSION(fold_left_first_with_iter, std::ranges::, <algorithm>, "c++23")
+SYMBOL_VERSION(fold_left_with_iter, std::ranges::, <algorithm>, "c++23")
+SYMBOL_VERSION(fold_right, std::ranges::, <algorithm>, "c++23")
+SYMBOL_VERSION(fold_right_last, std::ranges::, <algorithm>, "c++23")
+SYMBOL_VERSION(for_each, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(for_each_n, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(for_each_n_result, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(for_each_result, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(forward_range, std::ranges::, <ranges>, "c++20")
+SYMBOL_VERSION(generate, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(generate_n, std::ranges::, <algorithm>, "c++20")
SYMBOL(get, std::ranges::, <ranges>)
-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_adaptor_closure, std::ranges::, <ranges>)
-SYMBOL(range_const_reference_t, std::ranges::, <ranges>)
-SYMBOL(range_difference_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(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(repeat_view, 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_difference, std::ranges::, <algorithm>)
-SYMBOL(set_difference_result, std::ranges::, <algorithm>)
-SYMBOL(set_intersection, std::ranges::, <algorithm>)
-SYMBOL(set_intersection_result, std::ranges::, <algorithm>)
-SYMBOL(set_symmetric_difference, std::ranges::, <algorithm>)
-SYMBOL(set_symmetric_difference_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(sized_range, std::ranges::, <ranges>)
-SYMBOL(slide_view, std::ranges::, <ranges>)
-SYMBOL(sort, std::ranges::, <algorithm>)
-SYMBOL(sort_heap, std::ranges::, <algorithm>)
-SYMBOL(split_view, std::ranges::, <ranges>)
-SYMBOL(stable_partition, std::ranges::, <algorithm>)
-SYMBOL(stable_sort, std::ranges::, <algorithm>)
-SYMBOL(starts_with, std::ranges::, <algorithm>)
-SYMBOL(stride_view, std::ranges::, <ranges>)
-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(adjacent, std::ranges::views::, <ranges>)
-SYMBOL(adjacent_transform, std::ranges::views::, <ranges>)
-SYMBOL(all, std::ranges::views::, <ranges>)
-SYMBOL(all_t, std::ranges::views::, <ranges>)
-SYMBOL(as_const, std::ranges::views::, <ranges>)
-SYMBOL(as_rvalue, std::ranges::views::, <ranges>)
-SYMBOL(cartesian_product, std::ranges::views::, <ranges>)
-SYMBOL(chunk, std::ranges::views::, <ranges>)
-SYMBOL(chunk_by, std::ranges::views::, <ranges>)
-SYMBOL(common, std::ranges::views::, <ranges>)
-SYMBOL(concat, std::ranges::views::, <ranges>)
-SYMBOL(counted, std::ranges::views::, <ranges>)
-SYMBOL(drop, std::ranges::views::, <ranges>)
-SYMBOL(drop_while, std::ranges::views::, <ranges>)
-SYMBOL(elements, std::ranges::views::, <ranges>)
-SYMBOL(empty, std::ranges::views::, <ranges>)
-SYMBOL(enumerate, std::ranges::views::, <ranges>)
-SYMBOL(filter, std::ranges::views::, <ranges>)
-SYMBOL(iota, std::ranges::views::, <ranges>)
-SYMBOL(istream, std::ranges::views::, <ranges>)
-SYMBOL(istream, std::ranges::views::, <iosfwd>)
-SYMBOL(join, std::ranges::views::, <ranges>)
-SYMBOL(join_with, std::ranges::views::, <ranges>)
-SYMBOL(keys, std::ranges::views::, <ranges>)
-SYMBOL(lazy_split, std::ranges::views::, <ranges>)
-SYMBOL(pairwise, std::ranges::views::, <ranges>)
-SYMBOL(pairwise_transform, std::ranges::views::, <ranges>)
-SYMBOL(repeat, std::ranges::views::, <ranges>)
-SYMBOL(reverse, std::ranges::views::, <ranges>)
-SYMBOL(single, std::ranges::views::, <ranges>)
-SYMBOL(slide, std::ranges::views::, <ranges>)
-SYMBOL(split, std::ranges::views::, <ranges>)
-SYMBOL(stride, std::ranges::views::, <ranges>)
-SYMBOL(take, std::ranges::views::, <ranges>)
-SYMBOL(take_while, std::ranges::views::, <ranges>)
-SYMBOL(transform, std::ranges::views::, <ranges>)
-SYMBOL(values, std::ranges::views::, <ranges>)
-SYMBOL(zip, std::ranges::views::, <ranges>)
-SYMBOL(zip_transform, std::ranges::views::, <ranges>)
-SYMBOL(ECMAScript, std::regex_constants::, <regex>)
-SYMBOL(awk, std::regex_constants::, <regex>)
-SYMBOL(basic, std::regex_constants::, <regex>)
-SYMBOL(collate, std::regex_constants::, <regex>)
-SYMBOL(egrep, std::regex_constants::, <regex>)
-SYMBOL(error_backref, std::regex_constants::, <regex>)
-SYMBOL(error_badbrace, std::regex_constants::, <regex>)
-SYMBOL(error_badrepeat, std::regex_constants::, <regex>)
-SYMBOL(error_brace, std::regex_constants::, <regex>)
-SYMBOL(error_brack, std::regex_constants::, <regex>)
-SYMBOL(error_collate, std::regex_constants::, <regex>)
-SYMBOL(error_complexity, std::regex_constants::, <regex>)
-SYMBOL(error_ctype, std::regex_constants::, <regex>)
-SYMBOL(error_escape, std::regex_constants::, <regex>)
-SYMBOL(error_paren, std::regex_constants::, <regex>)
-SYMBOL(error_range, std::regex_constants::, <regex>)
-SYMBOL(error_space, std::regex_constants::, <regex>)
-SYMBOL(error_stack, std::regex_constants::, <regex>)
-SYMBOL(error_type, std::regex_constants::, <regex>)
-SYMBOL(extended, std::regex_constants::, <regex>)
-SYMBOL(format_default, std::regex_constants::, <regex>)
-SYMBOL(format_first_only, std::regex_constants::, <regex>)
-SYMBOL(format_no_copy, std::regex_constants::, <regex>)
-SYMBOL(format_sed, std::regex_constants::, <regex>)
-SYMBOL(grep, std::regex_constants::, <regex>)
-SYMBOL(icase, std::regex_constants::, <regex>)
-SYMBOL(match_any, std::regex_constants::, <regex>)
-SYMBOL(match_continuous, std::regex_constants::, <regex>)
-SYMBOL(match_default, std::regex_constants::, <regex>)
-SYMBOL(match_flag_type, std::regex_constants::, <regex>)
-SYMBOL(match_not_bol, std::regex_constants::, <regex>)
-SYMBOL(match_not_bow, std::regex_constants::, <regex>)
-SYMBOL(match_not_eol, std::regex_constants::, <regex>)
-SYMBOL(match_not_eow, std::regex_constants::, <regex>)
-SYMBOL(match_not_null, std::regex_constants::, <regex>)
-SYMBOL(match_prev_avail, std::regex_constants::, <regex>)
-SYMBOL(multiline, std::regex_constants::, <regex>)
-SYMBOL(nosubs, std::regex_constants::, <regex>)
-SYMBOL(optimize, std::regex_constants::, <regex>)
-SYMBOL(syntax_option_type, std::regex_constants::, <regex>)
-SYMBOL(get_id, std::this_thread::, <thread>)
-SYMBOL(sleep_for, std::this_thread::, <thread>)
-SYMBOL(sleep_until, std::this_thread::, <thread>)
-SYMBOL(yield, std::this_thread::, <thread>)
-SYMBOL(adjacent, std::views::, <ranges>)
-SYMBOL(adjacent_transform, std::views::, <ranges>)
-SYMBOL(all, std::views::, <ranges>)
-SYMBOL(all_t, std::views::, <ranges>)
-SYMBOL(as_const, std::views::, <ranges>)
-SYMBOL(as_rvalue, std::views::, <ranges>)
-SYMBOL(cartesian_product, std::views::, <ranges>)
-SYMBOL(chunk, std::views::, <ranges>)
-SYMBOL(chunk_by, std::views::, <ranges>)
-SYMBOL(common, std::views::, <ranges>)
-SYMBOL(concat, std::views::, <ranges>)
-SYMBOL(counted, std::views::, <ranges>)
-SYMBOL(drop, std::views::, <ranges>)
-SYMBOL(drop_while, std::views::, <ranges>)
-SYMBOL(elements, std::views::, <ranges>)
-SYMBOL(empty, std::views::, <ranges>)
-SYMBOL(enumerate, std::views::, <ranges>)
-SYMBOL(filter, std::views::, <ranges>)
-SYMBOL(iota, std::views::, <ranges>)
-SYMBOL(istream, std::views::, <ranges>)
-SYMBOL(istream, std::views::, <iosfwd>)
-SYMBOL(join, std::views::, <ranges>)
-SYMBOL(join_with, std::views::, <ranges>)
-SYMBOL(keys, std::views::, <ranges>)
-SYMBOL(lazy_split, std::views::, <ranges>)
-SYMBOL(pairwise, std::views::, <ranges>)
-SYMBOL(pairwise_transform, std::views::, <ranges>)
-SYMBOL(repeat, std::views::, <ranges>)
-SYMBOL(reverse, std::views::, <ranges>)
-SYMBOL(single, std::views::, <ranges>)
-SYMBOL(slide, std::views::, <ranges>)
-SYMBOL(split, std::views::, <ranges>)
-SYMBOL(stride, std::views::, <ranges>)
-SYMBOL(take, std::views::, <ranges>)
-SYMBOL(take_while, std::views::, <ranges>)
-SYMBOL(transform, std::views::, <ranges>)
-SYMBOL(values, std::views::, <ranges>)
-SYMBOL(zip, std::views::, <ranges>)
-SYMBOL(zip_transform, std::views::, <ranges>)
+SYMBOL_VERSION(greater, std::ranges::, <functional>, "c++20")
+SYMBOL_VERSION(greater_equal, std::ranges::, <functional>, "c++20")
+SYMBOL_VERSION(in_found_result, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(in_fun_result, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(in_in_out_result, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(in_in_result, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(in_out_out_result, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(in_out_result, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(in_value_result, std::ranges::, <algorithm>, "c++23")
+SYMBOL_VERSION(includes, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(inplace_merge, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(input_range, std::ranges::, <ranges>, "c++20")
+SYMBOL_VERSION(iota, std::ranges::, <numeric>, "c++23")
+SYMBOL_VERSION(iota_result, std::ranges::, <numeric>, "c++23")
+SYMBOL_VERSION(iota_view, std::ranges::, <ranges>, "c++20")
+SYMBOL_VERSION(is_heap, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(is_heap_until, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(is_partitioned, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(is_permutation, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(is_sorted, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(is_sorted_until, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(istream_view, std::ranges::, <ranges>, "c++20")
+SYMBOL_VERSION(iter_move, std::ranges::, <iterator>, "c++20")
+SYMBOL_VERSION(iter_swap, std::ranges::, <iterator>, "c++20")
+SYMBOL_VERSION(iterator_t, std::ranges::, <ranges>, "c++20")
+SYMBOL_VERSION(join_view, std::ranges::, <ranges>, "c++20")
+SYMBOL_VERSION(join_with_view, std::ranges::, <ranges>, "c++23")
+SYMBOL_VERSION(keys_view, std::ranges::, <ranges>, "c++20")
+SYMBOL_VERSION(lazy_split_view, std::ranges::, <ranges>, "c++20")
+SYMBOL_VERSION(less, std::ranges::, <functional>, "c++20")
+SYMBOL_VERSION(less_equal, std::ranges::, <functional>, "c++20")
+SYMBOL_VERSION(lexicographical_compare, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(lower_bound, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(make_heap, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(max, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(max_element, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(merge, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(merge_result, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(min, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(min_element, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(min_max_result, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(minmax, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(minmax_element, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(minmax_element_result, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(minmax_result, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(mismatch, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(mismatch_result, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(move, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(move_backward, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(move_backward_result, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(move_result, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(next, std::ranges::, <iterator>, "c++20")
+SYMBOL_VERSION(next_permutation, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(next_permutation_result, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(none_of, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(not_equal_to, std::ranges::, <functional>, "c++20")
+SYMBOL_VERSION(nth_element, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(out_value_result, std::ranges::, <algorithm>, "c++23")
+SYMBOL_VERSION(output_range, std::ranges::, <ranges>, "c++20")
+SYMBOL_VERSION(owning_view, std::ranges::, <ranges>, "c++20")
+SYMBOL_VERSION(partial_sort, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(partial_sort_copy, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(partial_sort_copy_result, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(partition, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(partition_copy, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(partition_copy_result, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(partition_point, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(pop_heap, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(prev, std::ranges::, <iterator>, "c++20")
+SYMBOL_VERSION(prev_permutation, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(prev_permutation_result, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(push_heap, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(random_access_range, std::ranges::, <ranges>, "c++20")
+SYMBOL_VERSION(range, std::ranges::, <ranges>, "c++20")
+SYMBOL_VERSION(range_adaptor_closure, std::ranges::, <ranges>, "c++23")
+SYMBOL_VERSION(range_const_reference_t, std::ranges::, <ranges>, "c++23")
+SYMBOL_VERSION(range_difference_t, std::ranges::, <ranges>, "c++20")
+SYMBOL_VERSION(range_reference_t, std::ranges::, <ranges>, "c++20")
+SYMBOL_VERSION(range_rvalue_reference_t, std::ranges::, <ranges>, "c++20")
+SYMBOL_VERSION(range_size_t, std::ranges::, <ranges>, "c++20")
+SYMBOL_VERSION(range_value_t, std::ranges::, <ranges>, "c++20")
+SYMBOL_VERSION(ref_view, std::ranges::, <ranges>, "c++20")
+SYMBOL_VERSION(remove, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(remove_copy, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(remove_copy_if, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(remove_copy_if_result, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(remove_copy_result, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(remove_if, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(repeat_view, std::ranges::, <ranges>, "c++23")
+SYMBOL_VERSION(replace, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(replace_copy, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(replace_copy_if, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(replace_copy_if_result, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(replace_copy_result, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(replace_if, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(reverse, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(reverse_copy, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(reverse_copy_result, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(reverse_view, std::ranges::, <ranges>, "c++20")
+SYMBOL_VERSION(rotate, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(rotate_copy, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(rotate_copy_result, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(sample, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(search, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(search_n, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(sentinel_t, std::ranges::, <ranges>, "c++20")
+SYMBOL_VERSION(set_difference, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(set_difference_result, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(set_intersection, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(set_intersection_result, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(set_symmetric_difference, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(set_symmetric_difference_result, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(set_union, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(set_union_result, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(shift_left, std::ranges::, <algorithm>, "c++23")
+SYMBOL_VERSION(shift_right, std::ranges::, <algorithm>, "c++23")
+SYMBOL_VERSION(shuffle, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(single_view, std::ranges::, <ranges>, "c++20")
+SYMBOL_VERSION(sized_range, std::ranges::, <ranges>, "c++20")
+SYMBOL_VERSION(slide_view, std::ranges::, <ranges>, "c++23")
+SYMBOL_VERSION(sort, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(sort_heap, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(split_view, std::ranges::, <ranges>, "c++20")
+SYMBOL_VERSION(stable_partition, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(stable_sort, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(starts_with, std::ranges::, <algorithm>, "c++23")
+SYMBOL_VERSION(stride_view, std::ranges::, <ranges>, "c++23")
+SYMBOL_VERSION(subrange, std::ranges::, <ranges>, "c++20")
+SYMBOL_VERSION(subrange_kind, std::ranges::, <ranges>, "c++20")
+SYMBOL_VERSION(swap, std::ranges::, <concepts>, "c++20")
+SYMBOL_VERSION(swap_ranges, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(swap_ranges_result, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(take_view, std::ranges::, <ranges>, "c++20")
+SYMBOL_VERSION(take_while_view, std::ranges::, <ranges>, "c++20")
+SYMBOL_VERSION(to, std::ranges::, <ranges>, "c++23")
+SYMBOL_VERSION(transform, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(transform_view, std::ranges::, <ranges>, "c++20")
+SYMBOL_VERSION(unary_transform_result, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(uninitialized_copy, std::ranges::, <memory>, "c++20")
+SYMBOL_VERSION(uninitialized_copy_n, std::ranges::, <memory>, "c++20")
+SYMBOL_VERSION(uninitialized_copy_n_result, std::ranges::, <memory>, "c++20")
+SYMBOL_VERSION(uninitialized_copy_result, std::ranges::, <memory>, "c++20")
+SYMBOL_VERSION(uninitialized_default_construct, std::ranges::, <memory>, "c++20")
+SYMBOL_VERSION(uninitialized_default_construct_n, std::ranges::, <memory>, "c++20")
+SYMBOL_VERSION(uninitialized_fill, std::ranges::, <memory>, "c++20")
+SYMBOL_VERSION(uninitialized_fill_n, std::ranges::, <memory>, "c++20")
+SYMBOL_VERSION(uninitialized_move, std::ranges::, <memory>, "c++20")
+SYMBOL_VERSION(uninitialized_move_n, std::ranges::, <memory>, "c++20")
+SYMBOL_VERSION(uninitialized_move_n_result, std::ranges::, <memory>, "c++20")
+SYMBOL_VERSION(uninitialized_move_result, std::ranges::, <memory>, "c++20")
+SYMBOL_VERSION(uninitialized_value_construct, std::ranges::, <memory>, "c++20")
+SYMBOL_VERSION(uninitialized_value_construct_n, std::ranges::, <memory>, "c++20")
+SYMBOL_VERSION(unique, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(unique_copy, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(unique_copy_result, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(upper_bound, std::ranges::, <algorithm>, "c++20")
+SYMBOL_VERSION(values_view, std::ranges::, <ranges>, "c++20")
+SYMBOL_VERSION(view, std::ranges::, <ranges>, "c++20")
+SYMBOL_VERSION(view_base, std::ranges::, <ranges>, "c++20")
+SYMBOL_VERSION(view_interface, std::ranges::, <ranges>, "c++20")
+SYMBOL_VERSION(viewable_range, std::ranges::, <ranges>, "c++20")
+SYMBOL_VERSION(wistream_view, std::ranges::, <ranges>, "c++20")
+SYMBOL_VERSION(zip_transform_view, std::ranges::, <ranges>, "c++23")
+SYMBOL_VERSION(zip_view, std::ranges::, <ranges>, "c++23")
+SYMBOL_VERSION(adjacent, std::ranges::views::, <ranges>, "c++23")
+SYMBOL_VERSION(adjacent_transform, std::ranges::views::, <ranges>, "c++23")
+SYMBOL_VERSION(all, std::ranges::views::, <ranges>, "c++20")
+SYMBOL_VERSION(all_t, std::ranges::views::, <ranges>, "c++20")
+SYMBOL_VERSION(as_const, std::ranges::views::, <ranges>, "c++23")
+SYMBOL_VERSION(as_rvalue, std::ranges::views::, <ranges>, "c++23")
+SYMBOL_VERSION(cartesian_product, std::ranges::views::, <ranges>, "c++23")
+SYMBOL_VERSION(chunk, std::ranges::views::, <ranges>, "c++23")
+SYMBOL_VERSION(chunk_by, std::ranges::views::, <ranges>, "c++23")
+SYMBOL_VERSION(common, std::ranges::views::, <ranges>, "c++20")
+SYMBOL_VERSION(concat, std::ranges::views::, <ranges>, "c++26")
+SYMBOL_VERSION(counted, std::ranges::views::, <ranges>, "c++20")
+SYMBOL_VERSION(drop, std::ranges::views::, <ranges>, "c++20")
+SYMBOL_VERSION(drop_while, std::ranges::views::, <ranges>, "c++20")
+SYMBOL_VERSION(elements, std::ranges::views::, <ranges>, "c++20")
+SYMBOL_VERSION(empty, std::ranges::views::, <ranges>, "c++20")
+SYMBOL_VERSION(enumerate, std::ranges::views::, <ranges>, "c++23")
+SYMBOL_VERSION(filter, std::ranges::views::, <ranges>, "c++20")
+SYMBOL_VERSION(iota, std::ranges::views::, <ranges>, "c++20")
+SYMBOL_VERSION(istream, std::ranges::views::, <ranges>, "c++20")
+SYMBOL_VERSION(istream, std::ranges::views::, <iosfwd>, "c++20")
+SYMBOL_VERSION(join, std::ranges::views::, <ranges>, "c++20")
+SYMBOL_VERSION(join_with, std::ranges::views::, <ranges>, "c++23")
+SYMBOL_VERSION(keys, std::ranges::views::, <ranges>, "c++20")
+SYMBOL_VERSION(lazy_split, std::ranges::views::, <ranges>, "c++20")
+SYMBOL_VERSION(pairwise, std::ranges::views::, <ranges>, "c++23")
+SYMBOL_VERSION(pairwise_transform, std::ranges::views::, <ranges>, "c++23")
+SYMBOL_VERSION(repeat, std::ranges::views::, <ranges>, "c++23")
+SYMBOL_VERSION(reverse, std::ranges::views::, <ranges>, "c++20")
+SYMBOL_VERSION(single, std::ranges::views::, <ranges>, "c++20")
+SYMBOL_VERSION(slide, std::ranges::views::, <ranges>, "c++23")
+SYMBOL_VERSION(split, std::ranges::views::, <ranges>, "c++20")
+SYMBOL_VERSION(stride, std::ranges::views::, <ranges>, "c++23")
+SYMBOL_VERSION(take, std::ranges::views::, <ranges>, "c++20")
+SYMBOL_VERSION(take_while, std::ranges::views::, <ranges>, "c++20")
+SYMBOL_VERSION(transform, std::ranges::views::, <ranges>, "c++20")
+SYMBOL_VERSION(values, std::ranges::views::, <ranges>, "c++20")
+SYMBOL_VERSION(zip, std::ranges::views::, <ranges>, "c++23")
+SYMBOL_VERSION(zip_transform, std::ranges::views::, <ranges>, "c++23")
+SYMBOL_VERSION(ECMAScript, std::regex_constants::, <regex>, "c++11")
+SYMBOL_VERSION(awk, std::regex_constants::, <regex>, "c++11")
+SYMBOL_VERSION(basic, std::regex_constants::, <regex>, "c++11")
+SYMBOL_VERSION(collate, std::regex_constants::, <regex>, "c++11")
+SYMBOL_VERSION(egrep, std::regex_constants::, <regex>, "c++11")
+SYMBOL_VERSION(error_backref, std::regex_constants::, <regex>, "c++11")
+SYMBOL_VERSION(error_badbrace, std::regex_constants::, <regex>, "c++11")
+SYMBOL_VERSION(error_badrepeat, std::regex_constants::, <regex>, "c++11")
+SYMBOL_VERSION(error_brace, std::regex_constants::, <regex>, "c++11")
+SYMBOL_VERSION(error_brack, std::regex_constants::, <regex>, "c++11")
+SYMBOL_VERSION(error_collate, std::regex_constants::, <regex>, "c++11")
+SYMBOL_VERSION(error_complexity, std::regex_constants::, <regex>, "c++11")
+SYMBOL_VERSION(error_ctype, std::regex_constants::, <regex>, "c++11")
+SYMBOL_VERSION(error_escape, std::regex_constants::, <regex>, "c++11")
+SYMBOL_VERSION(error_paren, std::regex_constants::, <regex>, "c++11")
+SYMBOL_VERSION(error_range, std::regex_constants::, <regex>, "c++11")
+SYMBOL_VERSION(error_space, std::regex_constants::, <regex>, "c++11")
+SYMBOL_VERSION(error_stack, std::regex_constants::, <regex>, "c++11")
+SYMBOL_VERSION(error_type, std::regex_constants::, <regex>, "c++11")
+SYMBOL_VERSION(extended, std::regex_constants::, <regex>, "c++11")
+SYMBOL_VERSION(format_default, std::regex_constants::, <regex>, "c++11")
+SYMBOL_VERSION(format_first_only, std::regex_constants::, <regex>, "c++11")
+SYMBOL_VERSION(format_no_copy, std::regex_constants::, <regex>, "c++11")
+SYMBOL_VERSION(format_sed, std::regex_constants::, <regex>, "c++11")
+SYMBOL_VERSION(grep, std::regex_constants::, <regex>, "c++11")
+SYMBOL_VERSION(icase, std::regex_constants::, <regex>, "c++11")
+SYMBOL_VERSION(match_any, std::regex_constants::, <regex>, "c++11")
+SYMBOL_VERSION(match_continuous, std::regex_constants::, <regex>, "c++11")
+SYMBOL_VERSION(match_default, std::regex_constants::, <regex>, "c++11")
+SYMBOL_VERSION(match_flag_type, std::regex_constants::, <regex>, "c++11")
+SYMBOL_VERSION(match_not_bol, std::regex_constants::, <regex>, "c++11")
+SYMBOL_VERSION(match_not_bow, std::regex_constants::, <regex>, "c++11")
+SYMBOL_VERSION(match_not_eol, std::regex_constants::, <regex>, "c++11")
+SYMBOL_VERSION(match_not_eow, std::regex_constants::, <regex>, "c++11")
+SYMBOL_VERSION(match_not_null, std::regex_constants::, <regex>, "c++11")
+SYMBOL_VERSION(match_prev_avail, std::regex_constants::, <regex>, "c++11")
+SYMBOL_VERSION(multiline, std::regex_constants::, <regex>, "c++17")
+SYMBOL_VERSION(nosubs, std::regex_constants::, <regex>, "c++11")
+SYMBOL_VERSION(optimize, std::regex_constants::, <regex>, "c++11")
+SYMBOL_VERSION(syntax_option_type, std::regex_constants::, <regex>, "c++11")
+SYMBOL_VERSION(get_id, std::this_thread::, <thread>, "c++11")
+SYMBOL_VERSION(sleep_for, std::this_thread::, <thread>, "c++11")
+SYMBOL_VERSION(sleep_until, std::this_thread::, <thread>, "c++11")
+SYMBOL_VERSION(yield, std::this_thread::, <thread>, "c++11")
+SYMBOL_VERSION(adjacent, std::views::, <ranges>, "c++23")
+SYMBOL_VERSION(adjacent_transform, std::views::, <ranges>, "c++23")
+SYMBOL_VERSION(all, std::views::, <ranges>, "c++20")
+SYMBOL_VERSION(all_t, std::views::, <ranges>, "c++20")
+SYMBOL_VERSION(as_const, std::views::, <ranges>, "c++23")
+SYMBOL_VERSION(as_rvalue, std::views::, <ranges>, "c++23")
+SYMBOL_VERSION(cartesian_product, std::views::, <ranges>, "c++23")
+SYMBOL_VERSION(chunk, std::views::, <ranges>, "c++23")
+SYMBOL_VERSION(chunk_by, std::views::, <ranges>, "c++23")
+SYMBOL_VERSION(common, std::views::, <ranges>, "c++20")
+SYMBOL_VERSION(concat, std::views::, <ranges>, "c++26")
+SYMBOL_VERSION(counted, std::views::, <ranges>, "c++20")
+SYMBOL_VERSION(drop, std::views::, <ranges>, "c++20")
+SYMBOL_VERSION(drop_while, std::views::, <ranges>, "c++20")
+SYMBOL_VERSION(elements, std::views::, <ranges>, "c++20")
+SYMBOL_VERSION(empty, std::views::, <ranges>, "c++20")
+SYMBOL_VERSION(enumerate, std::views::, <ranges>, "c++23")
+SYMBOL_VERSION(filter, std::views::, <ranges>, "c++20")
+SYMBOL_VERSION(iota, std::views::, <ranges>, "c++20")
+SYMBOL_VERSION(istream, std::views::, <ranges>, "c++20")
+SYMBOL_VERSION(istream, std::views::, <iosfwd>, "c++20")
+SYMBOL_VERSION(join, std::views::, <ranges>, "c++20")
+SYMBOL_VERSION(join_with, std::views::, <ranges>, "c++23")
+SYMBOL_VERSION(keys, std::views::, <ranges>, "c++20")
+SYMBOL_VERSION(lazy_split, std::views::, <ranges>, "c++20")
+SYMBOL_VERSION(pairwise, std::views::, <ranges>, "c++23")
+SYMBOL_VERSION(pairwise_transform, std::views::, <ranges>, "c++23")
+SYMBOL_VERSION(repeat, std::views::, <ranges>, "c++23")
+SYMBOL_VERSION(reverse, std::views::, <ranges>, "c++20")
+SYMBOL_VERSION(single, std::views::, <ranges>, "c++20")
+SYMBOL_VERSION(slide, std::views::, <ranges>, "c++23")
+SYMBOL_VERSION(split, std::views::, <ranges>, "c++20")
+SYMBOL_VERSION(stride, std::views::, <ranges>, "c++23")
+SYMBOL_VERSION(take, std::views::, <ranges>, "c++20")
+SYMBOL_VERSION(take_while, std::views::, <ranges>, "c++20")
+SYMBOL_VERSION(transform, std::views::, <ranges>, "c++20")
+SYMBOL_VERSION(values, std::views::, <ranges>, "c++20")
+SYMBOL_VERSION(zip, std::views::, <ranges>, "c++23")
+SYMBOL_VERSION(zip_transform, std::views::, <ranges>, "c++23")
+// clang-format on
diff --git a/clang/test/Headers/stddef.c b/clang/test/Headers/stddef.c
index bf564fb15221a..23564325d0088 100644
--- a/clang/test/Headers/stddef.c
+++ b/clang/test/Headers/stddef.c
@@ -9,9 +9,21 @@
struct astruct { char member; };
ptrdiff_t p0; // c99-error{{unknown type name 'ptrdiff_t'}} c11-error{{unknown type}} c23-error{{unknown type}} \
- c99-modules-error{{unknown type}} c11-modules-error{{unknown type}} c23-modules-error{{unknown type}}
+ c99-modules-error{{unknown type}} c11-modules-error{{unknown type}} c23-modules-error{{unknown type}} \
+ c99-note {{maybe try to include <stddef.h>; 'ptrdiff_t' is defined in <stddef.h>}} \
+ c11-note {{maybe try to include <stddef.h>; 'ptrdiff_t' is defined in <stddef.h>}} \
+ c23-note {{maybe try to include <stddef.h>; 'ptrdiff_t' is defined in <stddef.h>}} \
+ c99-modules-note {{maybe try to include <stddef.h>; 'ptrdiff_t' is defined in <stddef.h>}} \
+ c11-modules-note {{maybe try to include <stddef.h>; 'ptrdiff_t' is defined in <stddef.h>}} \
+ c23-modules-note {{maybe try to include <stddef.h>; 'ptrdiff_t' is defined in <stddef.h>}}
size_t s0; // c99-error{{unknown type name 'size_t'}} c11-error{{unknown type}} c23-error{{unknown type}} \
- c99-modules-error{{unknown type}} c11-modules-error{{unknown type}} c23-modules-error{{unknown type}}
+ c99-modules-error{{unknown type}} c11-modules-error{{unknown type}} c23-modules-error{{unknown type}} \
+ c99-note {{maybe try}} \
+ c11-note {{maybe try}} \
+ c23-note {{maybe try}} \
+ c99-modules-note {{maybe try to include <stddef.h>; 'size_t' is defined in <stddef.h>}} \
+ c11-modules-note {{maybe try to include <stddef.h>; 'size_t' is defined in <stddef.h>}} \
+ c23-modules-note {{maybe try to include <stddef.h>; 'size_t' is defined in <stddef.h>}}
rsize_t r0; // c99-error{{unknown type name 'rsize_t'}} c11-error{{unknown type}} c23-error{{unknown type}} \
c99-modules-error{{unknown type}} c11-modules-error{{unknown type}} c23-modules-error{{unknown type}}
wchar_t wc0; // c99-error{{unknown type name 'wchar_t'}} c11-error{{unknown type}} c23-error{{unknown type}} \
@@ -23,13 +35,31 @@ nullptr_t n0; // c99-error{{unknown type name 'nullptr_t'}} c11-error{{unknown t
static void f0(void) { unreachable(); } // c99-error{{call to undeclared function 'unreachable'}} c11-error{{undeclared function}} c23-error{{undeclared identifier}} \
c99-modules-error{{undeclared function}} c11-modules-error{{undeclared function}} c23-modules-error{{undeclared identifier}}
max_align_t m0; // c99-error{{unknown type name 'max_align_t'}} c11-error{{unknown type}} c23-error{{unknown type}} \
- c99-modules-error{{unknown type}} c11-modules-error{{unknown type}} c23-modules-error{{unknown type}}
+ c99-modules-error{{unknown type}} c11-modules-error{{unknown type}} c23-modules-error{{unknown type}} \
+ c99-note {{maybe try}} \
+ c99-note {{'max_align_t' is a c11 feature}} \
+ c11-note {{maybe try}} \
+ c11-note {{'max_align_t' is a c11 feature}} \
+ c23-note {{maybe try}} \
+ c23-note {{'max_align_t' is a c11 feature}} \
+ c99-modules-note {{maybe try to include <stddef.h>; 'max_align_t' is defined in <stddef.h>}} \
+ c99-modules-note {{'max_align_t' is a c11 feature}} \
+ c11-modules-note {{maybe try to include <stddef.h>; 'max_align_t' is defined in <stddef.h>}} \
+ c11-modules-note {{'max_align_t' is a c11 feature}} \
+ c23-modules-note {{maybe try to include <stddef.h>; 'max_align_t' is defined in <stddef.h>}} \
+ c23-modules-note {{'max_align_t' is a c11 feature}}
size_t o0 = offsetof(struct astruct, member); // c99-error{{unknown type name 'size_t'}} c99-error{{call to undeclared function 'offsetof'}} c99-error{{expected expression}} c99-error{{use of undeclared identifier 'member'}} \
c11-error{{unknown type}} c11-error{{undeclared function}} c11-error{{expected expression}} c11-error{{undeclared identifier}} \
c23-error{{unknown type}} c23-error{{undeclared identifier}} c23-error{{expected expression}} c23-error{{undeclared identifier}} \
c99-modules-error{{unknown type}} c99-modules-error{{undeclared function}} c99-modules-error{{expected expression}} c99-modules-error{{undeclared identifier}} \
c11-modules-error{{unknown type}} c11-modules-error{{undeclared function}} c11-modules-error{{expected expression}} c11-modules-error{{undeclared identifier}} \
- c23-modules-error{{unknown type}} c23-modules-error{{undeclared identifier}} c23-modules-error{{expected expression}} c23-modules-error{{undeclared identifier}}
+ c23-modules-error{{unknown type}} c23-modules-error{{undeclared identifier}} c23-modules-error{{expected expression}} c23-modules-error{{undeclared identifier}} \
+ c99-note {{maybe try}} \
+ c11-note {{maybe try}} \
+ c23-note {{maybe try}} \
+ c99-modules-note {{maybe try}} \
+ c11-modules-note {{maybe try}} \
+ c23-modules-note {{maybe try}}
wint_t wi0; // c99-error{{unknown type name 'wint_t'}} c11-error{{unknown type}} c23-error{{unknown type}} \
c99-modules-error{{unknown type name 'wint_t'}} c11-modules-error{{unknown type}} c23-modules-error{{unknown type}}
@@ -48,7 +78,9 @@ nullptr_t n1; // c99-error{{unknown type}} c11-error{{unknown type}} \
static void f1(void) { unreachable(); } // c99-error{{undeclared function}} c11-error{{undeclared function}} \
c99-modules-error{{undeclared function}} c11-modules-error{{undeclared function}}
max_align_t m1; // c99-error{{unknown type}} c99-modules-error{{'max_align_t' must be declared before it is used}} \
- c99-modules-note at __stddef_max_align_t.h:*{{declaration here is not visible}}
+ c99-modules-note at __stddef_max_align_t.h:*{{declaration here is not visible}} \
+ c99-note {{maybe try}} \
+ c99-note {{'max_align_t' is a c11 feature}}
size_t o1 = offsetof(struct astruct, member);
wint_t wi1; // c99-error{{unknown type}} c11-error{{unknown type}} c23-error{{unknown type}} \
c99-modules-error{{unknown type}} c11-modules-error{{unknown type}} c23-modules-error{{unknown type}}
@@ -65,7 +97,9 @@ nullptr_t n2; // c99-error{{unknown type}} c11-error{{unknown type}} \
c99-modules-error{{unknown type}} c11-modules-error{{unknown type}}
static void f2(void) { unreachable(); } // c99-error{{undeclared function}} c11-error{{undeclared function}} \
c99-modules-error{{undeclared function}} c11-modules-error{{undeclared function}}
-max_align_t m2; // c99-error{{unknown type}}
+max_align_t m2; // c99-error{{unknown type}} \
+ c99-note {{maybe try}} \
+ c99-note {{'max_align_t' is a c11 feature}}
size_t o2 = offsetof(struct astruct, member);
wint_t wi2; // c99-error{{unknown type}} c11-error{{unknown type}} c23-error{{unknown type}} \
c99-modules-error{{unknown type}} c11-modules-error{{unknown type}} c23-modules-error{{unknown type}}
diff --git a/clang/test/Headers/stddefneeds.c b/clang/test/Headers/stddefneeds.c
index fae7d7041d6af..5766d589ea81d 100644
--- a/clang/test/Headers/stddefneeds.c
+++ b/clang/test/Headers/stddefneeds.c
@@ -9,9 +9,17 @@
struct astruct { char member; };
ptrdiff_t p0; // c99-error{{unknown type name 'ptrdiff_t'}} c23-error{{unknown type}} \
- c99-modules-error{{unknown type}} c23-modules-error{{unknown type}}
+ c99-modules-error{{unknown type}} c23-modules-error{{unknown type}} \
+ c99-note {{maybe try to include <stddef.h>; 'ptrdiff_t' is defined in <stddef.h>}} \
+ c23-note {{maybe try to include <stddef.h>; 'ptrdiff_t' is defined in <stddef.h>}} \
+ c99-modules-note {{maybe try to include <stddef.h>; 'ptrdiff_t' is defined in <stddef.h>}} \
+ c23-modules-note {{maybe try to include <stddef.h>; 'ptrdiff_t' is defined in <stddef.h>}}
size_t s0; // c99-error{{unknown type name 'size_t'}} c23-error{{unknown type}} \
- c99-modules-error{{unknown type}} c23-modules-error{{unknown type}}
+ c99-modules-error{{unknown type}} c23-modules-error{{unknown type}}\
+ c99-note {{maybe try to include <stddef.h>; 'size_t' is defined in <stddef.h>}} \
+ c23-note {{maybe try to include <stddef.h>; 'size_t' is defined in <stddef.h>}} \
+ c99-modules-note {{maybe try to include <stddef.h>; 'size_t' is defined in <stddef.h>}} \
+ c23-modules-note {{maybe try to include <stddef.h>; 'size_t' is defined in <stddef.h>}}
rsize_t r0; // c99-error{{unknown type name 'rsize_t'}} c23-error{{unknown type}} \
c99-modules-error{{unknown type}} c23-modules-error{{unknown type}}
wchar_t wc0; // c99-error{{unknown type name 'wchar_t'}} c23-error{{unknown type}} \
@@ -23,11 +31,24 @@ nullptr_t n0; // c99-error{{unknown type name 'nullptr_t'}} c23-error{{unknown t
static void f0(void) { unreachable(); } // c99-error{{call to undeclared function 'unreachable'}} c23-error{{undeclared identifier 'unreachable'}} \
c99-modules-error{{undeclared function}} c23-modules-error{{undeclared identifier}}
max_align_t m0; // c99-error{{unknown type name 'max_align_t'}} c23-error{{unknown type}} \
- c99-modules-error{{unknown type}} c23-modules-error{{unknown type}}
+ c99-modules-error{{unknown type}} c23-modules-error{{unknown type}} \
+ c99-note {{maybe try to include <stddef.h>; 'max_align_t' is defined in <stddef.h>}} \
+ c99-note {{max_align_t' is a c11 feature}} \
+ c23-note {{maybe try to include <stddef.h>; 'max_align_t' is defined in <stddef.h>}} \
+ c23-note {{max_align_t' is a c11 feature}}\
+ c99-modules-note {{maybe try to include <stddef.h>; 'max_align_t' is defined in <stddef.h>}} \
+ c99-modules-note {{max_align_t' is a c11 feature}} \
+ c23-modules-note {{maybe try to include <stddef.h>; 'max_align_t' is defined in <stddef.h>}} \
+ c23-modules-note {{max_align_t' is a c11 feature}}
size_t o0 = offsetof(struct astruct, member); // c99-error{{unknown type name 'size_t'}} c99-error{{call to undeclared function 'offsetof'}} c99-error{{expected expression}} c99-error{{use of undeclared identifier 'member'}} \
c23-error{{unknown type name 'size_t'}} c23-error{{undeclared identifier 'offsetof'}} c23-error{{expected expression}} c23-error{{use of undeclared identifier 'member'}} \
c99-modules-error{{unknown type}} c99-modules-error{{undeclared function}} c99-modules-error{{expected expression}} c99-modules-error{{undeclared identifier}} \
- c23-modules-error{{unknown type}} c23-modules-error{{undeclared identifier}} c23-modules-error{{expected expression}} c23-modules-error{{undeclared identifier}}
+ c23-modules-error{{unknown type}} c23-modules-error{{undeclared identifier}} c23-modules-error{{expected expression}} c23-modules-error{{undeclared identifier}}\
+ c99-note {{maybe try to include <stddef.h>; 'size_t' is defined in <stddef.h>}} \
+ c23-note {{maybe try to include <stddef.h>; 'size_t' is defined in <stddef.h>}}\
+ c99-modules-note {{maybe try to include <stddef.h>; 'size_t' is defined in <stddef.h>}} \
+ c23-modules-note {{maybe try to include <stddef.h>; 'size_t' is defined in <stddef.h>}}
+
wint_t wi0; // c99-error{{unknown type name 'wint_t'}} c23-error{{unknown type}} \
c99-modules-error{{unknown type}} c23-modules-error{{unknown type}}
@@ -37,7 +58,9 @@ wint_t wi0; // c99-error{{unknown type name 'wint_t'}} c23-error{{unknown type}}
ptrdiff_t p1;
size_t s1; // c99-error{{unknown type}} c23-error{{unknown type}} \
c99-modules-error{{'size_t' must be declared before it is used}} c23-modules-error{{must be declared}} \
- c99-modules-note at __stddef_size_t.h:*{{declaration here is not visible}} c23-modules-note at __stddef_size_t.h:*{{declaration here is not visible}}
+ c99-modules-note at __stddef_size_t.h:*{{declaration here is not visible}} c23-modules-note at __stddef_size_t.h:*{{declaration here is not visible}} \
+ c99-note {{maybe try to include <stddef.h>; 'size_t' is defined in <stddef.h>}} \
+ c23-note {{maybe try to include <stddef.h>; 'size_t' is defined in <stddef.h>}}
rsize_t r1; // c99-error{{unknown type}} c23-error{{unknown type}} \
c99-modules-error{{'rsize_t' must be declared before it is used}} c23-modules-error{{must be declared}} \
c99-modules-note at __stddef_rsize_t.h:*{{declaration here is not visible}} c23-modules-note at __stddef_rsize_t.h:*{{declaration here is not visible}}
@@ -53,11 +76,18 @@ static void f1(void) { unreachable(); } // c99-error{{undeclared function}} c23-
c99-modules-error{{undeclared function}} c23-modules-error{{undeclared identifier}}
max_align_t m1; // c99-error{{unknown type}} c23-error{{unknown type}} \
c99-modules-error{{'max_align_t' must be declared before it is used}} c23-modules-error{{must be declared}} \
- c99-modules-note at __stddef_max_align_t.h:*{{declaration here is not visible}} c23-modules-note at __stddef_max_align_t.h:*{{declaration here is not visible}}
+ c99-modules-note at __stddef_max_align_t.h:*{{declaration here is not visible}} c23-modules-note at __stddef_max_align_t.h:*{{declaration here is not visible}} \
+ c99-note {{maybe try to include <stddef.h>; 'max_align_t' is defined in <stddef.h>}} \
+ c99-note {{'max_align_t' is a c11 feature}} \
+ c23-note {{maybe try to include <stddef.h>; 'max_align_t' is defined in <stddef.h>}} \
+ c23-note {{'max_align_t' is a c11 feature}}
+
size_t o1 = offsetof(struct astruct, member); // c99-error{{unknown type}} c99-error{{expected expression}} c99-error{{undeclared identifier}} \
c23-error{{unknown type}} c23-error{{undeclared identifier}} c23-error{{expected expression}} c23-error{{undeclared identifier}} \
c99-modules-error{{expected expression}} c99-modules-error{{undeclared identifier}} \
- c23-modules-error{{undeclared identifier}} c23-modules-error{{expected expression}} c23-modules-error{{undeclared identifier}}
+ c23-modules-error{{undeclared identifier}} c23-modules-error{{expected expression}} c23-modules-error{{undeclared identifier}} \
+ c99-note {{maybe try to include <stddef.h>; 'size_t' is defined in <stddef.h>}} \
+ c23-note {{maybe try to include <stddef.h>; 'size_t' is defined in <stddef.h>}}
wint_t wi1; // c99-error{{unknown type}} c23-error{{unknown type}} \
c99-modules-error{{unknown type}} c23-modules-error{{unknown type}}
@@ -82,7 +112,11 @@ nullptr_t n2; // c99-error{{unknown type}} c23-error{{unknown type}} \
c99-modules-error{{unknown type}}
static void f2(void) { unreachable(); } // c99-error{{undeclared function}} c23-error{{undeclared identifier}} \
c99-modules-error{{undeclared function}} c23-modules-error{{undeclared identifier}}
-max_align_t m2; // c99-error{{unknown type}} c23-error{{unknown type}}
+max_align_t m2; // c99-error{{unknown type}} c23-error{{unknown type}} \
+ c99-note {{maybe try to include <stddef.h>; 'max_align_t' is defined in <stddef.h>}} \
+ c99-note {{'max_align_t' is a c11 feature}} \
+ c23-note {{maybe try to include <stddef.h>; 'max_align_t' is defined in <stddef.h>}} \
+ c23-note {{'max_align_t' is a c11 feature}}
size_t o2 = offsetof(struct astruct, member); // c99-error{{expected expression}} c99-error{{undeclared identifier}} \
c23-error{{undeclared identifier}} c23-error{{expected expression}} c23-error{{undeclared identifier}} \
c99-modules-error{{expected expression}} c99-modules-error{{undeclared identifier}} \
@@ -103,7 +137,11 @@ nullptr_t n3; // c99-error{{unknown type}} c23-error{{unknown type}} \
c99-modules-error{{unknown type}}
static void f3(void) { unreachable(); } // c99-error{{undeclared function}} c23-error{{undeclared identifier}} \
c99-modules-error{{undeclared function}} c23-modules-error{{undeclared identifier}}
-max_align_t m3; // c99-error{{unknown type}} c23-error{{unknown type}}
+max_align_t m3; // c99-error{{unknown type}} c23-error{{unknown type}} \
+ c99-note {{maybe try to include <stddef.h>; 'max_align_t' is defined in <stddef.h>}} \
+ c99-note {{'max_align_t' is a c11 feature}} \
+ c23-note {{maybe try to include <stddef.h>; 'max_align_t' is defined in <stddef.h>}} \
+ c23-note {{'max_align_t' is a c11 feature}}
size_t o3 = offsetof(struct astruct, member); // c99-error{{expected expression}} c99-error{{undeclared identifier}} \
c23-error{{undeclared identifier}} c23-error{{expected expression}} c23-error{{undeclared identifier}} \
c99-modules-error{{expected expression}} c99-modules-error{{undeclared identifier}} \
@@ -124,7 +162,11 @@ nullptr_t n4; // c99-error{{unknown type}} c23-error{{unknown type}} \
c99-modules-error{{unknown type}}
static void f4(void) { unreachable(); } // c99-error{{undeclared function}} c23-error{{undeclared identifier}} \
c99-modules-error{{undeclared function}} c23-modules-error{{undeclared identifier}}
-max_align_t m4; // c99-error{{unknown type}} c23-error{{unknown type}}
+max_align_t m4; // c99-error{{unknown type}} c23-error{{unknown type}} \
+ c99-note {{maybe try to include <stddef.h>; 'max_align_t' is defined in <stddef.h>}} \
+ c99-note {{'max_align_t' is a c11 feature}} \
+ c23-note {{maybe try to include <stddef.h>; 'max_align_t' is defined in <stddef.h>}} \
+ c23-note {{'max_align_t' is a c11 feature}}
size_t o4 = offsetof(struct astruct, member); // c99-error{{expected expression}} c99-error{{undeclared identifier}} \
c23-error{{undeclared identifier}} c23-error{{expected expression}} c23-error{{undeclared identifier}} \
c99-modules-error{{expected expression}} c99-modules-error{{undeclared identifier}} \
@@ -144,7 +186,11 @@ nullptr_t n5; // c99-error{{unknown type}} c23-error{{unknown type}} \
c99-modules-error{{unknown type}}
static void f5(void) { unreachable(); } // c99-error{{undeclared function}} c23-error{{undeclared identifier}} \
c99-modules-error{{undeclared function}} c23-modules-error{{undeclared identifier}}
-max_align_t m5; // c99-error{{unknown type}} c23-error{{unknown type}}
+max_align_t m5; // c99-error{{unknown type}} c23-error{{unknown type}} \
+ c99-note {{maybe try to include <stddef.h>; 'max_align_t' is defined in <stddef.h>}} \
+ c99-note {{'max_align_t' is a c11 feature}} \
+ c23-note {{maybe try to include <stddef.h>; 'max_align_t' is defined in <stddef.h>}} \
+ c23-note {{'max_align_t' is a c11 feature}}
size_t o5 = offsetof(struct astruct, member); // c99-error{{expected expression}} c99-error{{undeclared identifier}} \
c23-error{{undeclared identifier}} c23-error{{expected expression}} c23-error{{undeclared identifier}} \
c99-modules-error{{expected expression}} c99-modules-error{{undeclared identifier}} \
@@ -165,7 +211,11 @@ void *v6 = NULL;
nullptr_t n6; // c99-error{{unknown type}} c99-modules-error{{unknown type}}
static void f6(void) { unreachable(); } // c99-error{{undeclared function}} c23-error{{undeclared identifier}} \
c99-modules-error{{undeclared function}} c23-modules-error{{undeclared identifier}}
-max_align_t m6; // c99-error{{unknown type}} c23-error{{unknown type}}
+max_align_t m6; // c99-error{{unknown type}} c23-error{{unknown type}} \
+ c99-note {{maybe try to include <stddef.h>; 'max_align_t' is defined in <stddef.h>}} \
+ c99-note {{'max_align_t' is a c11 feature}} \
+ c23-note {{maybe try to include <stddef.h>; 'max_align_t' is defined in <stddef.h>}} \
+ c23-note {{'max_align_t' is a c11 feature}}
size_t o6 = offsetof(struct astruct, member); // c99-error{{expected expression}} c99-error{{undeclared identifier}} \
c23-error{{undeclared identifier}} c23-error{{expected expression}} c23-error{{undeclared identifier}} \
c99-modules-error{{expected expression}} c99-modules-error{{undeclared identifier}} \
@@ -183,7 +233,11 @@ wchar_t wc7;
void *v7 = NULL;
nullptr_t n7 ; // c99-error{{unknown type}} c99-modules-error{{unknown type}}
static void f7(void) { unreachable(); }
-max_align_t m7; // c99-error{{unknown type}} c23-error{{unknown type}}
+max_align_t m7; // c99-error{{unknown type}} c23-error{{unknown type}} \
+ c99-note {{maybe try to include <stddef.h>; 'max_align_t' is defined in <stddef.h>}} \
+ c99-note {{'max_align_t' is a c11 feature}} \
+ c23-note {{maybe try to include <stddef.h>; 'max_align_t' is defined in <stddef.h>}} \
+ c23-note {{'max_align_t' is a c11 feature}}
size_t o7 = offsetof(struct astruct, member); // c99-error{{expected expression}} c99-error{{undeclared identifier}} \
c23-error{{undeclared identifier}} c23-error{{expected expression}} c23-error{{undeclared identifier}} \
c99-modules-error{{expected expression}} c99-modules-error{{undeclared identifier}} \
diff --git a/clang/test/Headers/stddefneeds.cpp b/clang/test/Headers/stddefneeds.cpp
index 0282e8afa600d..4e73a3d7fbd07 100644
--- a/clang/test/Headers/stddefneeds.cpp
+++ b/clang/test/Headers/stddefneeds.cpp
@@ -1,28 +1,28 @@
// RUN: %clang_cc1 -fsyntax-only -triple x86_64-apple-macosx10.9.0 -verify -Wsentinel -std=c++11 %s
-ptrdiff_t p0; // expected-error{{unknown}}
-size_t s0; // expected-error{{unknown}}
-void* v0 = NULL; // expected-error{{undeclared}}
+ptrdiff_t p0; // expected-error{{unknown}} expected-note {{maybe try to include <cstddef>; 'ptrdiff_t' is defined in <cstddef>}}
+size_t s0; // expected-error{{unknown}} expected-note {{maybe try to include <cstddef>; 'size_t' is defined in <cstddef>}}
+void* v0 = NULL; // expected-error{{undeclared}} expected-note {{maybe try to include <cstddef>; 'NULL' is defined in <cstddef>}}
wint_t w0; // expected-error{{unknown}}
-max_align_t m0; // expected-error{{unknown}}
+max_align_t m0; // expected-error{{unknown}} expected-note {{maybe try to include <cstddef>; 'max_align_t' is defined in <cstddef>}}
#define __need_ptrdiff_t
#include <stddef.h>
ptrdiff_t p1;
-size_t s1; // expected-error{{unknown}}
-void* v1 = NULL; // expected-error{{undeclared}}
+size_t s1; // expected-error{{unknown}} expected-note {{maybe try to include <cstddef>; 'size_t' is defined in <cstddef>}}
+void* v1 = NULL; // expected-error{{undeclared}} expected-note {{maybe try to include <cstddef>; 'NULL' is defined in <cstddef>}}
wint_t w1; // expected-error{{unknown}}
-max_align_t m1; // expected-error{{unknown}}
+max_align_t m1; // expected-error{{unknown}} expected-note {{maybe try to include <cstddef>; 'max_align_t' is defined in <cstddef>}}
#define __need_size_t
#include <stddef.h>
ptrdiff_t p2;
size_t s2;
-void* v2 = NULL; // expected-error{{undeclared}}
+void* v2 = NULL; // expected-error{{undeclared}} expected-note {{maybe try to include <cstddef>; 'NULL' is defined in <cstddef>}}
wint_t w2; // expected-error{{unknown}}
-max_align_t m2; // expected-error{{unknown}}
+max_align_t m2; // expected-error{{unknown}} expected-note {{maybe try to include <cstddef>; 'max_align_t' is defined in <cstddef>}}
#define __need_NULL
#include <stddef.h>
@@ -31,7 +31,7 @@ ptrdiff_t p3;
size_t s3;
void* v3 = NULL;
wint_t w3; // expected-error{{unknown}}
-max_align_t m3; // expected-error{{unknown}}
+max_align_t m3; // expected-error{{unknown}} expected-note {{maybe try to include <cstddef>; 'max_align_t' is defined in <cstddef>}}
// Shouldn't bring in wint_t by default:
#include <stddef.h>
diff --git a/clang/test/Modules/implicit-declared-allocation-functions.cppm b/clang/test/Modules/implicit-declared-allocation-functions.cppm
index b378a1d1365ee..cc6b1f0951bb5 100644
--- a/clang/test/Modules/implicit-declared-allocation-functions.cppm
+++ b/clang/test/Modules/implicit-declared-allocation-functions.cppm
@@ -17,14 +17,20 @@ export void alloc_wrapper() {
// std::align_Âval_Ât is ill-formed unless a standard library declaration
// ([cstddef.syn], [new.syn], [std.modules]) of that name precedes
// ([basic.lookup.general]) the use of that name.
- void *b = ::operator new((std::size_t)32); // expected-error {{use of undeclared identifier 'std'}}
- void *c = ::operator new((std::size_t)32, // expected-error {{use of undeclared identifier 'std'}}
- (std::align_val_t)64); // expected-error {{use of undeclared identifier 'std'}}
+ void *b = ::operator new((std::size_t)32); // expected-error {{use of undeclared identifier 'std'}} expected-note {{maybe try to include <cstddef>; 'std::size_t' is defined in <cstddef>}}
+ void *c = ::operator new((std::size_t)32, // expected-error {{use of undeclared identifier 'std'}} expected-note {{maybe try to include <cstddef>; 'std::size_t' is defined in <cstddef>}}
+ (std::align_val_t)64); // expected-error {{use of undeclared identifier 'std'}} \
+ expected-note {{maybe try to include <new>; 'std::align_val_t' is defined in <new>}} \
+ expected-note {{'std::align_val_t' is a c++17 feature}}
::operator delete(a);
- ::operator delete(b, (std::size_t)32); // expected-error {{use of undeclared identifier 'std'}}
- ::operator delete(c, (std::size_t)32, // expected-error {{use of undeclared identifier 'std'}}
- (std::align_val_t)64); // expected-error {{use of undeclared identifier 'std'}}
+ ::operator delete(b, (std::size_t)32); // expected-error {{use of undeclared identifier 'std'}} \
+ expected-note {{maybe try to include <cstddef>; 'std::size_t' is defined in <cstddef>}}
+ ::operator delete(c, (std::size_t)32, // expected-error {{use of undeclared identifier 'std'}} \
+ expected-note {{maybe try to include <cstddef>; 'std::size_t' is defined in <cstddef>}}
+ (std::align_val_t)64); // expected-error {{use of undeclared identifier 'std'}} \
+ expected-note {{maybe try to include <new>; 'std::align_val_t' is defined in <new>}} \
+ expected-note {{'std::align_val_t' is a c++17 feature}}
}
//--- new
diff --git a/clang/test/Modules/macro-reexport.cpp b/clang/test/Modules/macro-reexport.cpp
index 4e825a07bd803..2a76f4d800386 100644
--- a/clang/test/Modules/macro-reexport.cpp
+++ b/clang/test/Modules/macro-reexport.cpp
@@ -21,13 +21,13 @@
#include "f1.h"
void f() { return assert(true); } // expected-error {{undeclared identifier 'd'}}
#include "e2.h" // undefines d1's macro
-void g() { return assert(true); } // expected-error {{undeclared identifier 'assert'}}
+void g() { return assert(true); } // expected-error {{undeclared identifier 'assert'}} expected-note {{maybe try to include <cassert>; 'assert' is defined in <cassert>}}
#elif defined(D1)
#include "e1.h" // undefines c1's macro but not d1's macro
#include "d1.h"
void f() { return assert(true); } // expected-error {{undeclared identifier 'd'}}
#include "e2.h" // undefines d1's macro
-void g() { return assert(true); } // expected-error {{undeclared identifier 'assert'}}
+void g() { return assert(true); } // expected-error {{undeclared identifier 'assert'}} expected-note {{maybe try to include <cassert>; 'assert' is defined in <cassert>}}
#elif defined(D2)
#include "d2.h"
void f() { return assert(true); } // expected-error {{undeclared identifier 'b'}}
@@ -35,5 +35,5 @@ void f() { return assert(true); } // expected-error {{undeclared identifier 'b'}
// e2 undefines d1's macro, which overrides c1's macro.
#include "e2.h"
#include "c1.h"
-void f() { return assert(true); } // expected-error {{undeclared identifier 'assert'}}
+void f() { return assert(true); } // expected-error {{undeclared identifier 'assert'}} expected-note {{maybe try to include <cassert>; 'assert' is defined in <cassert>}}
#endif
diff --git a/clang/test/Modules/stddef.cpp b/clang/test/Modules/stddef.cpp
index c53bfa3485194..86622f0fef510 100644
--- a/clang/test/Modules/stddef.cpp
+++ b/clang/test/Modules/stddef.cpp
@@ -10,13 +10,13 @@ void *pointer = NULL;
size_t size = 0;
// When building with modules, a pcm is never re-imported, so re-including
-// stddef.h will not re-import _Builtin_stddef.null to restore the definition of
+// stddef.h will not re-import _Builtin_stddef.null to restore the definition of
// NULL, even though stddef.h will unconditionally include __stddef_null.h when
// building with modules.
#undef NULL
#include <stddef.h>
-void *anotherPointer = NULL; // expected-error{{use of undeclared identifier 'NULL'}}
+void *anotherPointer = NULL; // expected-error{{use of undeclared identifier 'NULL'}} expected-note {{maybe try to include <cstddef>; 'NULL' is defined in <cstddef>}}
// stddef.h needs to be a `textual` header to support clients doing things like
// this.
diff --git a/clang/test/Sema/MicrosoftCompatibility.c b/clang/test/Sema/MicrosoftCompatibility.c
index 8d402d53e004d..131d044d3f9c0 100644
--- a/clang/test/Sema/MicrosoftCompatibility.c
+++ b/clang/test/Sema/MicrosoftCompatibility.c
@@ -33,7 +33,7 @@ __declspec(__noreturn__) void f7(void); /* expected-warning {{__declspec attribu
#ifdef MSVCCOMPAT
size_t x;
#else
-size_t x; // expected-error {{unknown type name 'size_t'}}
+size_t x; // expected-error {{unknown type name 'size_t'}} expected-note {{maybe try to include <stddef.h>; 'size_t' is defined in <stddef.h>}}
#endif
/* Microsoft allows inline, __inline, and __forceinline to appear on a typedef
diff --git a/clang/test/Sema/builtin-setjmp.c b/clang/test/Sema/builtin-setjmp.c
index a71f87162612d..3231ca4373fd4 100644
--- a/clang/test/Sema/builtin-setjmp.c
+++ b/clang/test/Sema/builtin-setjmp.c
@@ -36,10 +36,12 @@ void use(void) {
#if NO_SETJMP
// cxx-error at -2 {{undeclared identifier 'setjmp'}}
// c-error at -3 {{call to undeclared function 'setjmp'; ISO C99 and later do not support implicit function declarations}}
+ // cxx-note at -4 {{maybe try to include <csetjmp>; 'setjmp' is defined in <csetjmp>}}
#elif ONLY_JMP_BUF
- // cxx-error at -5 {{undeclared identifier 'setjmp'}}
- // c-error at -6 {{call to undeclared library function 'setjmp' with type 'int (jmp_buf)' (aka 'int (int *)'); ISO C99 and later do not support implicit function declarations}}
- // c-note at -7 {{include the header <setjmp.h> or explicitly provide a declaration for 'setjmp'}}
+ // cxx-error at -6 {{undeclared identifier 'setjmp'}}
+ // c-error at -7 {{call to undeclared library function 'setjmp' with type 'int (jmp_buf)' (aka 'int (int *)'); ISO C99 and later do not support implicit function declarations}}
+ // c-note at -8 {{include the header <setjmp.h> or explicitly provide a declaration for 'setjmp'}}
+ // cxx-note at -9 {{maybe try to include <csetjmp>; 'setjmp' is defined in <csetjmp>}}
#else
// cxx-no-diagnostics
#endif
diff --git a/clang/test/Sema/c23-delayed-typo-correction-crashes.c b/clang/test/Sema/c23-delayed-typo-correction-crashes.c
index 6afd3fd32c366..53646fef1cb25 100644
--- a/clang/test/Sema/c23-delayed-typo-correction-crashes.c
+++ b/clang/test/Sema/c23-delayed-typo-correction-crashes.c
@@ -13,6 +13,7 @@ struct GH137867 {
void GH137867_test() {
_Atomic(struct GH137867) t;
while (!atomic_load(&t.value)->value) // expected-error {{use of undeclared identifier 'atomic_load'}} \
- expected-error {{accessing a member of an atomic structure or union is undefined behavior}}
+ expected-error {{accessing a member of an atomic structure or union is undefined behavior}} \
+ expected-note {{maybe try to include <stdatomic.h>; 'atomic_load' is defined in <stdatomic.h>}}
;
}
diff --git a/clang/test/Sema/implicit-builtin-decl.c b/clang/test/Sema/implicit-builtin-decl.c
index 055ba7e70eb12..d2997ccdfa2e1 100644
--- a/clang/test/Sema/implicit-builtin-decl.c
+++ b/clang/test/Sema/implicit-builtin-decl.c
@@ -24,7 +24,8 @@ void h() {
void f2() {
fprintf(0, "foo"); // expected-warning{{declaration of built-in function 'fprintf' requires inclusion of the header <stdio.h>}} \
- expected-error {{call to undeclared function 'fprintf'; ISO C99 and later do not support implicit function declarations}}
+ expected-error {{call to undeclared function 'fprintf'; ISO C99 and later do not support implicit function declarations}} \
+ expected-note {{maybe try to include <stdio.h>; 'fprintf' is defined in <stdio.h>}}
}
// PR2892
diff --git a/clang/test/Sema/include-suggestion.c b/clang/test/Sema/include-suggestion.c
new file mode 100644
index 0000000000000..f47039102840e
--- /dev/null
+++ b/clang/test/Sema/include-suggestion.c
@@ -0,0 +1,5 @@
+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+void test(){
+ (void) atoll;// expected-error {{use of undeclared identifier}} expected-note {{maybe try}} expected-note {{'atoll' is a}}
+}
diff --git a/clang/test/SemaCXX/constructor-initializer.cpp b/clang/test/SemaCXX/constructor-initializer.cpp
index 96be8dda97735..59db750f856c6 100644
--- a/clang/test/SemaCXX/constructor-initializer.cpp
+++ b/clang/test/SemaCXX/constructor-initializer.cpp
@@ -238,7 +238,7 @@ namespace PR7402 {
// Don't crash. Lots of questionable recovery here; errors can change.
namespace test3 {
- class A : public std::exception {}; // expected-error {{undeclared identifier}} expected-error {{expected class name}}
+ class A : public std::exception {}; // expected-error {{undeclared identifier}} expected-error {{expected class name}} expected-note {{maybe try to include <exception>; 'std::exception' is defined in <exception>}}
// expected-note at -1 {{candidate constructor (the implicit copy constructor) not viable}}
#if __cplusplus >= 201103L // C++11 or later
// expected-note at -3 {{candidate constructor (the implicit move constructor) not viable}}
diff --git a/clang/test/SemaCXX/include-suggestions-cxx.cpp b/clang/test/SemaCXX/include-suggestions-cxx.cpp
new file mode 100644
index 0000000000000..97f0a9347b2e8
--- /dev/null
+++ b/clang/test/SemaCXX/include-suggestions-cxx.cpp
@@ -0,0 +1,2458 @@
+// RUN: %clang_cc1 -verify -fsyntax-only %s
+
+namespace std{};
+
+void test(){
+ std::FILE; // expected-error {{no member}} expected-note {{maybe try}}
+ std::_Exit; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::_Exit' is a}}
+ std::accumulate; // expected-error {{no member}} expected-note {{maybe try}}
+ std::acosf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::acosf' is a}}
+ std::acoshf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::acoshf' is a}}
+ std::acoshl; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::acoshl' is a}}
+ std::acosl; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::acosl' is a}}
+ std::add_const; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::add_const' is a}}
+ std::add_const_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::add_const_t' is a}}
+ std::add_cv; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::add_cv' is a}}
+ std::add_cv_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::add_cv_t' is a}}
+ std::add_lvalue_reference; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::add_lvalue_reference' is a}}
+ std::add_lvalue_reference_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::add_lvalue_reference_t' is a}}
+ std::add_pointer; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::add_pointer' is a}}
+ std::add_pointer_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::add_pointer_t' is a}}
+ std::add_rvalue_reference; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::add_rvalue_reference' is a}}
+ std::add_rvalue_reference_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::add_rvalue_reference_t' is a}}
+ std::add_sat; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::add_sat' is a}}
+ std::add_volatile; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::add_volatile' is a}}
+ std::add_volatile_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::add_volatile_t' is a}}
+ std::addressof; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::addressof' is a}}
+ std::adjacent_difference; // expected-error {{no member}} expected-note {{maybe try}}
+ std::adjacent_find; // expected-error {{no member}} expected-note {{maybe try}}
+ std::adopt_lock; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::adopt_lock' is a}}
+ std::adopt_lock_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::adopt_lock_t' is a}}
+ std::advance; // expected-error {{no member}} expected-note {{maybe try}}
+ std::align; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::align' is a}}
+ std::align_val_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::align_val_t' is a}}
+ std::aligned_alloc; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::aligned_alloc' is a}}
+ std::aligned_storage; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::aligned_storage' is a}}
+ std::aligned_storage_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::aligned_storage_t' is a}}
+ std::aligned_union; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::aligned_union' is a}}
+ std::aligned_union_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::aligned_union_t' is a}}
+ std::alignment_of; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::alignment_of' is a}}
+ std::alignment_of_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::alignment_of_v' is a}}
+ std::all_of; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::all_of' is a}}
+ std::allocate_shared; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::allocate_shared' is a}}
+ std::allocate_shared_for_overwrite; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::allocate_shared_for_overwrite' is a}}
+ std::allocation_result; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::allocation_result' is a}}
+ std::allocator; // expected-error {{no member}} expected-note {{maybe try}}
+ std::allocator_arg; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::allocator_arg' is a}}
+ std::allocator_arg_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::allocator_arg_t' is a}}
+ std::allocator_traits; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::allocator_traits' is a}}
+ std::any; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::any' is a}}
+ std::any_cast; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::any_cast' is a}}
+ std::any_of; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::any_of' is a}}
+ std::apply; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::apply' is a}}
+ std::arg; // expected-error {{no member}} expected-note {{maybe try}}
+ std::array; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::array' is a}}
+ std::as_bytes; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::as_bytes' is a}}
+ std::as_const; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::as_const' is a}}
+ std::as_writable_bytes; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::as_writable_bytes' is a}}
+ std::asctime; // expected-error {{no member}} expected-note {{maybe try}}
+ std::asinf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::asinf' is a}}
+ std::asinhf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::asinhf' is a}}
+ std::asinhl; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::asinhl' is a}}
+ std::asinl; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::asinl' is a}}
+ std::assignable_from; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::assignable_from' is a}}
+ std::assoc_laguerre; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::assoc_laguerre' is a}}
+ std::assoc_laguerref; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::assoc_laguerref' is a}}
+ std::assoc_laguerrel; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::assoc_laguerrel' is a}}
+ std::assoc_legendre; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::assoc_legendre' is a}}
+ std::assoc_legendref; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::assoc_legendref' is a}}
+ std::assoc_legendrel; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::assoc_legendrel' is a}}
+ std::assume_aligned; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::assume_aligned' is a}}
+ std::async; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::async' is a}}
+ std::at_quick_exit; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::at_quick_exit' is a}}
+ std::atan2f; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::atan2f' is a}}
+ std::atan2l; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::atan2l' is a}}
+ std::atanf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::atanf' is a}}
+ std::atanhf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::atanhf' is a}}
+ std::atanhl; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::atanhl' is a}}
+ std::atanl; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::atanl' is a}}
+ std::atexit; // expected-error {{no member}} expected-note {{maybe try}}
+ std::atof; // expected-error {{no member}} expected-note {{maybe try}}
+ std::atoi; // expected-error {{no member}} expected-note {{maybe try}}
+ std::atol; // expected-error {{no member}} expected-note {{maybe try}}
+ std::atoll; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::atoll' is a}}
+ std::atomic_compare_exchange_strong; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::atomic_compare_exchange_strong' is a}}
+ std::atomic_compare_exchange_strong_explicit; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::atomic_compare_exchange_strong_explicit' is a}}
+ std::atomic_compare_exchange_weak; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::atomic_compare_exchange_weak' is a}}
+ std::atomic_compare_exchange_weak_explicit; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::atomic_compare_exchange_weak_explicit' is a}}
+ std::atomic_exchange; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::atomic_exchange' is a}}
+ std::atomic_exchange_explicit; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::atomic_exchange_explicit' is a}}
+ std::atomic_fetch_add; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::atomic_fetch_add' is a}}
+ std::atomic_fetch_add_explicit; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::atomic_fetch_add_explicit' is a}}
+ std::atomic_fetch_and; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::atomic_fetch_and' is a}}
+ std::atomic_fetch_and_explicit; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::atomic_fetch_and_explicit' is a}}
+ std::atomic_fetch_max; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::atomic_fetch_max' is a}}
+ std::atomic_fetch_max_explicit; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::atomic_fetch_max_explicit' is a}}
+ std::atomic_fetch_min; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::atomic_fetch_min' is a}}
+ std::atomic_fetch_min_explicit; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::atomic_fetch_min_explicit' is a}}
+ std::atomic_fetch_or; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::atomic_fetch_or' is a}}
+ std::atomic_fetch_or_explicit; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::atomic_fetch_or_explicit' is a}}
+ std::atomic_fetch_sub; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::atomic_fetch_sub' is a}}
+ std::atomic_fetch_sub_explicit; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::atomic_fetch_sub_explicit' is a}}
+ std::atomic_fetch_xor; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::atomic_fetch_xor' is a}}
+ std::atomic_fetch_xor_explicit; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::atomic_fetch_xor_explicit' is a}}
+ std::atomic_flag; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::atomic_flag' is a}}
+ std::atomic_flag_clear; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::atomic_flag_clear' is a}}
+ std::atomic_flag_clear_explicit; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::atomic_flag_clear_explicit' is a}}
+ std::atomic_flag_notify_all; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::atomic_flag_notify_all' is a}}
+ std::atomic_flag_notify_one; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::atomic_flag_notify_one' is a}}
+ std::atomic_flag_test; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::atomic_flag_test' is a}}
+ std::atomic_flag_test_and_set; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::atomic_flag_test_and_set' is a}}
+ std::atomic_flag_test_and_set_explicit; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::atomic_flag_test_and_set_explicit' is a}}
+ std::atomic_flag_test_explicit; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::atomic_flag_test_explicit' is a}}
+ std::atomic_flag_wait; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::atomic_flag_wait' is a}}
+ std::atomic_flag_wait_explicit; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::atomic_flag_wait_explicit' is a}}
+ std::atomic_init; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::atomic_init' is a}}
+ std::atomic_is_lock_free; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::atomic_is_lock_free' is a}}
+ std::atomic_load; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::atomic_load' is a}}
+ std::atomic_load_explicit; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::atomic_load_explicit' is a}}
+ std::atomic_notify_all; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::atomic_notify_all' is a}}
+ std::atomic_notify_one; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::atomic_notify_one' is a}}
+ std::atomic_ref; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::atomic_ref' is a}}
+ std::atomic_signal_fence; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::atomic_signal_fence' is a}}
+ std::atomic_store; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::atomic_store' is a}}
+ std::atomic_store_explicit; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::atomic_store_explicit' is a}}
+ std::atomic_thread_fence; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::atomic_thread_fence' is a}}
+ std::atomic_wait; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::atomic_wait' is a}}
+ std::atomic_wait_explicit; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::atomic_wait_explicit' is a}}
+ std::atto; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::atto' is a}}
+ std::auto_ptr; // expected-error {{no member}} expected-note {{maybe try}}
+ std::back_insert_iterator; // expected-error {{no member}} expected-note {{maybe try}}
+ std::back_inserter; // expected-error {{no member}} expected-note {{maybe try}}
+ std::bad_alloc; // expected-error {{no member}} expected-note {{maybe try}}
+ std::bad_any_cast; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::bad_any_cast' is a}}
+ std::bad_array_new_length; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::bad_array_new_length' is a}}
+ std::bad_cast; // expected-error {{no member}} expected-note {{maybe try}}
+ std::bad_exception; // expected-error {{no member}} expected-note {{maybe try}}
+ std::bad_expected_access; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::bad_expected_access' is a}}
+ std::bad_function_call; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::bad_function_call' is a}}
+ std::bad_optional_access; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::bad_optional_access' is a}}
+ std::bad_typeid; // expected-error {{no member}} expected-note {{maybe try}}
+ std::bad_variant_access; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::bad_variant_access' is a}}
+ std::bad_weak_ptr; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::bad_weak_ptr' is a}}
+ std::barrier; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::barrier' is a}}
+ std::basic_common_reference; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::basic_common_reference' is a}}
+ std::basic_const_iterator; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::basic_const_iterator' is a}}
+ std::basic_filebuf; // expected-error {{no member}} expected-note {{maybe try}}
+ std::basic_filebuf; // expected-error {{no member}} expected-note {{maybe try}}
+ std::basic_format_arg; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::basic_format_arg' is a}}
+ std::basic_format_args; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::basic_format_args' is a}}
+ std::basic_format_context; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::basic_format_context' is a}}
+ std::basic_format_parse_context; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::basic_format_parse_context' is a}}
+ std::basic_format_string; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::basic_format_string' is a}}
+ std::basic_fstream; // expected-error {{no member}} expected-note {{maybe try}}
+ std::basic_fstream; // expected-error {{no member}} expected-note {{maybe try}}
+ std::basic_ifstream; // expected-error {{no member}} expected-note {{maybe try}}
+ std::basic_ifstream; // expected-error {{no member}} expected-note {{maybe try}}
+ std::basic_ios; // expected-error {{no member}} expected-note {{maybe try}}
+ std::basic_ios; // expected-error {{no member}} expected-note {{maybe try}}
+ std::basic_ios; // expected-error {{no member}} expected-note {{maybe try}}
+ std::basic_iostream; // expected-error {{no member}} expected-note {{maybe try}}
+ std::basic_iostream; // expected-error {{no member}} expected-note {{maybe try}}
+ std::basic_iostream; // expected-error {{no member}} expected-note {{maybe try}}
+ std::basic_ispanstream; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::basic_ispanstream' is a}}
+ std::basic_ispanstream; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::basic_ispanstream' is a}}
+ std::basic_istream; // expected-error {{no member}} expected-note {{maybe try}}
+ std::basic_istream; // expected-error {{no member}} expected-note {{maybe try}}
+ std::basic_istream; // expected-error {{no member}} expected-note {{maybe try}}
+ std::basic_istringstream; // expected-error {{no member}} expected-note {{maybe try}}
+ std::basic_istringstream; // expected-error {{no member}} expected-note {{maybe try}}
+ std::basic_ofstream; // expected-error {{no member}} expected-note {{maybe try}}
+ std::basic_ofstream; // expected-error {{no member}} expected-note {{maybe try}}
+ std::basic_ospanstream; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::basic_ospanstream' is a}}
+ std::basic_ospanstream; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::basic_ospanstream' is a}}
+ std::basic_ostream; // expected-error {{no member}} expected-note {{maybe try}}
+ std::basic_ostream; // expected-error {{no member}} expected-note {{maybe try}}
+ std::basic_ostream; // expected-error {{no member}} expected-note {{maybe try}}
+ std::basic_ostringstream; // expected-error {{no member}} expected-note {{maybe try}}
+ std::basic_ostringstream; // expected-error {{no member}} expected-note {{maybe try}}
+ std::basic_osyncstream; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::basic_osyncstream' is a}}
+ std::basic_osyncstream; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::basic_osyncstream' is a}}
+ std::basic_regex; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::basic_regex' is a}}
+ std::basic_spanbuf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::basic_spanbuf' is a}}
+ std::basic_spanbuf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::basic_spanbuf' is a}}
+ std::basic_spanstream; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::basic_spanstream' is a}}
+ std::basic_spanstream; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::basic_spanstream' is a}}
+ std::basic_stacktrace; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::basic_stacktrace' is a}}
+ std::basic_streambuf; // expected-error {{no member}} expected-note {{maybe try}}
+ std::basic_streambuf; // expected-error {{no member}} expected-note {{maybe try}}
+ std::basic_streambuf; // expected-error {{no member}} expected-note {{maybe try}}
+ std::basic_string; // expected-error {{no member}} expected-note {{maybe try}}
+ std::basic_string_view; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::basic_string_view' is a}}
+ std::basic_stringbuf; // expected-error {{no member}} expected-note {{maybe try}}
+ std::basic_stringbuf; // expected-error {{no member}} expected-note {{maybe try}}
+ std::basic_stringstream; // expected-error {{no member}} expected-note {{maybe try}}
+ std::basic_stringstream; // expected-error {{no member}} expected-note {{maybe try}}
+ std::basic_syncbuf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::basic_syncbuf' is a}}
+ std::basic_syncbuf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::basic_syncbuf' is a}}
+ std::bernoulli_distribution; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::bernoulli_distribution' is a}}
+ std::beta; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::beta' is a}}
+ std::betaf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::betaf' is a}}
+ std::betal; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::betal' is a}}
+ std::bidirectional_iterator; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::bidirectional_iterator' is a}}
+ std::bidirectional_iterator_tag; // expected-error {{no member}} expected-note {{maybe try}}
+ std::binary_function; // expected-error {{no member}} expected-note {{maybe try}}
+ std::binary_negate; // expected-error {{no member}} expected-note {{maybe try}}
+ std::binary_search; // expected-error {{no member}} expected-note {{maybe try}}
+ std::binary_semaphore; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::binary_semaphore' is a}}
+ std::bind; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::bind' is a}}
+ std::bind1st; // expected-error {{no member}} expected-note {{maybe try}}
+ std::bind2nd; // expected-error {{no member}} expected-note {{maybe try}}
+ std::bind_back; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::bind_back' is a}}
+ std::bind_front; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::bind_front' is a}}
+ std::binder1st; // expected-error {{no member}} expected-note {{maybe try}}
+ std::binder2nd; // expected-error {{no member}} expected-note {{maybe try}}
+ std::binomial_distribution; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::binomial_distribution' is a}}
+ std::bit_and; // expected-error {{no member}} expected-note {{maybe try}}
+ std::bit_cast; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::bit_cast' is a}}
+ std::bit_ceil; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::bit_ceil' is a}}
+ std::bit_floor; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::bit_floor' is a}}
+ std::bit_not; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::bit_not' is a}}
+ std::bit_or; // expected-error {{no member}} expected-note {{maybe try}}
+ std::bit_width; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::bit_width' is a}}
+ std::bit_xor; // expected-error {{no member}} expected-note {{maybe try}}
+ std::bitset; // expected-error {{no member}} expected-note {{maybe try}}
+ std::bool_constant; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::bool_constant' is a}}
+ std::boolalpha; // expected-error {{no member}} expected-note {{maybe try}}
+ std::boolalpha; // expected-error {{no member}} expected-note {{maybe try}}
+ std::boyer_moore_horspool_searcher; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::boyer_moore_horspool_searcher' is a}}
+ std::boyer_moore_searcher; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::boyer_moore_searcher' is a}}
+ std::breakpoint; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::breakpoint' is a}}
+ std::breakpoint_if_debugging; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::breakpoint_if_debugging' is a}}
+ std::bsearch; // expected-error {{no member}} expected-note {{maybe try}}
+ std::btowc; // expected-error {{no member}} expected-note {{maybe try}}
+ std::byte; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::byte' is a}}
+ std::byteswap; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::byteswap' is a}}
+ std::c16rtomb; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::c16rtomb' is a}}
+ std::c32rtomb; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::c32rtomb' is a}}
+ std::c8rtomb; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::c8rtomb' is a}}
+ std::call_once; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::call_once' is a}}
+ std::calloc; // expected-error {{no member}} expected-note {{maybe try}}
+ std::cauchy_distribution; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::cauchy_distribution' is a}}
+ std::cbrtf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::cbrtf' is a}}
+ std::cbrtl; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::cbrtl' is a}}
+ std::ceilf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ceilf' is a}}
+ std::ceill; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ceill' is a}}
+ std::centi; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::centi' is a}}
+ std::cerr; // expected-error {{no member}} expected-note {{maybe try}}
+ std::char_traits; // expected-error {{no member}} expected-note {{maybe try}}
+ std::chars_format; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chars_format' is a}}
+ std::chi_squared_distribution; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chi_squared_distribution' is a}}
+ std::cin; // expected-error {{no member}} expected-note {{maybe try}}
+ std::clamp; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::clamp' is a}}
+ std::clearerr; // expected-error {{no member}} expected-note {{maybe try}}
+ std::clock; // expected-error {{no member}} expected-note {{maybe try}}
+ std::clock_t; // expected-error {{no member}} expected-note {{maybe try}}
+ std::clog; // expected-error {{no member}} expected-note {{maybe try}}
+ std::cmatch; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::cmatch' is a}}
+ std::cmp_equal; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::cmp_equal' is a}}
+ std::cmp_greater; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::cmp_greater' is a}}
+ std::cmp_greater_equal; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::cmp_greater_equal' is a}}
+ std::cmp_less; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::cmp_less' is a}}
+ std::cmp_less_equal; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::cmp_less_equal' is a}}
+ std::cmp_not_equal; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::cmp_not_equal' is a}}
+ std::codecvt; // expected-error {{no member}} expected-note {{maybe try}}
+ std::codecvt_base; // expected-error {{no member}} expected-note {{maybe try}}
+ std::codecvt_byname; // expected-error {{no member}} expected-note {{maybe try}}
+ std::codecvt_mode; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::codecvt_mode' is a}}
+ std::codecvt_utf16; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::codecvt_utf16' is a}}
+ std::codecvt_utf8; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::codecvt_utf8' is a}}
+ std::codecvt_utf8_utf16; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::codecvt_utf8_utf16' is a}}
+ std::collate; // expected-error {{no member}} expected-note {{maybe try}}
+ std::collate_byname; // expected-error {{no member}} expected-note {{maybe try}}
+ std::common_comparison_category; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::common_comparison_category' is a}}
+ std::common_comparison_category_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::common_comparison_category_t' is a}}
+ std::common_iterator; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::common_iterator' is a}}
+ std::common_reference; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::common_reference' is a}}
+ std::common_reference_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::common_reference_t' is a}}
+ std::common_reference_with; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::common_reference_with' is a}}
+ std::common_type; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::common_type' is a}}
+ std::common_type_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::common_type_t' is a}}
+ std::common_with; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::common_with' is a}}
+ std::comp_ellint_1; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::comp_ellint_1' is a}}
+ std::comp_ellint_1f; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::comp_ellint_1f' is a}}
+ std::comp_ellint_1l; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::comp_ellint_1l' is a}}
+ std::comp_ellint_2; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::comp_ellint_2' is a}}
+ std::comp_ellint_2f; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::comp_ellint_2f' is a}}
+ std::comp_ellint_2l; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::comp_ellint_2l' is a}}
+ std::comp_ellint_3; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::comp_ellint_3' is a}}
+ std::comp_ellint_3f; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::comp_ellint_3f' is a}}
+ std::comp_ellint_3l; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::comp_ellint_3l' is a}}
+ std::compare_partial_order_fallback; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::compare_partial_order_fallback' is a}}
+ std::compare_strong_order_fallback; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::compare_strong_order_fallback' is a}}
+ std::compare_three_way_result; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::compare_three_way_result' is a}}
+ std::compare_three_way_result_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::compare_three_way_result_t' is a}}
+ std::compare_weak_order_fallback; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::compare_weak_order_fallback' is a}}
+ std::complex; // expected-error {{no member}} expected-note {{maybe try}}
+ std::condition_variable; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::condition_variable' is a}}
+ std::condition_variable_any; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::condition_variable_any' is a}}
+ std::conditional; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::conditional' is a}}
+ std::conditional_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::conditional_t' is a}}
+ std::conj; // expected-error {{no member}} expected-note {{maybe try}}
+ std::conjunction; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::conjunction' is a}}
+ std::conjunction_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::conjunction_v' is a}}
+ std::const_iterator; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::const_iterator' is a}}
+ std::const_mem_fun1_ref_t; // expected-error {{no member}} expected-note {{maybe try}}
+ std::const_mem_fun1_t; // expected-error {{no member}} expected-note {{maybe try}}
+ std::const_mem_fun_ref_t; // expected-error {{no member}} expected-note {{maybe try}}
+ std::const_mem_fun_t; // expected-error {{no member}} expected-note {{maybe try}}
+ std::const_pointer_cast; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::const_pointer_cast' is a}}
+ std::const_sentinel; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::const_sentinel' is a}}
+ std::construct_at; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::construct_at' is a}}
+ std::constructible_from; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::constructible_from' is a}}
+ std::contiguous_iterator; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::contiguous_iterator' is a}}
+ std::contiguous_iterator_tag; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::contiguous_iterator_tag' is a}}
+ std::convertible_to; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::convertible_to' is a}}
+ std::copy; // expected-error {{no member}} expected-note {{maybe try}}
+ std::copy_backward; // expected-error {{no member}} expected-note {{maybe try}}
+ std::copy_constructible; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::copy_constructible' is a}}
+ std::copy_if; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::copy_if' is a}}
+ std::copy_n; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::copy_n' is a}}
+ std::copyable; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::copyable' is a}}
+ std::copyable_function; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::copyable_function' is a}}
+ std::copysignf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::copysignf' is a}}
+ std::copysignl; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::copysignl' is a}}
+ std::coroutine_handle; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::coroutine_handle' is a}}
+ std::coroutine_traits; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::coroutine_traits' is a}}
+ std::cosf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::cosf' is a}}
+ std::coshf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::coshf' is a}}
+ std::coshl; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::coshl' is a}}
+ std::cosl; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::cosl' is a}}
+ std::count; // expected-error {{no member}} expected-note {{maybe try}}
+ std::count_if; // expected-error {{no member}} expected-note {{maybe try}}
+ std::counted_iterator; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::counted_iterator' is a}}
+ std::counting_semaphore; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::counting_semaphore' is a}}
+ std::countl_one; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::countl_one' is a}}
+ std::countl_zero; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::countl_zero' is a}}
+ std::countr_one; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::countr_one' is a}}
+ std::countr_zero; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::countr_zero' is a}}
+ std::cout; // expected-error {{no member}} expected-note {{maybe try}}
+ std::cref; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::cref' is a}}
+ std::cregex_iterator; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::cregex_iterator' is a}}
+ std::cregex_token_iterator; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::cregex_token_iterator' is a}}
+ std::csub_match; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::csub_match' is a}}
+ std::ctime; // expected-error {{no member}} expected-note {{maybe try}}
+ std::ctype; // expected-error {{no member}} expected-note {{maybe try}}
+ std::ctype_base; // expected-error {{no member}} expected-note {{maybe try}}
+ std::ctype_byname; // expected-error {{no member}} expected-note {{maybe try}}
+ std::current_exception; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::current_exception' is a}}
+ std::cv_status; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::cv_status' is a}}
+ std::cyl_bessel_i; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::cyl_bessel_i' is a}}
+ std::cyl_bessel_if; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::cyl_bessel_if' is a}}
+ std::cyl_bessel_il; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::cyl_bessel_il' is a}}
+ std::cyl_bessel_j; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::cyl_bessel_j' is a}}
+ std::cyl_bessel_jf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::cyl_bessel_jf' is a}}
+ std::cyl_bessel_jl; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::cyl_bessel_jl' is a}}
+ std::cyl_bessel_k; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::cyl_bessel_k' is a}}
+ std::cyl_bessel_kf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::cyl_bessel_kf' is a}}
+ std::cyl_bessel_kl; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::cyl_bessel_kl' is a}}
+ std::cyl_neumann; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::cyl_neumann' is a}}
+ std::cyl_neumannf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::cyl_neumannf' is a}}
+ std::cyl_neumannl; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::cyl_neumannl' is a}}
+ std::dec; // expected-error {{no member}} expected-note {{maybe try}}
+ std::dec; // expected-error {{no member}} expected-note {{maybe try}}
+ std::deca; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::deca' is a}}
+ std::decay; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::decay' is a}}
+ std::decay_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::decay_t' is a}}
+ std::deci; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::deci' is a}}
+ std::declare_no_pointers; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::declare_no_pointers' is a}}
+ std::declare_reachable; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::declare_reachable' is a}}
+ std::declval; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::declval' is a}}
+ std::default_accessor; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::default_accessor' is a}}
+ std::default_delete; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::default_delete' is a}}
+ std::default_initializable; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::default_initializable' is a}}
+ std::default_random_engine; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::default_random_engine' is a}}
+ std::default_searcher; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::default_searcher' is a}}
+ std::default_sentinel; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::default_sentinel' is a}}
+ std::default_sentinel_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::default_sentinel_t' is a}}
+ std::defaultfloat; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::defaultfloat' is a}}
+ std::defaultfloat; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::defaultfloat' is a}}
+ std::defer_lock; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::defer_lock' is a}}
+ std::defer_lock_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::defer_lock_t' is a}}
+ std::denorm_absent; // expected-error {{no member}} expected-note {{maybe try}}
+ std::denorm_indeterminate; // expected-error {{no member}} expected-note {{maybe try}}
+ std::denorm_present; // expected-error {{no member}} expected-note {{maybe try}}
+ std::deque; // expected-error {{no member}} expected-note {{maybe try}}
+ std::derived_from; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::derived_from' is a}}
+ std::destroy; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::destroy' is a}}
+ std::destroy_at; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::destroy_at' is a}}
+ std::destroy_n; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::destroy_n' is a}}
+ std::destroying_delete; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::destroying_delete' is a}}
+ std::destroying_delete_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::destroying_delete_t' is a}}
+ std::destructible; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::destructible' is a}}
+ std::dextents; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::dextents' is a}}
+ std::difftime; // expected-error {{no member}} expected-note {{maybe try}}
+ std::dims; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::dims' is a}}
+ std::disable_sized_sentinel_for; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::disable_sized_sentinel_for' is a}}
+ std::discard_block_engine; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::discard_block_engine' is a}}
+ std::discrete_distribution; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::discrete_distribution' is a}}
+ std::disjunction; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::disjunction' is a}}
+ std::disjunction_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::disjunction_v' is a}}
+ std::distance; // expected-error {{no member}} expected-note {{maybe try}}
+ std::div_sat; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::div_sat' is a}}
+ std::div_t; // expected-error {{no member}} expected-note {{maybe try}}
+ std::divides; // expected-error {{no member}} expected-note {{maybe try}}
+ std::domain_error; // expected-error {{no member}} expected-note {{maybe try}}
+ std::double_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::double_t' is a}}
+ std::dynamic_extent; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::dynamic_extent' is a}}
+ std::dynamic_pointer_cast; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::dynamic_pointer_cast' is a}}
+ std::ellint_1; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ellint_1' is a}}
+ std::ellint_1f; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ellint_1f' is a}}
+ std::ellint_1l; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ellint_1l' is a}}
+ std::ellint_2; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ellint_2' is a}}
+ std::ellint_2f; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ellint_2f' is a}}
+ std::ellint_2l; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ellint_2l' is a}}
+ std::ellint_3; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ellint_3' is a}}
+ std::ellint_3f; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ellint_3f' is a}}
+ std::ellint_3l; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ellint_3l' is a}}
+ std::emit_on_flush; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::emit_on_flush' is a}}
+ std::emit_on_flush; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::emit_on_flush' is a}}
+ std::enable_if; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::enable_if' is a}}
+ std::enable_if_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::enable_if_t' is a}}
+ std::enable_nonlocking_formatter_optimization; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::enable_nonlocking_formatter_optimization' is a}}
+ std::enable_shared_from_this; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::enable_shared_from_this' is a}}
+ std::endian; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::endian' is a}}
+ std::endl; // expected-error {{no member}} expected-note {{maybe try}}
+ std::endl; // expected-error {{no member}} expected-note {{maybe try}}
+ std::ends; // expected-error {{no member}} expected-note {{maybe try}}
+ std::ends; // expected-error {{no member}} expected-note {{maybe try}}
+ std::equal; // expected-error {{no member}} expected-note {{maybe try}}
+ std::equal_range; // expected-error {{no member}} expected-note {{maybe try}}
+ std::equal_to; // expected-error {{no member}} expected-note {{maybe try}}
+ std::equality_comparable; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::equality_comparable' is a}}
+ std::equality_comparable_with; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::equality_comparable_with' is a}}
+ std::equivalence_relation; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::equivalence_relation' is a}}
+ std::erfcf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::erfcf' is a}}
+ std::erfcl; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::erfcl' is a}}
+ std::erff; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::erff' is a}}
+ std::erfl; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::erfl' is a}}
+ std::errc; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::errc' is a}}
+ std::error_category; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::error_category' is a}}
+ std::error_code; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::error_code' is a}}
+ std::error_condition; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::error_condition' is a}}
+ std::exa; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::exa' is a}}
+ std::exception; // expected-error {{no member}} expected-note {{maybe try}}
+ std::exception_ptr; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::exception_ptr' is a}}
+ std::exchange; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::exchange' is a}}
+ std::exclusive_scan; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::exclusive_scan' is a}}
+ std::exit; // expected-error {{no member}} expected-note {{maybe try}}
+ std::exp2f; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::exp2f' is a}}
+ std::exp2l; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::exp2l' is a}}
+ std::expected; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::expected' is a}}
+ std::expf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::expf' is a}}
+ std::expint; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::expint' is a}}
+ std::expintf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::expintf' is a}}
+ std::expintl; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::expintl' is a}}
+ std::expl; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::expl' is a}}
+ std::expm1f; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::expm1f' is a}}
+ std::expm1l; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::expm1l' is a}}
+ std::exponential_distribution; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::exponential_distribution' is a}}
+ std::extent; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::extent' is a}}
+ std::extent_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::extent_v' is a}}
+ std::extents; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::extents' is a}}
+ std::extreme_value_distribution; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::extreme_value_distribution' is a}}
+ std::fabs; // expected-error {{no member}} expected-note {{maybe try}}
+ std::fabsf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::fabsf' is a}}
+ std::fabsl; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::fabsl' is a}}
+ std::false_type; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::false_type' is a}}
+ std::fclose; // expected-error {{no member}} expected-note {{maybe try}}
+ std::fdimf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::fdimf' is a}}
+ std::fdiml; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::fdiml' is a}}
+ std::feclearexcept; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::feclearexcept' is a}}
+ std::fegetenv; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::fegetenv' is a}}
+ std::fegetexceptflag; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::fegetexceptflag' is a}}
+ std::fegetround; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::fegetround' is a}}
+ std::feholdexcept; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::feholdexcept' is a}}
+ std::femto; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::femto' is a}}
+ std::fenv_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::fenv_t' is a}}
+ std::feof; // expected-error {{no member}} expected-note {{maybe try}}
+ std::feraiseexcept; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::feraiseexcept' is a}}
+ std::ferror; // expected-error {{no member}} expected-note {{maybe try}}
+ std::fesetenv; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::fesetenv' is a}}
+ std::fesetexceptflag; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::fesetexceptflag' is a}}
+ std::fesetround; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::fesetround' is a}}
+ std::fetestexcept; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::fetestexcept' is a}}
+ std::feupdateenv; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::feupdateenv' is a}}
+ std::fexcept_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::fexcept_t' is a}}
+ std::fflush; // expected-error {{no member}} expected-note {{maybe try}}
+ std::fgetc; // expected-error {{no member}} expected-note {{maybe try}}
+ std::fgetpos; // expected-error {{no member}} expected-note {{maybe try}}
+ std::fgets; // expected-error {{no member}} expected-note {{maybe try}}
+ std::fgetwc; // expected-error {{no member}} expected-note {{maybe try}}
+ std::fgetws; // expected-error {{no member}} expected-note {{maybe try}}
+ std::filebuf; // expected-error {{no member}} expected-note {{maybe try}}
+ std::filebuf; // expected-error {{no member}} expected-note {{maybe try}}
+ std::fill; // expected-error {{no member}} expected-note {{maybe try}}
+ std::fill_n; // expected-error {{no member}} expected-note {{maybe try}}
+ std::find; // expected-error {{no member}} expected-note {{maybe try}}
+ std::find_end; // expected-error {{no member}} expected-note {{maybe try}}
+ std::find_first_of; // expected-error {{no member}} expected-note {{maybe try}}
+ std::find_if; // expected-error {{no member}} expected-note {{maybe try}}
+ std::find_if_not; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::find_if_not' is a}}
+ std::fisher_f_distribution; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::fisher_f_distribution' is a}}
+ std::fixed; // expected-error {{no member}} expected-note {{maybe try}}
+ std::fixed; // expected-error {{no member}} expected-note {{maybe try}}
+ std::flat_map; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::flat_map' is a}}
+ std::flat_multimap; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::flat_multimap' is a}}
+ std::flat_multiset; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::flat_multiset' is a}}
+ std::flat_set; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::flat_set' is a}}
+ std::float_denorm_style; // expected-error {{no member}} expected-note {{maybe try}}
+ std::float_round_style; // expected-error {{no member}} expected-note {{maybe try}}
+ std::float_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::float_t' is a}}
+ std::floating_point; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::floating_point' is a}}
+ std::floorf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::floorf' is a}}
+ std::floorl; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::floorl' is a}}
+ std::flush; // expected-error {{no member}} expected-note {{maybe try}}
+ std::flush; // expected-error {{no member}} expected-note {{maybe try}}
+ std::flush_emit; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::flush_emit' is a}}
+ std::flush_emit; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::flush_emit' is a}}
+ std::fma; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::fma' is a}}
+ std::fmaf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::fmaf' is a}}
+ std::fmal; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::fmal' is a}}
+ std::fmaxf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::fmaxf' is a}}
+ std::fmaxl; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::fmaxl' is a}}
+ std::fminf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::fminf' is a}}
+ std::fminl; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::fminl' is a}}
+ std::fmodf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::fmodf' is a}}
+ std::fmodl; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::fmodl' is a}}
+ std::fopen; // expected-error {{no member}} expected-note {{maybe try}}
+ std::for_each; // expected-error {{no member}} expected-note {{maybe try}}
+ std::for_each_n; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::for_each_n' is a}}
+ std::format; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::format' is a}}
+ std::format_args; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::format_args' is a}}
+ std::format_context; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::format_context' is a}}
+ std::format_error; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::format_error' is a}}
+ std::format_kind; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::format_kind' is a}}
+ std::format_parse_context; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::format_parse_context' is a}}
+ std::format_string; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::format_string' is a}}
+ std::format_to; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::format_to' is a}}
+ std::format_to_n; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::format_to_n' is a}}
+ std::format_to_n_result; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::format_to_n_result' is a}}
+ std::formattable; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::formattable' is a}}
+ std::formatted_size; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::formatted_size' is a}}
+ std::formatter; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::formatter' is a}}
+ std::forward; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::forward' is a}}
+ std::forward_as_tuple; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::forward_as_tuple' is a}}
+ std::forward_iterator; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::forward_iterator' is a}}
+ std::forward_iterator_tag; // expected-error {{no member}} expected-note {{maybe try}}
+ std::forward_like; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::forward_like' is a}}
+ std::forward_list; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::forward_list' is a}}
+ std::fpclassify; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::fpclassify' is a}}
+ std::fpos; // expected-error {{no member}} expected-note {{maybe try}}
+ std::fpos; // expected-error {{no member}} expected-note {{maybe try}}
+ std::fpos; // expected-error {{no member}} expected-note {{maybe try}}
+ std::fpos_t; // expected-error {{no member}} expected-note {{maybe try}}
+ std::fprintf; // expected-error {{no member}} expected-note {{maybe try}}
+ std::fputc; // expected-error {{no member}} expected-note {{maybe try}}
+ std::fputs; // expected-error {{no member}} expected-note {{maybe try}}
+ std::fputwc; // expected-error {{no member}} expected-note {{maybe try}}
+ std::fputws; // expected-error {{no member}} expected-note {{maybe try}}
+ std::fread; // expected-error {{no member}} expected-note {{maybe try}}
+ std::free; // expected-error {{no member}} expected-note {{maybe try}}
+ std::freopen; // expected-error {{no member}} expected-note {{maybe try}}
+ std::frexp; // expected-error {{no member}} expected-note {{maybe try}}
+ std::frexpf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::frexpf' is a}}
+ std::frexpl; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::frexpl' is a}}
+ std::from_chars; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::from_chars' is a}}
+ std::from_chars_result; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::from_chars_result' is a}}
+ std::from_range; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::from_range' is a}}
+ std::from_range_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::from_range_t' is a}}
+ std::front_insert_iterator; // expected-error {{no member}} expected-note {{maybe try}}
+ std::front_inserter; // expected-error {{no member}} expected-note {{maybe try}}
+ std::fscanf; // expected-error {{no member}} expected-note {{maybe try}}
+ std::fseek; // expected-error {{no member}} expected-note {{maybe try}}
+ std::fsetpos; // expected-error {{no member}} expected-note {{maybe try}}
+ std::fstream; // expected-error {{no member}} expected-note {{maybe try}}
+ std::fstream; // expected-error {{no member}} expected-note {{maybe try}}
+ std::ftell; // expected-error {{no member}} expected-note {{maybe try}}
+ std::function; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::function' is a}}
+ std::function_ref; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::function_ref' is a}}
+ std::future; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::future' is a}}
+ std::future_category; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::future_category' is a}}
+ std::future_errc; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::future_errc' is a}}
+ std::future_error; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::future_error' is a}}
+ std::future_status; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::future_status' is a}}
+ std::fwide; // expected-error {{no member}} expected-note {{maybe try}}
+ std::fwprintf; // expected-error {{no member}} expected-note {{maybe try}}
+ std::fwrite; // expected-error {{no member}} expected-note {{maybe try}}
+ std::fwscanf; // expected-error {{no member}} expected-note {{maybe try}}
+ std::gamma_distribution; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::gamma_distribution' is a}}
+ std::gcd; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::gcd' is a}}
+ std::generate; // expected-error {{no member}} expected-note {{maybe try}}
+ std::generate_canonical; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::generate_canonical' is a}}
+ std::generate_n; // expected-error {{no member}} expected-note {{maybe try}}
+ std::generator; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::generator' is a}}
+ std::generic_category; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::generic_category' is a}}
+ std::geometric_distribution; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::geometric_distribution' is a}}
+ std::get_deleter; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::get_deleter' is a}}
+ std::get_if; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::get_if' is a}}
+ std::get_money; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::get_money' is a}}
+ std::get_new_handler; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::get_new_handler' is a}}
+ std::get_pointer_safety; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::get_pointer_safety' is a}}
+ std::get_temporary_buffer; // expected-error {{no member}} expected-note {{maybe try}}
+ std::get_terminate; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::get_terminate' is a}}
+ std::get_time; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::get_time' is a}}
+ std::get_unexpected; // expected-error {{no member}} expected-note {{maybe try}}
+ std::getc; // expected-error {{no member}} expected-note {{maybe try}}
+ std::getchar; // expected-error {{no member}} expected-note {{maybe try}}
+ std::getenv; // expected-error {{no member}} expected-note {{maybe try}}
+ std::getline; // expected-error {{no member}} expected-note {{maybe try}}
+ std::gets; // expected-error {{no member}} expected-note {{maybe try}}
+ std::getwc; // expected-error {{no member}} expected-note {{maybe try}}
+ std::getwchar; // expected-error {{no member}} expected-note {{maybe try}}
+ std::giga; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::giga' is a}}
+ std::gmtime; // expected-error {{no member}} expected-note {{maybe try}}
+ std::greater; // expected-error {{no member}} expected-note {{maybe try}}
+ std::greater_equal; // expected-error {{no member}} expected-note {{maybe try}}
+ std::gslice; // expected-error {{no member}} expected-note {{maybe try}}
+ std::gslice_array; // expected-error {{no member}} expected-note {{maybe try}}
+ std::hardware_constructive_interference_size; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::hardware_constructive_interference_size' is a}}
+ std::hardware_destructive_interference_size; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::hardware_destructive_interference_size' is a}}
+ std::has_facet; // expected-error {{no member}} expected-note {{maybe try}}
+ std::has_single_bit; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::has_single_bit' is a}}
+ std::has_unique_object_representations; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::has_unique_object_representations' is a}}
+ std::has_unique_object_representations_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::has_unique_object_representations_v' is a}}
+ std::has_virtual_destructor; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::has_virtual_destructor' is a}}
+ std::has_virtual_destructor_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::has_virtual_destructor_v' is a}}
+ std::hecto; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::hecto' is a}}
+ std::hermite; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::hermite' is a}}
+ std::hermitef; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::hermitef' is a}}
+ std::hermitel; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::hermitel' is a}}
+ std::hex; // expected-error {{no member}} expected-note {{maybe try}}
+ std::hex; // expected-error {{no member}} expected-note {{maybe try}}
+ std::hexfloat; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::hexfloat' is a}}
+ std::hexfloat; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::hexfloat' is a}}
+ std::holds_alternative; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::holds_alternative' is a}}
+ std::hypot; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::hypot' is a}}
+ std::hypotf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::hypotf' is a}}
+ std::hypotl; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::hypotl' is a}}
+ std::identity; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::identity' is a}}
+ std::ifstream; // expected-error {{no member}} expected-note {{maybe try}}
+ std::ifstream; // expected-error {{no member}} expected-note {{maybe try}}
+ std::ilogb; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ilogb' is a}}
+ std::ilogbf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ilogbf' is a}}
+ std::ilogbl; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ilogbl' is a}}
+ std::imag; // expected-error {{no member}} expected-note {{maybe try}}
+ std::imaxabs; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::imaxabs' is a}}
+ std::imaxdiv; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::imaxdiv' is a}}
+ std::imaxdiv_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::imaxdiv_t' is a}}
+ std::in_place; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::in_place' is a}}
+ std::in_place_index; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::in_place_index' is a}}
+ std::in_place_index_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::in_place_index_t' is a}}
+ std::in_place_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::in_place_t' is a}}
+ std::in_place_type; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::in_place_type' is a}}
+ std::in_place_type_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::in_place_type_t' is a}}
+ std::in_range; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::in_range' is a}}
+ std::includes; // expected-error {{no member}} expected-note {{maybe try}}
+ std::inclusive_scan; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::inclusive_scan' is a}}
+ std::incrementable; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::incrementable' is a}}
+ std::incrementable_traits; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::incrementable_traits' is a}}
+ std::independent_bits_engine; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::independent_bits_engine' is a}}
+ std::index_sequence; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::index_sequence' is a}}
+ std::index_sequence_for; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::index_sequence_for' is a}}
+ std::indirect_array; // expected-error {{no member}} expected-note {{maybe try}}
+ std::indirect_binary_predicate; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::indirect_binary_predicate' is a}}
+ std::indirect_equivalence_relation; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::indirect_equivalence_relation' is a}}
+ std::indirect_result_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::indirect_result_t' is a}}
+ std::indirect_strict_weak_order; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::indirect_strict_weak_order' is a}}
+ std::indirect_unary_predicate; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::indirect_unary_predicate' is a}}
+ std::indirectly_comparable; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::indirectly_comparable' is a}}
+ std::indirectly_copyable; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::indirectly_copyable' is a}}
+ std::indirectly_copyable_storable; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::indirectly_copyable_storable' is a}}
+ std::indirectly_movable; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::indirectly_movable' is a}}
+ std::indirectly_movable_storable; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::indirectly_movable_storable' is a}}
+ std::indirectly_readable; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::indirectly_readable' is a}}
+ std::indirectly_readable_traits; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::indirectly_readable_traits' is a}}
+ std::indirectly_regular_unary_invocable; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::indirectly_regular_unary_invocable' is a}}
+ std::indirectly_swappable; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::indirectly_swappable' is a}}
+ std::indirectly_unary_invocable; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::indirectly_unary_invocable' is a}}
+ std::indirectly_writable; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::indirectly_writable' is a}}
+ std::initializer_list; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::initializer_list' is a}}
+ std::inner_product; // expected-error {{no member}} expected-note {{maybe try}}
+ std::inout_ptr; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::inout_ptr' is a}}
+ std::inout_ptr_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::inout_ptr_t' is a}}
+ std::inplace_merge; // expected-error {{no member}} expected-note {{maybe try}}
+ std::inplace_vector; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::inplace_vector' is a}}
+ std::input_iterator; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::input_iterator' is a}}
+ std::input_iterator_tag; // expected-error {{no member}} expected-note {{maybe try}}
+ std::input_or_output_iterator; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::input_or_output_iterator' is a}}
+ std::insert_iterator; // expected-error {{no member}} expected-note {{maybe try}}
+ std::inserter; // expected-error {{no member}} expected-note {{maybe try}}
+ std::int16_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::int16_t' is a}}
+ std::int32_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::int32_t' is a}}
+ std::int64_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::int64_t' is a}}
+ std::int8_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::int8_t' is a}}
+ std::int_fast16_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::int_fast16_t' is a}}
+ std::int_fast32_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::int_fast32_t' is a}}
+ std::int_fast64_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::int_fast64_t' is a}}
+ std::int_fast8_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::int_fast8_t' is a}}
+ std::int_least16_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::int_least16_t' is a}}
+ std::int_least32_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::int_least32_t' is a}}
+ std::int_least64_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::int_least64_t' is a}}
+ std::int_least8_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::int_least8_t' is a}}
+ std::integer_sequence; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::integer_sequence' is a}}
+ std::integral; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::integral' is a}}
+ std::integral_constant; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::integral_constant' is a}}
+ std::internal; // expected-error {{no member}} expected-note {{maybe try}}
+ std::internal; // expected-error {{no member}} expected-note {{maybe try}}
+ std::intmax_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::intmax_t' is a}}
+ std::intptr_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::intptr_t' is a}}
+ std::invalid_argument; // expected-error {{no member}} expected-note {{maybe try}}
+ std::invocable; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::invocable' is a}}
+ std::invoke; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::invoke' is a}}
+ std::invoke_r; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::invoke_r' is a}}
+ std::invoke_result; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::invoke_result' is a}}
+ std::invoke_result_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::invoke_result_t' is a}}
+ std::io_errc; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::io_errc' is a}}
+ std::io_errc; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::io_errc' is a}}
+ std::io_state; // expected-error {{no member}} expected-note {{maybe try}}
+ std::io_state; // expected-error {{no member}} expected-note {{maybe try}}
+ std::ios; // expected-error {{no member}} expected-note {{maybe try}}
+ std::ios; // expected-error {{no member}} expected-note {{maybe try}}
+ std::ios; // expected-error {{no member}} expected-note {{maybe try}}
+ std::ios_base; // expected-error {{no member}} expected-note {{maybe try}}
+ std::ios_base; // expected-error {{no member}} expected-note {{maybe try}}
+ std::iostream; // expected-error {{no member}} expected-note {{maybe try}}
+ std::iostream; // expected-error {{no member}} expected-note {{maybe try}}
+ std::iostream; // expected-error {{no member}} expected-note {{maybe try}}
+ std::iostream_category; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::iostream_category' is a}}
+ std::iostream_category; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::iostream_category' is a}}
+ std::iota; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::iota' is a}}
+ std::is_abstract; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_abstract' is a}}
+ std::is_abstract_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_abstract_v' is a}}
+ std::is_aggregate; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_aggregate' is a}}
+ std::is_aggregate_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_aggregate_v' is a}}
+ std::is_arithmetic; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_arithmetic' is a}}
+ std::is_arithmetic_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_arithmetic_v' is a}}
+ std::is_array; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_array' is a}}
+ std::is_array_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_array_v' is a}}
+ std::is_assignable; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_assignable' is a}}
+ std::is_assignable_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_assignable_v' is a}}
+ std::is_base_of; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_base_of' is a}}
+ std::is_base_of_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_base_of_v' is a}}
+ std::is_bind_expression; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_bind_expression' is a}}
+ std::is_bind_expression_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_bind_expression_v' is a}}
+ std::is_bounded_array; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_bounded_array' is a}}
+ std::is_bounded_array_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_bounded_array_v' is a}}
+ std::is_class; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_class' is a}}
+ std::is_class_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_class_v' is a}}
+ std::is_compound; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_compound' is a}}
+ std::is_compound_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_compound_v' is a}}
+ std::is_const; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_const' is a}}
+ std::is_const_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_const_v' is a}}
+ std::is_constant_evaluated; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_constant_evaluated' is a}}
+ std::is_constructible; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_constructible' is a}}
+ std::is_constructible_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_constructible_v' is a}}
+ std::is_convertible; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_convertible' is a}}
+ std::is_convertible_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_convertible_v' is a}}
+ std::is_copy_assignable; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_copy_assignable' is a}}
+ std::is_copy_assignable_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_copy_assignable_v' is a}}
+ std::is_copy_constructible; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_copy_constructible' is a}}
+ std::is_copy_constructible_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_copy_constructible_v' is a}}
+ std::is_corresponding_member; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_corresponding_member' is a}}
+ std::is_debugger_present; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_debugger_present' is a}}
+ std::is_default_constructible; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_default_constructible' is a}}
+ std::is_default_constructible_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_default_constructible_v' is a}}
+ std::is_destructible; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_destructible' is a}}
+ std::is_destructible_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_destructible_v' is a}}
+ std::is_empty; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_empty' is a}}
+ std::is_empty_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_empty_v' is a}}
+ std::is_enum; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_enum' is a}}
+ std::is_enum_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_enum_v' is a}}
+ std::is_eq; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_eq' is a}}
+ std::is_error_code_enum; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_error_code_enum' is a}}
+ std::is_error_condition_enum; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_error_condition_enum' is a}}
+ std::is_error_condition_enum_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_error_condition_enum_v' is a}}
+ std::is_execution_policy; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_execution_policy' is a}}
+ std::is_execution_policy_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_execution_policy_v' is a}}
+ std::is_final; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_final' is a}}
+ std::is_final_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_final_v' is a}}
+ std::is_floating_point; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_floating_point' is a}}
+ std::is_floating_point_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_floating_point_v' is a}}
+ std::is_function; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_function' is a}}
+ std::is_function_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_function_v' is a}}
+ std::is_fundamental; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_fundamental' is a}}
+ std::is_fundamental_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_fundamental_v' is a}}
+ std::is_gt; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_gt' is a}}
+ std::is_gteq; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_gteq' is a}}
+ std::is_heap; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_heap' is a}}
+ std::is_heap_until; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_heap_until' is a}}
+ std::is_implicit_lifetime; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_implicit_lifetime' is a}}
+ std::is_integral; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_integral' is a}}
+ std::is_integral_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_integral_v' is a}}
+ std::is_invocable; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_invocable' is a}}
+ std::is_invocable_r; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_invocable_r' is a}}
+ std::is_invocable_r_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_invocable_r_v' is a}}
+ std::is_invocable_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_invocable_v' is a}}
+ std::is_layout_compatible; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_layout_compatible' is a}}
+ std::is_layout_compatible_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_layout_compatible_v' is a}}
+ std::is_literal_type; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_literal_type' is a}}
+ std::is_literal_type_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_literal_type_v' is a}}
+ std::is_lt; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_lt' is a}}
+ std::is_lteq; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_lteq' is a}}
+ std::is_lvalue_reference; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_lvalue_reference' is a}}
+ std::is_lvalue_reference_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_lvalue_reference_v' is a}}
+ std::is_member_function_pointer; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_member_function_pointer' is a}}
+ std::is_member_function_pointer_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_member_function_pointer_v' is a}}
+ std::is_member_object_pointer; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_member_object_pointer' is a}}
+ std::is_member_object_pointer_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_member_object_pointer_v' is a}}
+ std::is_member_pointer; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_member_pointer' is a}}
+ std::is_member_pointer_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_member_pointer_v' is a}}
+ std::is_move_assignable; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_move_assignable' is a}}
+ std::is_move_assignable_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_move_assignable_v' is a}}
+ std::is_move_constructible; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_move_constructible' is a}}
+ std::is_move_constructible_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_move_constructible_v' is a}}
+ std::is_neq; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_neq' is a}}
+ std::is_nothrow_assignable; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_nothrow_assignable' is a}}
+ std::is_nothrow_assignable_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_nothrow_assignable_v' is a}}
+ std::is_nothrow_constructible; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_nothrow_constructible' is a}}
+ std::is_nothrow_constructible_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_nothrow_constructible_v' is a}}
+ std::is_nothrow_convertible; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_nothrow_convertible' is a}}
+ std::is_nothrow_convertible_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_nothrow_convertible_v' is a}}
+ std::is_nothrow_copy_assignable; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_nothrow_copy_assignable' is a}}
+ std::is_nothrow_copy_assignable_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_nothrow_copy_assignable_v' is a}}
+ std::is_nothrow_copy_constructible; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_nothrow_copy_constructible' is a}}
+ std::is_nothrow_copy_constructible_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_nothrow_copy_constructible_v' is a}}
+ std::is_nothrow_default_constructible; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_nothrow_default_constructible' is a}}
+ std::is_nothrow_default_constructible_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_nothrow_default_constructible_v' is a}}
+ std::is_nothrow_destructible; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_nothrow_destructible' is a}}
+ std::is_nothrow_destructible_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_nothrow_destructible_v' is a}}
+ std::is_nothrow_invocable; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_nothrow_invocable' is a}}
+ std::is_nothrow_invocable_r; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_nothrow_invocable_r' is a}}
+ std::is_nothrow_invocable_r_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_nothrow_invocable_r_v' is a}}
+ std::is_nothrow_invocable_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_nothrow_invocable_v' is a}}
+ std::is_nothrow_move_assignable; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_nothrow_move_assignable' is a}}
+ std::is_nothrow_move_assignable_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_nothrow_move_assignable_v' is a}}
+ std::is_nothrow_move_constructible; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_nothrow_move_constructible' is a}}
+ std::is_nothrow_move_constructible_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_nothrow_move_constructible_v' is a}}
+ std::is_nothrow_swappable; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_nothrow_swappable' is a}}
+ std::is_nothrow_swappable_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_nothrow_swappable_v' is a}}
+ std::is_nothrow_swappable_with; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_nothrow_swappable_with' is a}}
+ std::is_nothrow_swappable_with_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_nothrow_swappable_with_v' is a}}
+ std::is_null_pointer; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_null_pointer' is a}}
+ std::is_null_pointer_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_null_pointer_v' is a}}
+ std::is_object; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_object' is a}}
+ std::is_object_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_object_v' is a}}
+ std::is_partitioned; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_partitioned' is a}}
+ std::is_permutation; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_permutation' is a}}
+ std::is_placeholder; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_placeholder' is a}}
+ std::is_placeholder_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_placeholder_v' is a}}
+ std::is_pod; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_pod' is a}}
+ std::is_pod_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_pod_v' is a}}
+ std::is_pointer; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_pointer' is a}}
+ std::is_pointer_interconvertible_base_of; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_pointer_interconvertible_base_of' is a}}
+ std::is_pointer_interconvertible_base_of_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_pointer_interconvertible_base_of_v' is a}}
+ std::is_pointer_interconvertible_with_class; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_pointer_interconvertible_with_class' is a}}
+ std::is_pointer_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_pointer_v' is a}}
+ std::is_polymorphic; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_polymorphic' is a}}
+ std::is_polymorphic_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_polymorphic_v' is a}}
+ std::is_reference; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_reference' is a}}
+ std::is_reference_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_reference_v' is a}}
+ std::is_rvalue_reference; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_rvalue_reference' is a}}
+ std::is_rvalue_reference_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_rvalue_reference_v' is a}}
+ std::is_same; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_same' is a}}
+ std::is_same_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_same_v' is a}}
+ std::is_scalar; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_scalar' is a}}
+ std::is_scalar_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_scalar_v' is a}}
+ std::is_scoped_enum; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_scoped_enum' is a}}
+ std::is_scoped_enum_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_scoped_enum_v' is a}}
+ std::is_signed; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_signed' is a}}
+ std::is_signed_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_signed_v' is a}}
+ std::is_sorted; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_sorted' is a}}
+ std::is_sorted_until; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_sorted_until' is a}}
+ std::is_standard_layout; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_standard_layout' is a}}
+ std::is_standard_layout_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_standard_layout_v' is a}}
+ std::is_swappable; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_swappable' is a}}
+ std::is_swappable_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_swappable_v' is a}}
+ std::is_swappable_with; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_swappable_with' is a}}
+ std::is_swappable_with_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_swappable_with_v' is a}}
+ std::is_trivial; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_trivial' is a}}
+ std::is_trivial_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_trivial_v' is a}}
+ std::is_trivially_assignable; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_trivially_assignable' is a}}
+ std::is_trivially_assignable_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_trivially_assignable_v' is a}}
+ std::is_trivially_constructible; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_trivially_constructible' is a}}
+ std::is_trivially_constructible_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_trivially_constructible_v' is a}}
+ std::is_trivially_copy_assignable; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_trivially_copy_assignable' is a}}
+ std::is_trivially_copy_assignable_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_trivially_copy_assignable_v' is a}}
+ std::is_trivially_copy_constructible; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_trivially_copy_constructible' is a}}
+ std::is_trivially_copy_constructible_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_trivially_copy_constructible_v' is a}}
+ std::is_trivially_copyable; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_trivially_copyable' is a}}
+ std::is_trivially_copyable_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_trivially_copyable_v' is a}}
+ std::is_trivially_default_constructible; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_trivially_default_constructible' is a}}
+ std::is_trivially_default_constructible_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_trivially_default_constructible_v' is a}}
+ std::is_trivially_destructible; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_trivially_destructible' is a}}
+ std::is_trivially_destructible_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_trivially_destructible_v' is a}}
+ std::is_trivially_move_assignable; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_trivially_move_assignable' is a}}
+ std::is_trivially_move_assignable_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_trivially_move_assignable_v' is a}}
+ std::is_trivially_move_constructible; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_trivially_move_constructible' is a}}
+ std::is_trivially_move_constructible_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_trivially_move_constructible_v' is a}}
+ std::is_unbounded_array; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_unbounded_array' is a}}
+ std::is_unbounded_array_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_unbounded_array_v' is a}}
+ std::is_union; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_union' is a}}
+ std::is_union_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_union_v' is a}}
+ std::is_unsigned; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_unsigned' is a}}
+ std::is_unsigned_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_unsigned_v' is a}}
+ std::is_virtual_base_of; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_virtual_base_of' is a}}
+ std::is_virtual_base_of_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_virtual_base_of_v' is a}}
+ std::is_void; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_void' is a}}
+ std::is_void_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_void_v' is a}}
+ std::is_volatile; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_volatile' is a}}
+ std::is_volatile_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_volatile_v' is a}}
+ std::is_within_lifetime; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_within_lifetime' is a}}
+ std::isalnum; // expected-error {{no member}} expected-note {{maybe try}}
+ std::isalpha; // expected-error {{no member}} expected-note {{maybe try}}
+ std::isblank; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::isblank' is a}}
+ std::iscntrl; // expected-error {{no member}} expected-note {{maybe try}}
+ std::isdigit; // expected-error {{no member}} expected-note {{maybe try}}
+ std::isgraph; // expected-error {{no member}} expected-note {{maybe try}}
+ std::isgreater; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::isgreater' is a}}
+ std::isgreaterequal; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::isgreaterequal' is a}}
+ std::isless; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::isless' is a}}
+ std::islessequal; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::islessequal' is a}}
+ std::islessgreater; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::islessgreater' is a}}
+ std::islower; // expected-error {{no member}} expected-note {{maybe try}}
+ std::ispanstream; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ispanstream' is a}}
+ std::ispanstream; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ispanstream' is a}}
+ std::isprint; // expected-error {{no member}} expected-note {{maybe try}}
+ std::ispunct; // expected-error {{no member}} expected-note {{maybe try}}
+ std::isspace; // expected-error {{no member}} expected-note {{maybe try}}
+ std::istream; // expected-error {{no member}} expected-note {{maybe try}}
+ std::istream; // expected-error {{no member}} expected-note {{maybe try}}
+ std::istream; // expected-error {{no member}} expected-note {{maybe try}}
+ std::istream_iterator; // expected-error {{no member}} expected-note {{maybe try}}
+ std::istreambuf_iterator; // expected-error {{no member}} expected-note {{maybe try}}
+ std::istreambuf_iterator; // expected-error {{no member}} expected-note {{maybe try}}
+ std::istringstream; // expected-error {{no member}} expected-note {{maybe try}}
+ std::istringstream; // expected-error {{no member}} expected-note {{maybe try}}
+ std::istrstream; // expected-error {{no member}} expected-note {{maybe try}}
+ std::isunordered; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::isunordered' is a}}
+ std::isupper; // expected-error {{no member}} expected-note {{maybe try}}
+ std::iswalnum; // expected-error {{no member}} expected-note {{maybe try}}
+ std::iswalpha; // expected-error {{no member}} expected-note {{maybe try}}
+ std::iswblank; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::iswblank' is a}}
+ std::iswcntrl; // expected-error {{no member}} expected-note {{maybe try}}
+ std::iswctype; // expected-error {{no member}} expected-note {{maybe try}}
+ std::iswdigit; // expected-error {{no member}} expected-note {{maybe try}}
+ std::iswgraph; // expected-error {{no member}} expected-note {{maybe try}}
+ std::iswlower; // expected-error {{no member}} expected-note {{maybe try}}
+ std::iswprint; // expected-error {{no member}} expected-note {{maybe try}}
+ std::iswpunct; // expected-error {{no member}} expected-note {{maybe try}}
+ std::iswspace; // expected-error {{no member}} expected-note {{maybe try}}
+ std::iswupper; // expected-error {{no member}} expected-note {{maybe try}}
+ std::iswxdigit; // expected-error {{no member}} expected-note {{maybe try}}
+ std::isxdigit; // expected-error {{no member}} expected-note {{maybe try}}
+ std::iter_common_reference_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::iter_common_reference_t' is a}}
+ std::iter_const_reference_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::iter_const_reference_t' is a}}
+ std::iter_difference_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::iter_difference_t' is a}}
+ std::iter_reference_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::iter_reference_t' is a}}
+ std::iter_rvalue_reference_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::iter_rvalue_reference_t' is a}}
+ std::iter_swap; // expected-error {{no member}} expected-note {{maybe try}}
+ std::iter_value_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::iter_value_t' is a}}
+ std::iterator; // expected-error {{no member}} expected-note {{maybe try}}
+ std::iterator_traits; // expected-error {{no member}} expected-note {{maybe try}}
+ std::jmp_buf; // expected-error {{no member}} expected-note {{maybe try}}
+ std::jthread; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::jthread' is a}}
+ std::kill_dependency; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::kill_dependency' is a}}
+ std::kilo; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::kilo' is a}}
+ std::knuth_b; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::knuth_b' is a}}
+ std::labs; // expected-error {{no member}} expected-note {{maybe try}}
+ std::laguerre; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::laguerre' is a}}
+ std::laguerref; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::laguerref' is a}}
+ std::laguerrel; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::laguerrel' is a}}
+ std::latch; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::latch' is a}}
+ std::launch; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::launch' is a}}
+ std::launder; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::launder' is a}}
+ std::layout_left; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::layout_left' is a}}
+ std::layout_left_padded; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::layout_left_padded' is a}}
+ std::layout_right; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::layout_right' is a}}
+ std::layout_right_padded; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::layout_right_padded' is a}}
+ std::layout_stride; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::layout_stride' is a}}
+ std::lcm; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::lcm' is a}}
+ std::lconv; // expected-error {{no member}} expected-note {{maybe try}}
+ std::ldexp; // expected-error {{no member}} expected-note {{maybe try}}
+ std::ldexpf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ldexpf' is a}}
+ std::ldexpl; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ldexpl' is a}}
+ std::ldiv; // expected-error {{no member}} expected-note {{maybe try}}
+ std::ldiv_t; // expected-error {{no member}} expected-note {{maybe try}}
+ std::left; // expected-error {{no member}} expected-note {{maybe try}}
+ std::left; // expected-error {{no member}} expected-note {{maybe try}}
+ std::legendre; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::legendre' is a}}
+ std::legendref; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::legendref' is a}}
+ std::legendrel; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::legendrel' is a}}
+ std::length_error; // expected-error {{no member}} expected-note {{maybe try}}
+ std::lerp; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::lerp' is a}}
+ std::less; // expected-error {{no member}} expected-note {{maybe try}}
+ std::less_equal; // expected-error {{no member}} expected-note {{maybe try}}
+ std::lexicographical_compare; // expected-error {{no member}} expected-note {{maybe try}}
+ std::lexicographical_compare_three_way; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::lexicographical_compare_three_way' is a}}
+ std::lgammaf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::lgammaf' is a}}
+ std::lgammal; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::lgammal' is a}}
+ std::linear_congruential_engine; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::linear_congruential_engine' is a}}
+ std::list; // expected-error {{no member}} expected-note {{maybe try}}
+ std::llabs; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::llabs' is a}}
+ std::lldiv; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::lldiv' is a}}
+ std::lldiv_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::lldiv_t' is a}}
+ std::llrint; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::llrint' is a}}
+ std::llrintf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::llrintf' is a}}
+ std::llrintl; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::llrintl' is a}}
+ std::llround; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::llround' is a}}
+ std::llroundf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::llroundf' is a}}
+ std::llroundl; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::llroundl' is a}}
+ std::locale; // expected-error {{no member}} expected-note {{maybe try}}
+ std::localeconv; // expected-error {{no member}} expected-note {{maybe try}}
+ std::localtime; // expected-error {{no member}} expected-note {{maybe try}}
+ std::lock; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::lock' is a}}
+ std::lock_guard; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::lock_guard' is a}}
+ std::log10f; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::log10f' is a}}
+ std::log10l; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::log10l' is a}}
+ std::log1pf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::log1pf' is a}}
+ std::log1pl; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::log1pl' is a}}
+ std::log2f; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::log2f' is a}}
+ std::log2l; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::log2l' is a}}
+ std::logbf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::logbf' is a}}
+ std::logbl; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::logbl' is a}}
+ std::logf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::logf' is a}}
+ std::logic_error; // expected-error {{no member}} expected-note {{maybe try}}
+ std::logical_and; // expected-error {{no member}} expected-note {{maybe try}}
+ std::logical_not; // expected-error {{no member}} expected-note {{maybe try}}
+ std::logical_or; // expected-error {{no member}} expected-note {{maybe try}}
+ std::logl; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::logl' is a}}
+ std::lognormal_distribution; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::lognormal_distribution' is a}}
+ std::longjmp; // expected-error {{no member}} expected-note {{maybe try}}
+ std::lower_bound; // expected-error {{no member}} expected-note {{maybe try}}
+ std::lrint; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::lrint' is a}}
+ std::lrintf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::lrintf' is a}}
+ std::lrintl; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::lrintl' is a}}
+ std::lround; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::lround' is a}}
+ std::lroundf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::lroundf' is a}}
+ std::lroundl; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::lroundl' is a}}
+ std::make_any; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::make_any' is a}}
+ std::make_const_iterator; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::make_const_iterator' is a}}
+ std::make_const_sentinel; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::make_const_sentinel' is a}}
+ std::make_exception_ptr; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::make_exception_ptr' is a}}
+ std::make_format_args; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::make_format_args' is a}}
+ std::make_from_tuple; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::make_from_tuple' is a}}
+ std::make_heap; // expected-error {{no member}} expected-note {{maybe try}}
+ std::make_index_sequence; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::make_index_sequence' is a}}
+ std::make_integer_sequence; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::make_integer_sequence' is a}}
+ std::make_move_iterator; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::make_move_iterator' is a}}
+ std::make_obj_using_allocator; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::make_obj_using_allocator' is a}}
+ std::make_optional; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::make_optional' is a}}
+ std::make_pair; // expected-error {{no member}} expected-note {{maybe try}}
+ std::make_reverse_iterator; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::make_reverse_iterator' is a}}
+ std::make_shared; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::make_shared' is a}}
+ std::make_shared_for_overwrite; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::make_shared_for_overwrite' is a}}
+ std::make_signed; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::make_signed' is a}}
+ std::make_signed_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::make_signed_t' is a}}
+ std::make_tuple; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::make_tuple' is a}}
+ std::make_unique; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::make_unique' is a}}
+ std::make_unique_for_overwrite; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::make_unique_for_overwrite' is a}}
+ std::make_unsigned; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::make_unsigned' is a}}
+ std::make_unsigned_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::make_unsigned_t' is a}}
+ std::make_wformat_args; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::make_wformat_args' is a}}
+ std::malloc; // expected-error {{no member}} expected-note {{maybe try}}
+ std::map; // expected-error {{no member}} expected-note {{maybe try}}
+ std::mask_array; // expected-error {{no member}} expected-note {{maybe try}}
+ std::match_results; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::match_results' is a}}
+ std::max; // expected-error {{no member}} expected-note {{maybe try}}
+ std::max_align_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::max_align_t' is a}}
+ std::max_element; // expected-error {{no member}} expected-note {{maybe try}}
+ std::mblen; // expected-error {{no member}} expected-note {{maybe try}}
+ std::mbrlen; // expected-error {{no member}} expected-note {{maybe try}}
+ std::mbrtoc16; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::mbrtoc16' is a}}
+ std::mbrtoc32; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::mbrtoc32' is a}}
+ std::mbrtoc8; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::mbrtoc8' is a}}
+ std::mbrtowc; // expected-error {{no member}} expected-note {{maybe try}}
+ std::mbsinit; // expected-error {{no member}} expected-note {{maybe try}}
+ std::mbsrtowcs; // expected-error {{no member}} expected-note {{maybe try}}
+ std::mbstowcs; // expected-error {{no member}} expected-note {{maybe try}}
+ std::mbtowc; // expected-error {{no member}} expected-note {{maybe try}}
+ std::mdspan; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::mdspan' is a}}
+ std::mega; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::mega' is a}}
+ std::mem_fn; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::mem_fn' is a}}
+ std::mem_fun; // expected-error {{no member}} expected-note {{maybe try}}
+ std::mem_fun1_ref_t; // expected-error {{no member}} expected-note {{maybe try}}
+ std::mem_fun1_t; // expected-error {{no member}} expected-note {{maybe try}}
+ std::mem_fun_ref; // expected-error {{no member}} expected-note {{maybe try}}
+ std::mem_fun_ref_t; // expected-error {{no member}} expected-note {{maybe try}}
+ std::mem_fun_t; // expected-error {{no member}} expected-note {{maybe try}}
+ std::memchr; // expected-error {{no member}} expected-note {{maybe try}}
+ std::memcmp; // expected-error {{no member}} expected-note {{maybe try}}
+ std::memcpy; // expected-error {{no member}} expected-note {{maybe try}}
+ std::memmove; // expected-error {{no member}} expected-note {{maybe try}}
+ std::memory_order; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::memory_order' is a}}
+ std::memory_order_acq_rel; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::memory_order_acq_rel' is a}}
+ std::memory_order_acquire; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::memory_order_acquire' is a}}
+ std::memory_order_consume; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::memory_order_consume' is a}}
+ std::memory_order_relaxed; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::memory_order_relaxed' is a}}
+ std::memory_order_release; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::memory_order_release' is a}}
+ std::memory_order_seq_cst; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::memory_order_seq_cst' is a}}
+ std::memset; // expected-error {{no member}} expected-note {{maybe try}}
+ std::merge; // expected-error {{no member}} expected-note {{maybe try}}
+ std::mergeable; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::mergeable' is a}}
+ std::mersenne_twister_engine; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::mersenne_twister_engine' is a}}
+ std::messages; // expected-error {{no member}} expected-note {{maybe try}}
+ std::messages_base; // expected-error {{no member}} expected-note {{maybe try}}
+ std::messages_byname; // expected-error {{no member}} expected-note {{maybe try}}
+ std::micro; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::micro' is a}}
+ std::midpoint; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::midpoint' is a}}
+ std::milli; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::milli' is a}}
+ std::min; // expected-error {{no member}} expected-note {{maybe try}}
+ std::min_element; // expected-error {{no member}} expected-note {{maybe try}}
+ std::minmax; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::minmax' is a}}
+ std::minmax_element; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::minmax_element' is a}}
+ std::minstd_rand; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::minstd_rand' is a}}
+ std::minstd_rand0; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::minstd_rand0' is a}}
+ std::minus; // expected-error {{no member}} expected-note {{maybe try}}
+ std::mismatch; // expected-error {{no member}} expected-note {{maybe try}}
+ std::mktime; // expected-error {{no member}} expected-note {{maybe try}}
+ std::modf; // expected-error {{no member}} expected-note {{maybe try}}
+ std::modff; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::modff' is a}}
+ std::modfl; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::modfl' is a}}
+ std::modulus; // expected-error {{no member}} expected-note {{maybe try}}
+ std::money_base; // expected-error {{no member}} expected-note {{maybe try}}
+ std::money_get; // expected-error {{no member}} expected-note {{maybe try}}
+ std::money_put; // expected-error {{no member}} expected-note {{maybe try}}
+ std::moneypunct; // expected-error {{no member}} expected-note {{maybe try}}
+ std::moneypunct_byname; // expected-error {{no member}} expected-note {{maybe try}}
+ std::movable; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::movable' is a}}
+ std::move_backward; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::move_backward' is a}}
+ std::move_constructible; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::move_constructible' is a}}
+ std::move_if_noexcept; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::move_if_noexcept' is a}}
+ std::move_iterator; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::move_iterator' is a}}
+ std::move_only_function; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::move_only_function' is a}}
+ std::move_sentinel; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::move_sentinel' is a}}
+ std::mt19937; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::mt19937' is a}}
+ std::mt19937_64; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::mt19937_64' is a}}
+ std::mul_sat; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::mul_sat' is a}}
+ std::multimap; // expected-error {{no member}} expected-note {{maybe try}}
+ std::multiplies; // expected-error {{no member}} expected-note {{maybe try}}
+ std::multiset; // expected-error {{no member}} expected-note {{maybe try}}
+ std::mutex; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::mutex' is a}}
+ std::nan; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::nan' is a}}
+ std::nanf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::nanf' is a}}
+ std::nanl; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::nanl' is a}}
+ std::nano; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::nano' is a}}
+ std::nearbyintf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::nearbyintf' is a}}
+ std::nearbyintl; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::nearbyintl' is a}}
+ std::negate; // expected-error {{no member}} expected-note {{maybe try}}
+ std::negation; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::negation' is a}}
+ std::negation_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::negation_v' is a}}
+ std::negative_binomial_distribution; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::negative_binomial_distribution' is a}}
+ std::nested_exception; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::nested_exception' is a}}
+ std::new_handler; // expected-error {{no member}} expected-note {{maybe try}}
+ std::next; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::next' is a}}
+ std::next_permutation; // expected-error {{no member}} expected-note {{maybe try}}
+ std::nextafter; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::nextafter' is a}}
+ std::nextafterf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::nextafterf' is a}}
+ std::nextafterl; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::nextafterl' is a}}
+ std::nexttoward; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::nexttoward' is a}}
+ std::nexttowardf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::nexttowardf' is a}}
+ std::nexttowardl; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::nexttowardl' is a}}
+ std::noboolalpha; // expected-error {{no member}} expected-note {{maybe try}}
+ std::noboolalpha; // expected-error {{no member}} expected-note {{maybe try}}
+ std::noemit_on_flush; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::noemit_on_flush' is a}}
+ std::noemit_on_flush; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::noemit_on_flush' is a}}
+ std::none_of; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::none_of' is a}}
+ std::nontype; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::nontype' is a}}
+ std::nontype_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::nontype_t' is a}}
+ std::noop_coroutine; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::noop_coroutine' is a}}
+ std::noop_coroutine_handle; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::noop_coroutine_handle' is a}}
+ std::noop_coroutine_promise; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::noop_coroutine_promise' is a}}
+ std::norm; // expected-error {{no member}} expected-note {{maybe try}}
+ std::normal_distribution; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::normal_distribution' is a}}
+ std::noshowbase; // expected-error {{no member}} expected-note {{maybe try}}
+ std::noshowbase; // expected-error {{no member}} expected-note {{maybe try}}
+ std::noshowpoint; // expected-error {{no member}} expected-note {{maybe try}}
+ std::noshowpoint; // expected-error {{no member}} expected-note {{maybe try}}
+ std::noshowpos; // expected-error {{no member}} expected-note {{maybe try}}
+ std::noshowpos; // expected-error {{no member}} expected-note {{maybe try}}
+ std::noskipws; // expected-error {{no member}} expected-note {{maybe try}}
+ std::noskipws; // expected-error {{no member}} expected-note {{maybe try}}
+ std::nostopstate; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::nostopstate' is a}}
+ std::nostopstate_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::nostopstate_t' is a}}
+ std::not1; // expected-error {{no member}} expected-note {{maybe try}}
+ std::not2; // expected-error {{no member}} expected-note {{maybe try}}
+ std::not_equal_to; // expected-error {{no member}} expected-note {{maybe try}}
+ std::not_fn; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::not_fn' is a}}
+ std::nothrow; // expected-error {{no member}} expected-note {{maybe try}}
+ std::nothrow_t; // expected-error {{no member}} expected-note {{maybe try}}
+ std::notify_all_at_thread_exit; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::notify_all_at_thread_exit' is a}}
+ std::nounitbuf; // expected-error {{no member}} expected-note {{maybe try}}
+ std::nounitbuf; // expected-error {{no member}} expected-note {{maybe try}}
+ std::nouppercase; // expected-error {{no member}} expected-note {{maybe try}}
+ std::nouppercase; // expected-error {{no member}} expected-note {{maybe try}}
+ std::nth_element; // expected-error {{no member}} expected-note {{maybe try}}
+ std::nullopt; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::nullopt' is a}}
+ std::nullopt_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::nullopt_t' is a}}
+ std::nullptr_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::nullptr_t' is a}}
+ std::num_get; // expected-error {{no member}} expected-note {{maybe try}}
+ std::num_put; // expected-error {{no member}} expected-note {{maybe try}}
+ std::numeric_limits; // expected-error {{no member}} expected-note {{maybe try}}
+ std::numpunct; // expected-error {{no member}} expected-note {{maybe try}}
+ std::numpunct_byname; // expected-error {{no member}} expected-note {{maybe try}}
+ std::oct; // expected-error {{no member}} expected-note {{maybe try}}
+ std::oct; // expected-error {{no member}} expected-note {{maybe try}}
+ std::ofstream; // expected-error {{no member}} expected-note {{maybe try}}
+ std::ofstream; // expected-error {{no member}} expected-note {{maybe try}}
+ std::once_flag; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::once_flag' is a}}
+ std::op; // expected-error {{no member}} expected-note {{maybe try}}
+ std::open_mode; // expected-error {{no member}} expected-note {{maybe try}}
+ std::open_mode; // expected-error {{no member}} expected-note {{maybe try}}
+ std::optional; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::optional' is a}}
+ std::ospanstream; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ospanstream' is a}}
+ std::ospanstream; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ospanstream' is a}}
+ std::ostream; // expected-error {{no member}} expected-note {{maybe try}}
+ std::ostream; // expected-error {{no member}} expected-note {{maybe try}}
+ std::ostream; // expected-error {{no member}} expected-note {{maybe try}}
+ std::ostream_iterator; // expected-error {{no member}} expected-note {{maybe try}}
+ std::ostreambuf_iterator; // expected-error {{no member}} expected-note {{maybe try}}
+ std::ostreambuf_iterator; // expected-error {{no member}} expected-note {{maybe try}}
+ std::ostringstream; // expected-error {{no member}} expected-note {{maybe try}}
+ std::ostringstream; // expected-error {{no member}} expected-note {{maybe try}}
+ std::ostrstream; // expected-error {{no member}} expected-note {{maybe try}}
+ std::osyncstream; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::osyncstream' is a}}
+ std::osyncstream; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::osyncstream' is a}}
+ std::out_of_range; // expected-error {{no member}} expected-note {{maybe try}}
+ std::out_ptr; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::out_ptr' is a}}
+ std::out_ptr_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::out_ptr_t' is a}}
+ std::output_iterator; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::output_iterator' is a}}
+ std::output_iterator_tag; // expected-error {{no member}} expected-note {{maybe try}}
+ std::overflow_error; // expected-error {{no member}} expected-note {{maybe try}}
+ std::owner_less; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::owner_less' is a}}
+ std::packaged_task; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::packaged_task' is a}}
+ std::pair; // expected-error {{no member}} expected-note {{maybe try}}
+ std::partial_order; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::partial_order' is a}}
+ std::partial_ordering; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::partial_ordering' is a}}
+ std::partial_sort; // expected-error {{no member}} expected-note {{maybe try}}
+ std::partial_sort_copy; // expected-error {{no member}} expected-note {{maybe try}}
+ std::partial_sum; // expected-error {{no member}} expected-note {{maybe try}}
+ std::partition; // expected-error {{no member}} expected-note {{maybe try}}
+ std::partition_copy; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::partition_copy' is a}}
+ std::partition_point; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::partition_point' is a}}
+ std::permutable; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::permutable' is a}}
+ std::perror; // expected-error {{no member}} expected-note {{maybe try}}
+ std::peta; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::peta' is a}}
+ std::pico; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::pico' is a}}
+ std::piecewise_constant_distribution; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::piecewise_constant_distribution' is a}}
+ std::piecewise_construct; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::piecewise_construct' is a}}
+ std::piecewise_construct_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::piecewise_construct_t' is a}}
+ std::piecewise_linear_distribution; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::piecewise_linear_distribution' is a}}
+ std::plus; // expected-error {{no member}} expected-note {{maybe try}}
+ std::pointer_safety; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::pointer_safety' is a}}
+ std::pointer_traits; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::pointer_traits' is a}}
+ std::poisson_distribution; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::poisson_distribution' is a}}
+ std::polar; // expected-error {{no member}} expected-note {{maybe try}}
+ std::pop_heap; // expected-error {{no member}} expected-note {{maybe try}}
+ std::popcount; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::popcount' is a}}
+ std::pow; // expected-error {{no member}} expected-note {{maybe try}}
+ std::powf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::powf' is a}}
+ std::powl; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::powl' is a}}
+ std::predicate; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::predicate' is a}}
+ std::preferred; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::preferred' is a}}
+ std::prev; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::prev' is a}}
+ std::prev_permutation; // expected-error {{no member}} expected-note {{maybe try}}
+ std::print; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::print' is a}}
+ std::printf; // expected-error {{no member}} expected-note {{maybe try}}
+ std::println; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::println' is a}}
+ std::priority_queue; // expected-error {{no member}} expected-note {{maybe try}}
+ std::proj; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::proj' is a}}
+ std::projected; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::projected' is a}}
+ std::promise; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::promise' is a}}
+ std::ptr_fun; // expected-error {{no member}} expected-note {{maybe try}}
+ std::ptrdiff_t; // expected-error {{no member}} expected-note {{maybe try}}
+ std::push_heap; // expected-error {{no member}} expected-note {{maybe try}}
+ std::put_money; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::put_money' is a}}
+ std::put_time; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::put_time' is a}}
+ std::putc; // expected-error {{no member}} expected-note {{maybe try}}
+ std::putchar; // expected-error {{no member}} expected-note {{maybe try}}
+ std::puts; // expected-error {{no member}} expected-note {{maybe try}}
+ std::putwc; // expected-error {{no member}} expected-note {{maybe try}}
+ std::putwchar; // expected-error {{no member}} expected-note {{maybe try}}
+ std::qsort; // expected-error {{no member}} expected-note {{maybe try}}
+ std::quecto; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::quecto' is a}}
+ std::quetta; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::quetta' is a}}
+ std::queue; // expected-error {{no member}} expected-note {{maybe try}}
+ std::quick_exit; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::quick_exit' is a}}
+ std::quoted; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::quoted' is a}}
+ std::raise; // expected-error {{no member}} expected-note {{maybe try}}
+ std::rand; // expected-error {{no member}} expected-note {{maybe try}}
+ std::random_access_iterator; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::random_access_iterator' is a}}
+ std::random_access_iterator_tag; // expected-error {{no member}} expected-note {{maybe try}}
+ std::random_device; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::random_device' is a}}
+ std::random_shuffle; // expected-error {{no member}} expected-note {{maybe try}}
+ std::range_error; // expected-error {{no member}} expected-note {{maybe try}}
+ std::range_format; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::range_format' is a}}
+ std::range_formatter; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::range_formatter' is a}}
+ std::rank; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::rank' is a}}
+ std::rank_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::rank_v' is a}}
+ std::ranlux24; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranlux24' is a}}
+ std::ranlux24_base; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranlux24_base' is a}}
+ std::ranlux48; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranlux48' is a}}
+ std::ranlux48_base; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranlux48_base' is a}}
+ std::ratio; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ratio' is a}}
+ std::ratio_add; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ratio_add' is a}}
+ std::ratio_divide; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ratio_divide' is a}}
+ std::ratio_equal; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ratio_equal' is a}}
+ std::ratio_equal_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ratio_equal_v' is a}}
+ std::ratio_greater; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ratio_greater' is a}}
+ std::ratio_greater_equal; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ratio_greater_equal' is a}}
+ std::ratio_greater_equal_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ratio_greater_equal_v' is a}}
+ std::ratio_greater_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ratio_greater_v' is a}}
+ std::ratio_less; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ratio_less' is a}}
+ std::ratio_less_equal; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ratio_less_equal' is a}}
+ std::ratio_less_equal_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ratio_less_equal_v' is a}}
+ std::ratio_less_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ratio_less_v' is a}}
+ std::ratio_multiply; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ratio_multiply' is a}}
+ std::ratio_not_equal; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ratio_not_equal' is a}}
+ std::ratio_not_equal_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ratio_not_equal_v' is a}}
+ std::ratio_subtract; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ratio_subtract' is a}}
+ std::raw_storage_iterator; // expected-error {{no member}} expected-note {{maybe try}}
+ std::real; // expected-error {{no member}} expected-note {{maybe try}}
+ std::realloc; // expected-error {{no member}} expected-note {{maybe try}}
+ std::recursive_mutex; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::recursive_mutex' is a}}
+ std::recursive_timed_mutex; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::recursive_timed_mutex' is a}}
+ std::reduce; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::reduce' is a}}
+ std::ref; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ref' is a}}
+ std::reference_constructs_from_temporary; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::reference_constructs_from_temporary' is a}}
+ std::reference_converts_from_temporary; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::reference_converts_from_temporary' is a}}
+ std::reference_wrapper; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::reference_wrapper' is a}}
+ std::regex; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::regex' is a}}
+ std::regex_error; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::regex_error' is a}}
+ std::regex_iterator; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::regex_iterator' is a}}
+ std::regex_match; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::regex_match' is a}}
+ std::regex_replace; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::regex_replace' is a}}
+ std::regex_search; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::regex_search' is a}}
+ std::regex_token_iterator; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::regex_token_iterator' is a}}
+ std::regex_traits; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::regex_traits' is a}}
+ std::regular; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::regular' is a}}
+ std::regular_invocable; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::regular_invocable' is a}}
+ std::reinterpret_pointer_cast; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::reinterpret_pointer_cast' is a}}
+ std::relation; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::relation' is a}}
+ std::relaxed; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::relaxed' is a}}
+ std::remainderf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::remainderf' is a}}
+ std::remainderl; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::remainderl' is a}}
+ std::remove_all_extents; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::remove_all_extents' is a}}
+ std::remove_all_extents_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::remove_all_extents_t' is a}}
+ std::remove_const; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::remove_const' is a}}
+ std::remove_const_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::remove_const_t' is a}}
+ std::remove_copy; // expected-error {{no member}} expected-note {{maybe try}}
+ std::remove_copy_if; // expected-error {{no member}} expected-note {{maybe try}}
+ std::remove_cv; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::remove_cv' is a}}
+ std::remove_cv_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::remove_cv_t' is a}}
+ std::remove_cvref; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::remove_cvref' is a}}
+ std::remove_cvref_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::remove_cvref_t' is a}}
+ std::remove_extent; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::remove_extent' is a}}
+ std::remove_extent_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::remove_extent_t' is a}}
+ std::remove_if; // expected-error {{no member}} expected-note {{maybe try}}
+ std::remove_pointer; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::remove_pointer' is a}}
+ std::remove_pointer_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::remove_pointer_t' is a}}
+ std::remove_reference; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::remove_reference' is a}}
+ std::remove_reference_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::remove_reference_t' is a}}
+ std::remove_volatile; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::remove_volatile' is a}}
+ std::remove_volatile_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::remove_volatile_t' is a}}
+ std::remquo; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::remquo' is a}}
+ std::remquof; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::remquof' is a}}
+ std::remquol; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::remquol' is a}}
+ std::rename; // expected-error {{no member}} expected-note {{maybe try}}
+ std::replace; // expected-error {{no member}} expected-note {{maybe try}}
+ std::replace_copy; // expected-error {{no member}} expected-note {{maybe try}}
+ std::replace_copy_if; // expected-error {{no member}} expected-note {{maybe try}}
+ std::replace_if; // expected-error {{no member}} expected-note {{maybe try}}
+ std::resetiosflags; // expected-error {{no member}} expected-note {{maybe try}}
+ std::result_of; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::result_of' is a}}
+ std::result_of_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::result_of_t' is a}}
+ std::rethrow_exception; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::rethrow_exception' is a}}
+ std::rethrow_if_nested; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::rethrow_if_nested' is a}}
+ std::return_temporary_buffer; // expected-error {{no member}} expected-note {{maybe try}}
+ std::reverse; // expected-error {{no member}} expected-note {{maybe try}}
+ std::reverse_copy; // expected-error {{no member}} expected-note {{maybe try}}
+ std::reverse_iterator; // expected-error {{no member}} expected-note {{maybe try}}
+ std::rewind; // expected-error {{no member}} expected-note {{maybe try}}
+ std::riemann_zeta; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::riemann_zeta' is a}}
+ std::riemann_zetaf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::riemann_zetaf' is a}}
+ std::riemann_zetal; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::riemann_zetal' is a}}
+ std::right; // expected-error {{no member}} expected-note {{maybe try}}
+ std::right; // expected-error {{no member}} expected-note {{maybe try}}
+ std::rint; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::rint' is a}}
+ std::rintf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::rintf' is a}}
+ std::rintl; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::rintl' is a}}
+ std::ronna; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ronna' is a}}
+ std::ronto; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ronto' is a}}
+ std::rotate; // expected-error {{no member}} expected-note {{maybe try}}
+ std::rotate_copy; // expected-error {{no member}} expected-note {{maybe try}}
+ std::rotl; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::rotl' is a}}
+ std::rotr; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::rotr' is a}}
+ std::round; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::round' is a}}
+ std::round_indeterminate; // expected-error {{no member}} expected-note {{maybe try}}
+ std::round_to_nearest; // expected-error {{no member}} expected-note {{maybe try}}
+ std::round_toward_infinity; // expected-error {{no member}} expected-note {{maybe try}}
+ std::round_toward_neg_infinity; // expected-error {{no member}} expected-note {{maybe try}}
+ std::round_toward_zero; // expected-error {{no member}} expected-note {{maybe try}}
+ std::roundf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::roundf' is a}}
+ std::roundl; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::roundl' is a}}
+ std::runtime_error; // expected-error {{no member}} expected-note {{maybe try}}
+ std::runtime_format; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::runtime_format' is a}}
+ std::same_as; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::same_as' is a}}
+ std::sample; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::sample' is a}}
+ std::saturate_cast; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::saturate_cast' is a}}
+ std::scalbln; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::scalbln' is a}}
+ std::scalblnf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::scalblnf' is a}}
+ std::scalblnl; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::scalblnl' is a}}
+ std::scalbn; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::scalbn' is a}}
+ std::scalbnf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::scalbnf' is a}}
+ std::scalbnl; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::scalbnl' is a}}
+ std::scanf; // expected-error {{no member}} expected-note {{maybe try}}
+ std::scientific; // expected-error {{no member}} expected-note {{maybe try}}
+ std::scientific; // expected-error {{no member}} expected-note {{maybe try}}
+ std::scoped_allocator_adaptor; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::scoped_allocator_adaptor' is a}}
+ std::scoped_lock; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::scoped_lock' is a}}
+ std::search; // expected-error {{no member}} expected-note {{maybe try}}
+ std::search_n; // expected-error {{no member}} expected-note {{maybe try}}
+ std::seed_seq; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::seed_seq' is a}}
+ std::seek_dir; // expected-error {{no member}} expected-note {{maybe try}}
+ std::seek_dir; // expected-error {{no member}} expected-note {{maybe try}}
+ std::semiregular; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::semiregular' is a}}
+ std::sentinel_for; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::sentinel_for' is a}}
+ std::set; // expected-error {{no member}} expected-note {{maybe try}}
+ std::set_difference; // expected-error {{no member}} expected-note {{maybe try}}
+ std::set_intersection; // expected-error {{no member}} expected-note {{maybe try}}
+ std::set_new_handler; // expected-error {{no member}} expected-note {{maybe try}}
+ std::set_symmetric_difference; // expected-error {{no member}} expected-note {{maybe try}}
+ std::set_terminate; // expected-error {{no member}} expected-note {{maybe try}}
+ std::set_unexpected; // expected-error {{no member}} expected-note {{maybe try}}
+ std::set_union; // expected-error {{no member}} expected-note {{maybe try}}
+ std::setbase; // expected-error {{no member}} expected-note {{maybe try}}
+ std::setbuf; // expected-error {{no member}} expected-note {{maybe try}}
+ std::setfill; // expected-error {{no member}} expected-note {{maybe try}}
+ std::setiosflags; // expected-error {{no member}} expected-note {{maybe try}}
+ std::setlocale; // expected-error {{no member}} expected-note {{maybe try}}
+ std::setprecision; // expected-error {{no member}} expected-note {{maybe try}}
+ std::setvbuf; // expected-error {{no member}} expected-note {{maybe try}}
+ std::setw; // expected-error {{no member}} expected-note {{maybe try}}
+ std::shared_future; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::shared_future' is a}}
+ std::shared_lock; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::shared_lock' is a}}
+ std::shared_mutex; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::shared_mutex' is a}}
+ std::shared_ptr; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::shared_ptr' is a}}
+ std::shared_timed_mutex; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::shared_timed_mutex' is a}}
+ std::shift_left; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::shift_left' is a}}
+ std::shift_right; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::shift_right' is a}}
+ std::showbase; // expected-error {{no member}} expected-note {{maybe try}}
+ std::showbase; // expected-error {{no member}} expected-note {{maybe try}}
+ std::showpoint; // expected-error {{no member}} expected-note {{maybe try}}
+ std::showpoint; // expected-error {{no member}} expected-note {{maybe try}}
+ std::showpos; // expected-error {{no member}} expected-note {{maybe try}}
+ std::showpos; // expected-error {{no member}} expected-note {{maybe try}}
+ std::shuffle; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::shuffle' is a}}
+ std::shuffle_order_engine; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::shuffle_order_engine' is a}}
+ std::sig_atomic_t; // expected-error {{no member}} expected-note {{maybe try}}
+ std::signal; // expected-error {{no member}} expected-note {{maybe try}}
+ std::signed_integral; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::signed_integral' is a}}
+ std::sinf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::sinf' is a}}
+ std::sinhf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::sinhf' is a}}
+ std::sinhl; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::sinhl' is a}}
+ std::sinl; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::sinl' is a}}
+ std::sized_sentinel_for; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::sized_sentinel_for' is a}}
+ std::skipws; // expected-error {{no member}} expected-note {{maybe try}}
+ std::skipws; // expected-error {{no member}} expected-note {{maybe try}}
+ std::slice; // expected-error {{no member}} expected-note {{maybe try}}
+ std::slice_array; // expected-error {{no member}} expected-note {{maybe try}}
+ std::smatch; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::smatch' is a}}
+ std::snprintf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::snprintf' is a}}
+ std::sort; // expected-error {{no member}} expected-note {{maybe try}}
+ std::sort_heap; // expected-error {{no member}} expected-note {{maybe try}}
+ std::sortable; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::sortable' is a}}
+ std::source_location; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::source_location' is a}}
+ std::span; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::span' is a}}
+ std::spanbuf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::spanbuf' is a}}
+ std::spanbuf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::spanbuf' is a}}
+ std::spanstream; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::spanstream' is a}}
+ std::spanstream; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::spanstream' is a}}
+ std::sph_bessel; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::sph_bessel' is a}}
+ std::sph_besself; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::sph_besself' is a}}
+ std::sph_bessell; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::sph_bessell' is a}}
+ std::sph_legendre; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::sph_legendre' is a}}
+ std::sph_legendref; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::sph_legendref' is a}}
+ std::sph_legendrel; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::sph_legendrel' is a}}
+ std::sph_neumann; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::sph_neumann' is a}}
+ std::sph_neumannf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::sph_neumannf' is a}}
+ std::sph_neumannl; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::sph_neumannl' is a}}
+ std::sprintf; // expected-error {{no member}} expected-note {{maybe try}}
+ std::sqrtf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::sqrtf' is a}}
+ std::sqrtl; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::sqrtl' is a}}
+ std::srand; // expected-error {{no member}} expected-note {{maybe try}}
+ std::sregex_iterator; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::sregex_iterator' is a}}
+ std::sregex_token_iterator; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::sregex_token_iterator' is a}}
+ std::sscanf; // expected-error {{no member}} expected-note {{maybe try}}
+ std::ssub_match; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ssub_match' is a}}
+ std::stable_partition; // expected-error {{no member}} expected-note {{maybe try}}
+ std::stable_sort; // expected-error {{no member}} expected-note {{maybe try}}
+ std::stack; // expected-error {{no member}} expected-note {{maybe try}}
+ std::stacktrace; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::stacktrace' is a}}
+ std::stacktrace_entry; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::stacktrace_entry' is a}}
+ std::start_lifetime_as; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::start_lifetime_as' is a}}
+ std::static_pointer_cast; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::static_pointer_cast' is a}}
+ std::stod; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::stod' is a}}
+ std::stof; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::stof' is a}}
+ std::stoi; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::stoi' is a}}
+ std::stol; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::stol' is a}}
+ std::stold; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::stold' is a}}
+ std::stoll; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::stoll' is a}}
+ std::stop_callback; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::stop_callback' is a}}
+ std::stop_source; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::stop_source' is a}}
+ std::stop_token; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::stop_token' is a}}
+ std::stoul; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::stoul' is a}}
+ std::stoull; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::stoull' is a}}
+ std::strcat; // expected-error {{no member}} expected-note {{maybe try}}
+ std::strchr; // expected-error {{no member}} expected-note {{maybe try}}
+ std::strcmp; // expected-error {{no member}} expected-note {{maybe try}}
+ std::strcoll; // expected-error {{no member}} expected-note {{maybe try}}
+ std::strcpy; // expected-error {{no member}} expected-note {{maybe try}}
+ std::strcspn; // expected-error {{no member}} expected-note {{maybe try}}
+ std::streambuf; // expected-error {{no member}} expected-note {{maybe try}}
+ std::streambuf; // expected-error {{no member}} expected-note {{maybe try}}
+ std::streambuf; // expected-error {{no member}} expected-note {{maybe try}}
+ std::streamoff; // expected-error {{no member}} expected-note {{maybe try}}
+ std::streamoff; // expected-error {{no member}} expected-note {{maybe try}}
+ std::streampos; // expected-error {{no member}} expected-note {{maybe try}}
+ std::streampos; // expected-error {{no member}} expected-note {{maybe try}}
+ std::streamsize; // expected-error {{no member}} expected-note {{maybe try}}
+ std::streamsize; // expected-error {{no member}} expected-note {{maybe try}}
+ std::strerror; // expected-error {{no member}} expected-note {{maybe try}}
+ std::strftime; // expected-error {{no member}} expected-note {{maybe try}}
+ std::strict; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::strict' is a}}
+ std::strict_weak_order; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::strict_weak_order' is a}}
+ std::strided_slice; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::strided_slice' is a}}
+ std::string; // expected-error {{no member}} expected-note {{maybe try}}
+ std::string_view; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::string_view' is a}}
+ std::stringbuf; // expected-error {{no member}} expected-note {{maybe try}}
+ std::stringbuf; // expected-error {{no member}} expected-note {{maybe try}}
+ std::stringstream; // expected-error {{no member}} expected-note {{maybe try}}
+ std::stringstream; // expected-error {{no member}} expected-note {{maybe try}}
+ std::strlen; // expected-error {{no member}} expected-note {{maybe try}}
+ std::strncat; // expected-error {{no member}} expected-note {{maybe try}}
+ std::strncmp; // expected-error {{no member}} expected-note {{maybe try}}
+ std::strncpy; // expected-error {{no member}} expected-note {{maybe try}}
+ std::strong_order; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::strong_order' is a}}
+ std::strong_ordering; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::strong_ordering' is a}}
+ std::strpbrk; // expected-error {{no member}} expected-note {{maybe try}}
+ std::strrchr; // expected-error {{no member}} expected-note {{maybe try}}
+ std::strspn; // expected-error {{no member}} expected-note {{maybe try}}
+ std::strstr; // expected-error {{no member}} expected-note {{maybe try}}
+ std::strstream; // expected-error {{no member}} expected-note {{maybe try}}
+ std::strstreambuf; // expected-error {{no member}} expected-note {{maybe try}}
+ std::strtod; // expected-error {{no member}} expected-note {{maybe try}}
+ std::strtof; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::strtof' is a}}
+ std::strtoimax; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::strtoimax' is a}}
+ std::strtok; // expected-error {{no member}} expected-note {{maybe try}}
+ std::strtol; // expected-error {{no member}} expected-note {{maybe try}}
+ std::strtold; // expected-error {{no member}} expected-note {{maybe try}}
+ std::strtoll; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::strtoll' is a}}
+ std::strtoul; // expected-error {{no member}} expected-note {{maybe try}}
+ std::strtoull; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::strtoull' is a}}
+ std::strtoumax; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::strtoumax' is a}}
+ std::strxfrm; // expected-error {{no member}} expected-note {{maybe try}}
+ std::student_t_distribution; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::student_t_distribution' is a}}
+ std::sub_match; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::sub_match' is a}}
+ std::sub_sat; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::sub_sat' is a}}
+ std::submdspan_mapping_result; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::submdspan_mapping_result' is a}}
+ std::subtract_with_carry_engine; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::subtract_with_carry_engine' is a}}
+ std::suspend_always; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::suspend_always' is a}}
+ std::suspend_never; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::suspend_never' is a}}
+ std::swap_ranges; // expected-error {{no member}} expected-note {{maybe try}}
+ std::swappable; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::swappable' is a}}
+ std::swappable_with; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::swappable_with' is a}}
+ std::swprintf; // expected-error {{no member}} expected-note {{maybe try}}
+ std::swscanf; // expected-error {{no member}} expected-note {{maybe try}}
+ std::syncbuf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::syncbuf' is a}}
+ std::syncbuf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::syncbuf' is a}}
+ std::system; // expected-error {{no member}} expected-note {{maybe try}}
+ std::system_category; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::system_category' is a}}
+ std::system_error; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::system_error' is a}}
+ std::tanf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::tanf' is a}}
+ std::tanhf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::tanhf' is a}}
+ std::tanhl; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::tanhl' is a}}
+ std::tanl; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::tanl' is a}}
+ std::tera; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::tera' is a}}
+ std::terminate; // expected-error {{no member}} expected-note {{maybe try}}
+ std::terminate_handler; // expected-error {{no member}} expected-note {{maybe try}}
+ std::text_encoding; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::text_encoding' is a}}
+ std::tgammaf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::tgammaf' is a}}
+ std::tgammal; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::tgammal' is a}}
+ std::thread; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::thread' is a}}
+ std::three_way_comparable; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::three_way_comparable' is a}}
+ std::three_way_comparable_with; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::three_way_comparable_with' is a}}
+ std::throw_with_nested; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::throw_with_nested' is a}}
+ std::tie; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::tie' is a}}
+ std::time; // expected-error {{no member}} expected-note {{maybe try}}
+ std::time_base; // expected-error {{no member}} expected-note {{maybe try}}
+ std::time_get; // expected-error {{no member}} expected-note {{maybe try}}
+ std::time_get_byname; // expected-error {{no member}} expected-note {{maybe try}}
+ std::time_put; // expected-error {{no member}} expected-note {{maybe try}}
+ std::time_put_byname; // expected-error {{no member}} expected-note {{maybe try}}
+ std::time_t; // expected-error {{no member}} expected-note {{maybe try}}
+ std::timed_mutex; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::timed_mutex' is a}}
+ std::timespec; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::timespec' is a}}
+ std::timespec_get; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::timespec_get' is a}}
+ std::tm; // expected-error {{no member}} expected-note {{maybe try}}
+ std::tmpfile; // expected-error {{no member}} expected-note {{maybe try}}
+ std::tmpnam; // expected-error {{no member}} expected-note {{maybe try}}
+ std::to_address; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::to_address' is a}}
+ std::to_array; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::to_array' is a}}
+ std::to_chars; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::to_chars' is a}}
+ std::to_chars_result; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::to_chars_result' is a}}
+ std::to_integer; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::to_integer' is a}}
+ std::to_string; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::to_string' is a}}
+ std::to_underlying; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::to_underlying' is a}}
+ std::to_wstring; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::to_wstring' is a}}
+ std::tolower; // expected-error {{no member}} expected-note {{maybe try}}
+ std::totally_ordered; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::totally_ordered' is a}}
+ std::totally_ordered_with; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::totally_ordered_with' is a}}
+ std::toupper; // expected-error {{no member}} expected-note {{maybe try}}
+ std::towctrans; // expected-error {{no member}} expected-note {{maybe try}}
+ std::towlower; // expected-error {{no member}} expected-note {{maybe try}}
+ std::towupper; // expected-error {{no member}} expected-note {{maybe try}}
+ std::transform; // expected-error {{no member}} expected-note {{maybe try}}
+ std::transform_exclusive_scan; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::transform_exclusive_scan' is a}}
+ std::transform_inclusive_scan; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::transform_inclusive_scan' is a}}
+ std::transform_reduce; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::transform_reduce' is a}}
+ std::true_type; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::true_type' is a}}
+ std::truncf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::truncf' is a}}
+ std::truncl; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::truncl' is a}}
+ std::try_lock; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::try_lock' is a}}
+ std::try_to_lock; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::try_to_lock' is a}}
+ std::try_to_lock_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::try_to_lock_t' is a}}
+ std::tuple; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::tuple' is a}}
+ std::tuple_cat; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::tuple_cat' is a}}
+ std::tuple_element_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::tuple_element_t' is a}}
+ std::tuple_size_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::tuple_size_v' is a}}
+ std::type_identity; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::type_identity' is a}}
+ std::type_identity_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::type_identity_t' is a}}
+ std::type_index; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::type_index' is a}}
+ std::type_info; // expected-error {{no member}} expected-note {{maybe try}}
+ std::u16streampos; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::u16streampos' is a}}
+ std::u16streampos; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::u16streampos' is a}}
+ std::u16string; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::u16string' is a}}
+ std::u16string_view; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::u16string_view' is a}}
+ std::u32streampos; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::u32streampos' is a}}
+ std::u32streampos; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::u32streampos' is a}}
+ std::u32string; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::u32string' is a}}
+ std::u32string_view; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::u32string_view' is a}}
+ std::u8streampos; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::u8streampos' is a}}
+ std::u8streampos; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::u8streampos' is a}}
+ std::u8string; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::u8string' is a}}
+ std::u8string_view; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::u8string_view' is a}}
+ std::uint16_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::uint16_t' is a}}
+ std::uint32_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::uint32_t' is a}}
+ std::uint64_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::uint64_t' is a}}
+ std::uint8_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::uint8_t' is a}}
+ std::uint_fast16_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::uint_fast16_t' is a}}
+ std::uint_fast32_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::uint_fast32_t' is a}}
+ std::uint_fast64_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::uint_fast64_t' is a}}
+ std::uint_fast8_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::uint_fast8_t' is a}}
+ std::uint_least16_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::uint_least16_t' is a}}
+ std::uint_least32_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::uint_least32_t' is a}}
+ std::uint_least64_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::uint_least64_t' is a}}
+ std::uint_least8_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::uint_least8_t' is a}}
+ std::uintmax_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::uintmax_t' is a}}
+ std::uintptr_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::uintptr_t' is a}}
+ std::unary_function; // expected-error {{no member}} expected-note {{maybe try}}
+ std::unary_negate; // expected-error {{no member}} expected-note {{maybe try}}
+ std::uncaught_exception; // expected-error {{no member}} expected-note {{maybe try}}
+ std::uncaught_exceptions; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::uncaught_exceptions' is a}}
+ std::undeclare_no_pointers; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::undeclare_no_pointers' is a}}
+ std::undeclare_reachable; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::undeclare_reachable' is a}}
+ std::underflow_error; // expected-error {{no member}} expected-note {{maybe try}}
+ std::underlying_type; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::underlying_type' is a}}
+ std::underlying_type_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::underlying_type_t' is a}}
+ std::unexpect; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::unexpect' is a}}
+ std::unexpect_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::unexpect_t' is a}}
+ std::unexpected; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::unexpected' is a}}
+ std::unexpected_handler; // expected-error {{no member}} expected-note {{maybe try}}
+ std::ungetc; // expected-error {{no member}} expected-note {{maybe try}}
+ std::ungetwc; // expected-error {{no member}} expected-note {{maybe try}}
+ std::uniform_int_distribution; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::uniform_int_distribution' is a}}
+ std::uniform_random_bit_generator; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::uniform_random_bit_generator' is a}}
+ std::uniform_real_distribution; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::uniform_real_distribution' is a}}
+ std::uninitialized_construct_using_allocator; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::uninitialized_construct_using_allocator' is a}}
+ std::uninitialized_copy; // expected-error {{no member}} expected-note {{maybe try}}
+ std::uninitialized_copy_n; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::uninitialized_copy_n' is a}}
+ std::uninitialized_default_construct; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::uninitialized_default_construct' is a}}
+ std::uninitialized_default_construct_n; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::uninitialized_default_construct_n' is a}}
+ std::uninitialized_fill; // expected-error {{no member}} expected-note {{maybe try}}
+ std::uninitialized_fill_n; // expected-error {{no member}} expected-note {{maybe try}}
+ std::uninitialized_move; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::uninitialized_move' is a}}
+ std::uninitialized_move_n; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::uninitialized_move_n' is a}}
+ std::uninitialized_value_construct; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::uninitialized_value_construct' is a}}
+ std::uninitialized_value_construct_n; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::uninitialized_value_construct_n' is a}}
+ std::unique; // expected-error {{no member}} expected-note {{maybe try}}
+ std::unique_copy; // expected-error {{no member}} expected-note {{maybe try}}
+ std::unique_lock; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::unique_lock' is a}}
+ std::unique_ptr; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::unique_ptr' is a}}
+ std::unitbuf; // expected-error {{no member}} expected-note {{maybe try}}
+ std::unitbuf; // expected-error {{no member}} expected-note {{maybe try}}
+ std::unordered_map; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::unordered_map' is a}}
+ std::unordered_multimap; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::unordered_multimap' is a}}
+ std::unordered_multiset; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::unordered_multiset' is a}}
+ std::unordered_set; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::unordered_set' is a}}
+ std::unreachable; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::unreachable' is a}}
+ std::unreachable_sentinel; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::unreachable_sentinel' is a}}
+ std::unreachable_sentinel_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::unreachable_sentinel_t' is a}}
+ std::unsigned_integral; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::unsigned_integral' is a}}
+ std::upper_bound; // expected-error {{no member}} expected-note {{maybe try}}
+ std::uppercase; // expected-error {{no member}} expected-note {{maybe try}}
+ std::uppercase; // expected-error {{no member}} expected-note {{maybe try}}
+ std::use_facet; // expected-error {{no member}} expected-note {{maybe try}}
+ std::uses_allocator; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::uses_allocator' is a}}
+ std::uses_allocator_construction_args; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::uses_allocator_construction_args' is a}}
+ std::uses_allocator_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::uses_allocator_v' is a}}
+ std::va_list; // expected-error {{no member}} expected-note {{maybe try}}
+ std::valarray; // expected-error {{no member}} expected-note {{maybe try}}
+ std::variant; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::variant' is a}}
+ std::variant_alternative; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::variant_alternative' is a}}
+ std::variant_alternative_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::variant_alternative_t' is a}}
+ std::variant_npos; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::variant_npos' is a}}
+ std::variant_size; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::variant_size' is a}}
+ std::variant_size_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::variant_size_v' is a}}
+ std::vector; // expected-error {{no member}} expected-note {{maybe try}}
+ std::vformat; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::vformat' is a}}
+ std::vformat_to; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::vformat_to' is a}}
+ std::vfprintf; // expected-error {{no member}} expected-note {{maybe try}}
+ std::vfscanf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::vfscanf' is a}}
+ std::vfwprintf; // expected-error {{no member}} expected-note {{maybe try}}
+ std::vfwscanf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::vfwscanf' is a}}
+ std::visit; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::visit' is a}}
+ std::visit_format_arg; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::visit_format_arg' is a}}
+ std::void_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::void_t' is a}}
+ std::vprint_nonunicode; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::vprint_nonunicode' is a}}
+ std::vprint_nonunicode_buffered; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::vprint_nonunicode_buffered' is a}}
+ std::vprint_unicode; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::vprint_unicode' is a}}
+ std::vprint_unicode_buffered; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::vprint_unicode_buffered' is a}}
+ std::vprintf; // expected-error {{no member}} expected-note {{maybe try}}
+ std::vscanf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::vscanf' is a}}
+ std::vsnprintf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::vsnprintf' is a}}
+ std::vsprintf; // expected-error {{no member}} expected-note {{maybe try}}
+ std::vsscanf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::vsscanf' is a}}
+ std::vswprintf; // expected-error {{no member}} expected-note {{maybe try}}
+ std::vswscanf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::vswscanf' is a}}
+ std::vwprintf; // expected-error {{no member}} expected-note {{maybe try}}
+ std::vwscanf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::vwscanf' is a}}
+ std::wbuffer_convert; // expected-error {{no member}} expected-note {{maybe try}}
+ std::wbuffer_convert; // expected-error {{no member}} expected-note {{maybe try}}
+ std::wcerr; // expected-error {{no member}} expected-note {{maybe try}}
+ std::wcin; // expected-error {{no member}} expected-note {{maybe try}}
+ std::wclog; // expected-error {{no member}} expected-note {{maybe try}}
+ std::wcmatch; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::wcmatch' is a}}
+ std::wcout; // expected-error {{no member}} expected-note {{maybe try}}
+ std::wcregex_iterator; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::wcregex_iterator' is a}}
+ std::wcregex_token_iterator; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::wcregex_token_iterator' is a}}
+ std::wcrtomb; // expected-error {{no member}} expected-note {{maybe try}}
+ std::wcscat; // expected-error {{no member}} expected-note {{maybe try}}
+ std::wcschr; // expected-error {{no member}} expected-note {{maybe try}}
+ std::wcscmp; // expected-error {{no member}} expected-note {{maybe try}}
+ std::wcscoll; // expected-error {{no member}} expected-note {{maybe try}}
+ std::wcscpy; // expected-error {{no member}} expected-note {{maybe try}}
+ std::wcscspn; // expected-error {{no member}} expected-note {{maybe try}}
+ std::wcsftime; // expected-error {{no member}} expected-note {{maybe try}}
+ std::wcslen; // expected-error {{no member}} expected-note {{maybe try}}
+ std::wcsncat; // expected-error {{no member}} expected-note {{maybe try}}
+ std::wcsncmp; // expected-error {{no member}} expected-note {{maybe try}}
+ std::wcsncpy; // expected-error {{no member}} expected-note {{maybe try}}
+ std::wcspbrk; // expected-error {{no member}} expected-note {{maybe try}}
+ std::wcsrchr; // expected-error {{no member}} expected-note {{maybe try}}
+ std::wcsrtombs; // expected-error {{no member}} expected-note {{maybe try}}
+ std::wcsspn; // expected-error {{no member}} expected-note {{maybe try}}
+ std::wcsstr; // expected-error {{no member}} expected-note {{maybe try}}
+ std::wcstod; // expected-error {{no member}} expected-note {{maybe try}}
+ std::wcstof; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::wcstof' is a}}
+ std::wcstoimax; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::wcstoimax' is a}}
+ std::wcstok; // expected-error {{no member}} expected-note {{maybe try}}
+ std::wcstol; // expected-error {{no member}} expected-note {{maybe try}}
+ std::wcstold; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::wcstold' is a}}
+ std::wcstoll; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::wcstoll' is a}}
+ std::wcstombs; // expected-error {{no member}} expected-note {{maybe try}}
+ std::wcstoul; // expected-error {{no member}} expected-note {{maybe try}}
+ std::wcstoull; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::wcstoull' is a}}
+ std::wcstoumax; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::wcstoumax' is a}}
+ std::wcsub_match; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::wcsub_match' is a}}
+ std::wcsxfrm; // expected-error {{no member}} expected-note {{maybe try}}
+ std::wctob; // expected-error {{no member}} expected-note {{maybe try}}
+ std::wctomb; // expected-error {{no member}} expected-note {{maybe try}}
+ std::wctrans; // expected-error {{no member}} expected-note {{maybe try}}
+ std::wctrans_t; // expected-error {{no member}} expected-note {{maybe try}}
+ std::wctype; // expected-error {{no member}} expected-note {{maybe try}}
+ std::wctype_t; // expected-error {{no member}} expected-note {{maybe try}}
+ std::weak_order; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::weak_order' is a}}
+ std::weak_ordering; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::weak_ordering' is a}}
+ std::weak_ptr; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::weak_ptr' is a}}
+ std::weakly_incrementable; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::weakly_incrementable' is a}}
+ std::weibull_distribution; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::weibull_distribution' is a}}
+ std::wfilebuf; // expected-error {{no member}} expected-note {{maybe try}}
+ std::wfilebuf; // expected-error {{no member}} expected-note {{maybe try}}
+ std::wformat_args; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::wformat_args' is a}}
+ std::wformat_context; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::wformat_context' is a}}
+ std::wformat_parse_context; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::wformat_parse_context' is a}}
+ std::wformat_string; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::wformat_string' is a}}
+ std::wfstream; // expected-error {{no member}} expected-note {{maybe try}}
+ std::wfstream; // expected-error {{no member}} expected-note {{maybe try}}
+ std::wifstream; // expected-error {{no member}} expected-note {{maybe try}}
+ std::wifstream; // expected-error {{no member}} expected-note {{maybe try}}
+ std::wios; // expected-error {{no member}} expected-note {{maybe try}}
+ std::wios; // expected-error {{no member}} expected-note {{maybe try}}
+ std::wios; // expected-error {{no member}} expected-note {{maybe try}}
+ std::wiostream; // expected-error {{no member}} expected-note {{maybe try}}
+ std::wiostream; // expected-error {{no member}} expected-note {{maybe try}}
+ std::wiostream; // expected-error {{no member}} expected-note {{maybe try}}
+ std::wispanstream; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::wispanstream' is a}}
+ std::wispanstream; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::wispanstream' is a}}
+ std::wistream; // expected-error {{no member}} expected-note {{maybe try}}
+ std::wistream; // expected-error {{no member}} expected-note {{maybe try}}
+ std::wistream; // expected-error {{no member}} expected-note {{maybe try}}
+ std::wistringstream; // expected-error {{no member}} expected-note {{maybe try}}
+ std::wistringstream; // expected-error {{no member}} expected-note {{maybe try}}
+ std::wmemchr; // expected-error {{no member}} expected-note {{maybe try}}
+ std::wmemcmp; // expected-error {{no member}} expected-note {{maybe try}}
+ std::wmemcpy; // expected-error {{no member}} expected-note {{maybe try}}
+ std::wmemmove; // expected-error {{no member}} expected-note {{maybe try}}
+ std::wmemset; // expected-error {{no member}} expected-note {{maybe try}}
+ std::wofstream; // expected-error {{no member}} expected-note {{maybe try}}
+ std::wofstream; // expected-error {{no member}} expected-note {{maybe try}}
+ std::wospanstream; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::wospanstream' is a}}
+ std::wospanstream; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::wospanstream' is a}}
+ std::wostream; // expected-error {{no member}} expected-note {{maybe try}}
+ std::wostream; // expected-error {{no member}} expected-note {{maybe try}}
+ std::wostream; // expected-error {{no member}} expected-note {{maybe try}}
+ std::wostringstream; // expected-error {{no member}} expected-note {{maybe try}}
+ std::wostringstream; // expected-error {{no member}} expected-note {{maybe try}}
+ std::wosyncstream; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::wosyncstream' is a}}
+ std::wosyncstream; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::wosyncstream' is a}}
+ std::wprintf; // expected-error {{no member}} expected-note {{maybe try}}
+ std::wregex; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::wregex' is a}}
+ std::ws; // expected-error {{no member}} expected-note {{maybe try}}
+ std::ws; // expected-error {{no member}} expected-note {{maybe try}}
+ std::wscanf; // expected-error {{no member}} expected-note {{maybe try}}
+ std::wsmatch; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::wsmatch' is a}}
+ std::wspanbuf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::wspanbuf' is a}}
+ std::wspanbuf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::wspanbuf' is a}}
+ std::wspanstream; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::wspanstream' is a}}
+ std::wspanstream; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::wspanstream' is a}}
+ std::wsregex_iterator; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::wsregex_iterator' is a}}
+ std::wsregex_token_iterator; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::wsregex_token_iterator' is a}}
+ std::wssub_match; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::wssub_match' is a}}
+ std::wstreambuf; // expected-error {{no member}} expected-note {{maybe try}}
+ std::wstreambuf; // expected-error {{no member}} expected-note {{maybe try}}
+ std::wstreambuf; // expected-error {{no member}} expected-note {{maybe try}}
+ std::wstreampos; // expected-error {{no member}} expected-note {{maybe try}}
+ std::wstreampos; // expected-error {{no member}} expected-note {{maybe try}}
+ std::wstring; // expected-error {{no member}} expected-note {{maybe try}}
+ std::wstring_convert; // expected-error {{no member}} expected-note {{maybe try}}
+ std::wstring_convert; // expected-error {{no member}} expected-note {{maybe try}}
+ std::wstring_view; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::wstring_view' is a}}
+ std::wstringbuf; // expected-error {{no member}} expected-note {{maybe try}}
+ std::wstringbuf; // expected-error {{no member}} expected-note {{maybe try}}
+ std::wstringstream; // expected-error {{no member}} expected-note {{maybe try}}
+ std::wstringstream; // expected-error {{no member}} expected-note {{maybe try}}
+ std::wsyncbuf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::wsyncbuf' is a}}
+ std::wsyncbuf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::wsyncbuf' is a}}
+ std::yocto; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::yocto' is a}}
+ std::yotta; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::yotta' is a}}
+ std::zepto; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::zepto' is a}}
+ std::zetta; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::zetta' is a}}
+ std::chrono::April; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::April' is a}}
+ std::chrono::August; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::August' is a}}
+ std::chrono::December; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::December' is a}}
+ std::chrono::February; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::February' is a}}
+ std::chrono::Friday; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::Friday' is a}}
+ std::chrono::January; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::January' is a}}
+ std::chrono::July; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::July' is a}}
+ std::chrono::June; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::June' is a}}
+ std::chrono::March; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::March' is a}}
+ std::chrono::May; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::May' is a}}
+ std::chrono::Monday; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::Monday' is a}}
+ std::chrono::November; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::November' is a}}
+ std::chrono::October; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::October' is a}}
+ std::chrono::Saturday; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::Saturday' is a}}
+ std::chrono::September; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::September' is a}}
+ std::chrono::Sunday; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::Sunday' is a}}
+ std::chrono::Thursday; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::Thursday' is a}}
+ std::chrono::Tuesday; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::Tuesday' is a}}
+ std::chrono::Wednesday; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::Wednesday' is a}}
+ std::chrono::abs; // expected-error {{no member}} expected-note {{maybe try}}
+ std::chrono::ambiguous_local_time; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::ambiguous_local_time' is a}}
+ std::chrono::ceil; // expected-error {{no member}} expected-note {{maybe try}}
+ std::chrono::choose; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::choose' is a}}
+ std::chrono::clock_cast; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::clock_cast' is a}}
+ std::chrono::clock_time_conversion; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::clock_time_conversion' is a}}
+ std::chrono::current_zone; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::current_zone' is a}}
+ std::chrono::day; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::day' is a}}
+ std::chrono::duration; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::duration' is a}}
+ std::chrono::duration_cast; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::duration_cast' is a}}
+ std::chrono::duration_values; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::duration_values' is a}}
+ std::chrono::file_clock; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::file_clock' is a}}
+ std::chrono::file_seconds; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::file_seconds' is a}}
+ std::chrono::file_time; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::file_time' is a}}
+ std::chrono::floor; // expected-error {{no member}} expected-note {{maybe try}}
+ std::chrono::from_stream; // expected-error {{no member}} expected-note {{maybe try}}
+ std::chrono::get_leap_second_info; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::get_leap_second_info' is a}}
+ std::chrono::gps_clock; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::gps_clock' is a}}
+ std::chrono::gps_seconds; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::gps_seconds' is a}}
+ std::chrono::gps_time; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::gps_time' is a}}
+ std::chrono::hh_mm_ss; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::hh_mm_ss' is a}}
+ std::chrono::high_resolution_clock; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::high_resolution_clock' is a}}
+ std::chrono::hours; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::hours' is a}}
+ std::chrono::is_am; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::is_am' is a}}
+ std::chrono::is_clock; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::is_clock' is a}}
+ std::chrono::is_clock_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::is_clock_v' is a}}
+ std::chrono::is_pm; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::is_pm' is a}}
+ std::chrono::last; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::last' is a}}
+ std::chrono::last_spec; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::last_spec' is a}}
+ std::chrono::leap_second; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::leap_second' is a}}
+ std::chrono::leap_second_info; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::leap_second_info' is a}}
+ std::chrono::local_info; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::local_info' is a}}
+ std::chrono::local_seconds; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::local_seconds' is a}}
+ std::chrono::local_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::local_t' is a}}
+ std::chrono::local_time; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::local_time' is a}}
+ std::chrono::local_time_format; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::local_time_format' is a}}
+ std::chrono::locate_zone; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::locate_zone' is a}}
+ std::chrono::make12; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::make12' is a}}
+ std::chrono::make24; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::make24' is a}}
+ std::chrono::microseconds; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::microseconds' is a}}
+ std::chrono::milliseconds; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::milliseconds' is a}}
+ std::chrono::minutes; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::minutes' is a}}
+ std::chrono::month; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::month' is a}}
+ std::chrono::month_day; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::month_day' is a}}
+ std::chrono::month_day_last; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::month_day_last' is a}}
+ std::chrono::month_weekday; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::month_weekday' is a}}
+ std::chrono::month_weekday_last; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::month_weekday_last' is a}}
+ std::chrono::nanoseconds; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::nanoseconds' is a}}
+ std::chrono::nonexistent_local_time; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::nonexistent_local_time' is a}}
+ std::chrono::parse; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::parse' is a}}
+ std::chrono::round; // expected-error {{no member}} expected-note {{maybe try}}
+ std::chrono::seconds; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::seconds' is a}}
+ std::chrono::steady_clock; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::steady_clock' is a}}
+ std::chrono::sys_days; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::sys_days' is a}}
+ std::chrono::sys_info; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::sys_info' is a}}
+ std::chrono::sys_seconds; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::sys_seconds' is a}}
+ std::chrono::sys_time; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::sys_time' is a}}
+ std::chrono::system_clock; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::system_clock' is a}}
+ std::chrono::tai_clock; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::tai_clock' is a}}
+ std::chrono::tai_seconds; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::tai_seconds' is a}}
+ std::chrono::tai_time; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::tai_time' is a}}
+ std::chrono::time_point; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::time_point' is a}}
+ std::chrono::time_point_cast; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::time_point_cast' is a}}
+ std::chrono::time_zone; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::time_zone' is a}}
+ std::chrono::time_zone_link; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::time_zone_link' is a}}
+ std::chrono::treat_as_floating_point; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::treat_as_floating_point' is a}}
+ std::chrono::treat_as_floating_point_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::treat_as_floating_point_v' is a}}
+ std::chrono::tzdb; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::tzdb' is a}}
+ std::chrono::tzdb_list; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::tzdb_list' is a}}
+ std::chrono::utc_clock; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::utc_clock' is a}}
+ std::chrono::utc_seconds; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::utc_seconds' is a}}
+ std::chrono::utc_time; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::utc_time' is a}}
+ std::chrono::weekday; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::weekday' is a}}
+ std::chrono::weekday_indexed; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::weekday_indexed' is a}}
+ std::chrono::weekday_last; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::weekday_last' is a}}
+ std::chrono::year; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::year' is a}}
+ std::chrono::year_month; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::year_month' is a}}
+ std::chrono::year_month_day; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::year_month_day' is a}}
+ std::chrono::year_month_day_last; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::year_month_day_last' is a}}
+ std::chrono::year_month_weekday; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::year_month_weekday' is a}}
+ std::chrono::year_month_weekday_last; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::year_month_weekday_last' is a}}
+ std::chrono::zoned_seconds; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::zoned_seconds' is a}}
+ std::chrono::zoned_time; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::zoned_time' is a}}
+ std::chrono::zoned_traits; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::zoned_traits' is a}}
+ std::execution::par; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::execution::par' is a}}
+ std::execution::par_unseq; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::execution::par_unseq' is a}}
+ std::execution::parallel_policy; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::execution::parallel_policy' is a}}
+ std::execution::parallel_unsequenced_policy; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::execution::parallel_unsequenced_policy' is a}}
+ std::execution::seq; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::execution::seq' is a}}
+ std::execution::sequenced_policy; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::execution::sequenced_policy' is a}}
+ std::execution::unseq; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::execution::unseq' is a}}
+ std::execution::unsequenced_policy; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::execution::unsequenced_policy' is a}}
+ std::filesystem::absolute; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::filesystem::absolute' is a}}
+ std::filesystem::begin; // expected-error {{no member}} expected-note {{maybe try}}
+ std::filesystem::canonical; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::filesystem::canonical' is a}}
+ std::filesystem::copy; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::filesystem::copy' is a}}
+ std::filesystem::copy_file; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::filesystem::copy_file' is a}}
+ std::filesystem::copy_options; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::filesystem::copy_options' is a}}
+ std::filesystem::copy_symlink; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::filesystem::copy_symlink' is a}}
+ std::filesystem::create_directories; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::filesystem::create_directories' is a}}
+ std::filesystem::create_directory; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::filesystem::create_directory' is a}}
+ std::filesystem::create_directory_symlink; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::filesystem::create_directory_symlink' is a}}
+ std::filesystem::create_hard_link; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::filesystem::create_hard_link' is a}}
+ std::filesystem::create_symlink; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::filesystem::create_symlink' is a}}
+ std::filesystem::current_path; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::filesystem::current_path' is a}}
+ std::filesystem::directory_entry; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::filesystem::directory_entry' is a}}
+ std::filesystem::directory_iterator; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::filesystem::directory_iterator' is a}}
+ std::filesystem::directory_options; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::filesystem::directory_options' is a}}
+ std::filesystem::end; // expected-error {{no member}} expected-note {{maybe try}}
+ std::filesystem::equivalent; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::filesystem::equivalent' is a}}
+ std::filesystem::exists; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::filesystem::exists' is a}}
+ std::filesystem::file_size; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::filesystem::file_size' is a}}
+ std::filesystem::file_status; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::filesystem::file_status' is a}}
+ std::filesystem::file_time_type; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::filesystem::file_time_type' is a}}
+ std::filesystem::file_type; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::filesystem::file_type' is a}}
+ std::filesystem::filesystem_error; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::filesystem::filesystem_error' is a}}
+ std::filesystem::hard_link_count; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::filesystem::hard_link_count' is a}}
+ std::filesystem::hash_value; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::filesystem::hash_value' is a}}
+ std::filesystem::is_block_file; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::filesystem::is_block_file' is a}}
+ std::filesystem::is_character_file; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::filesystem::is_character_file' is a}}
+ std::filesystem::is_directory; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::filesystem::is_directory' is a}}
+ std::filesystem::is_empty; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::filesystem::is_empty' is a}}
+ std::filesystem::is_fifo; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::filesystem::is_fifo' is a}}
+ std::filesystem::is_other; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::filesystem::is_other' is a}}
+ std::filesystem::is_regular_file; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::filesystem::is_regular_file' is a}}
+ std::filesystem::is_socket; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::filesystem::is_socket' is a}}
+ std::filesystem::is_symlink; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::filesystem::is_symlink' is a}}
+ std::filesystem::last_write_time; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::filesystem::last_write_time' is a}}
+ std::filesystem::path; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::filesystem::path' is a}}
+ std::filesystem::perm_options; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::filesystem::perm_options' is a}}
+ std::filesystem::permissions; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::filesystem::permissions' is a}}
+ std::filesystem::perms; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::filesystem::perms' is a}}
+ std::filesystem::proximate; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::filesystem::proximate' is a}}
+ std::filesystem::read_symlink; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::filesystem::read_symlink' is a}}
+ std::filesystem::recursive_directory_iterator; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::filesystem::recursive_directory_iterator' is a}}
+ std::filesystem::relative; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::filesystem::relative' is a}}
+ std::filesystem::remove; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::filesystem::remove' is a}}
+ std::filesystem::remove_all; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::filesystem::remove_all' is a}}
+ std::filesystem::rename; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::filesystem::rename' is a}}
+ std::filesystem::resize_file; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::filesystem::resize_file' is a}}
+ std::filesystem::space; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::filesystem::space' is a}}
+ std::filesystem::space_info; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::filesystem::space_info' is a}}
+ std::filesystem::status; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::filesystem::status' is a}}
+ std::filesystem::status_known; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::filesystem::status_known' is a}}
+ std::filesystem::symlink_status; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::filesystem::symlink_status' is a}}
+ std::filesystem::temp_directory_path; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::filesystem::temp_directory_path' is a}}
+ std::filesystem::u8path; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::filesystem::u8path' is a}}
+ std::filesystem::weakly_canonical; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::filesystem::weakly_canonical' is a}}
+ std::numbers::e; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::numbers::e' is a}}
+ std::numbers::e_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::numbers::e_v' is a}}
+ std::numbers::egamma; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::numbers::egamma' is a}}
+ std::numbers::egamma_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::numbers::egamma_v' is a}}
+ std::numbers::inv_pi; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::numbers::inv_pi' is a}}
+ std::numbers::inv_pi_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::numbers::inv_pi_v' is a}}
+ std::numbers::inv_sqrt3; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::numbers::inv_sqrt3' is a}}
+ std::numbers::inv_sqrt3_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::numbers::inv_sqrt3_v' is a}}
+ std::numbers::inv_sqrtpi; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::numbers::inv_sqrtpi' is a}}
+ std::numbers::inv_sqrtpi_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::numbers::inv_sqrtpi_v' is a}}
+ std::numbers::ln10; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::numbers::ln10' is a}}
+ std::numbers::ln10_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::numbers::ln10_v' is a}}
+ std::numbers::ln2; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::numbers::ln2' is a}}
+ std::numbers::ln2_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::numbers::ln2_v' is a}}
+ std::numbers::log10e; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::numbers::log10e' is a}}
+ std::numbers::log10e_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::numbers::log10e_v' is a}}
+ std::numbers::log2e; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::numbers::log2e' is a}}
+ std::numbers::log2e_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::numbers::log2e_v' is a}}
+ std::numbers::phi; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::numbers::phi' is a}}
+ std::numbers::phi_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::numbers::phi_v' is a}}
+ std::numbers::pi; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::numbers::pi' is a}}
+ std::numbers::pi_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::numbers::pi_v' is a}}
+ std::numbers::sqrt2; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::numbers::sqrt2' is a}}
+ std::numbers::sqrt2_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::numbers::sqrt2_v' is a}}
+ std::numbers::sqrt3; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::numbers::sqrt3' is a}}
+ std::numbers::sqrt3_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::numbers::sqrt3_v' is a}}
+ std::pmr::basic_string; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::pmr::basic_string' is a}}
+ std::pmr::cmatch; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::pmr::cmatch' is a}}
+ std::pmr::deque; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::pmr::deque' is a}}
+ std::pmr::forward_list; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::pmr::forward_list' is a}}
+ std::pmr::get_default_resource; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::pmr::get_default_resource' is a}}
+ std::pmr::list; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::pmr::list' is a}}
+ std::pmr::map; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::pmr::map' is a}}
+ std::pmr::match_results; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::pmr::match_results' is a}}
+ std::pmr::memory_resource; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::pmr::memory_resource' is a}}
+ std::pmr::monotonic_buffer_resource; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::pmr::monotonic_buffer_resource' is a}}
+ std::pmr::multimap; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::pmr::multimap' is a}}
+ std::pmr::multiset; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::pmr::multiset' is a}}
+ std::pmr::new_delete_resource; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::pmr::new_delete_resource' is a}}
+ std::pmr::null_memory_resource; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::pmr::null_memory_resource' is a}}
+ std::pmr::polymorphic_allocator; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::pmr::polymorphic_allocator' is a}}
+ std::pmr::pool_options; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::pmr::pool_options' is a}}
+ std::pmr::set; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::pmr::set' is a}}
+ std::pmr::set_default_resource; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::pmr::set_default_resource' is a}}
+ std::pmr::smatch; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::pmr::smatch' is a}}
+ std::pmr::stacktrace; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::pmr::stacktrace' is a}}
+ std::pmr::string; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::pmr::string' is a}}
+ std::pmr::synchronized_pool_resource; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::pmr::synchronized_pool_resource' is a}}
+ std::pmr::u16string; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::pmr::u16string' is a}}
+ std::pmr::u32string; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::pmr::u32string' is a}}
+ std::pmr::u8string; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::pmr::u8string' is a}}
+ std::pmr::unordered_map; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::pmr::unordered_map' is a}}
+ std::pmr::unordered_multimap; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::pmr::unordered_multimap' is a}}
+ std::pmr::unordered_multiset; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::pmr::unordered_multiset' is a}}
+ std::pmr::unordered_set; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::pmr::unordered_set' is a}}
+ std::pmr::unsynchronized_pool_resource; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::pmr::unsynchronized_pool_resource' is a}}
+ std::pmr::vector; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::pmr::vector' is a}}
+ std::pmr::wcmatch; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::pmr::wcmatch' is a}}
+ std::pmr::wsmatch; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::pmr::wsmatch' is a}}
+ std::pmr::wstring; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::pmr::wstring' is a}}
+ std::ranges::adjacent_find; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::adjacent_find' is a}}
+ std::ranges::adjacent_transform_view; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::adjacent_transform_view' is a}}
+ std::ranges::adjacent_view; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::adjacent_view' is a}}
+ std::ranges::advance; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::advance' is a}}
+ std::ranges::all_of; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::all_of' is a}}
+ std::ranges::any_of; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::any_of' is a}}
+ std::ranges::as_const_view; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::as_const_view' is a}}
+ std::ranges::as_rvalue_view; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::as_rvalue_view' is a}}
+ std::ranges::basic_istream_view; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::basic_istream_view' is a}}
+ std::ranges::bidirectional_range; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::bidirectional_range' is a}}
+ std::ranges::binary_transform_result; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::binary_transform_result' is a}}
+ std::ranges::borrowed_iterator_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::borrowed_iterator_t' is a}}
+ std::ranges::borrowed_range; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::borrowed_range' is a}}
+ std::ranges::borrowed_subrange_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::borrowed_subrange_t' is a}}
+ std::ranges::cartesian_product_view; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::cartesian_product_view' is a}}
+ std::ranges::chunk_by_view; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::chunk_by_view' is a}}
+ std::ranges::chunk_view; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::chunk_view' is a}}
+ std::ranges::clamp; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::clamp' is a}}
+ std::ranges::common_range; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::common_range' is a}}
+ std::ranges::common_view; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::common_view' is a}}
+ std::ranges::concat_view; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::concat_view' is a}}
+ std::ranges::const_iterator_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::const_iterator_t' is a}}
+ std::ranges::constant_range; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::constant_range' is a}}
+ std::ranges::construct_at; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::construct_at' is a}}
+ std::ranges::contains; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::contains' is a}}
+ std::ranges::contains_subrange; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::contains_subrange' is a}}
+ std::ranges::contiguous_range; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::contiguous_range' is a}}
+ std::ranges::copy; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::copy' is a}}
+ std::ranges::copy_backward; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::copy_backward' is a}}
+ std::ranges::copy_backward_result; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::copy_backward_result' is a}}
+ std::ranges::copy_if; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::copy_if' is a}}
+ std::ranges::copy_if_result; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::copy_if_result' is a}}
+ std::ranges::copy_n; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::copy_n' is a}}
+ std::ranges::copy_n_result; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::copy_n_result' is a}}
+ std::ranges::copy_result; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::copy_result' is a}}
+ std::ranges::count; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::count' is a}}
+ std::ranges::count_if; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::count_if' is a}}
+ std::ranges::dangling; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::dangling' is a}}
+ std::ranges::destroy; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::destroy' is a}}
+ std::ranges::destroy_at; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::destroy_at' is a}}
+ std::ranges::destroy_n; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::destroy_n' is a}}
+ std::ranges::disable_sized_range; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::disable_sized_range' is a}}
+ std::ranges::distance; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::distance' is a}}
+ std::ranges::drop_view; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::drop_view' is a}}
+ std::ranges::drop_while_view; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::drop_while_view' is a}}
+ std::ranges::elements_of; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::elements_of' is a}}
+ std::ranges::elements_view; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::elements_view' is a}}
+ std::ranges::empty_view; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::empty_view' is a}}
+ std::ranges::enable_borrowed_range; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::enable_borrowed_range' is a}}
+ std::ranges::enable_view; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::enable_view' is a}}
+ std::ranges::ends_with; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::ends_with' is a}}
+ std::ranges::enumerate_view; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::enumerate_view' is a}}
+ std::ranges::equal; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::equal' is a}}
+ std::ranges::fill; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::fill' is a}}
+ std::ranges::fill_n; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::fill_n' is a}}
+ std::ranges::filter_view; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::filter_view' is a}}
+ std::ranges::find; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::find' is a}}
+ std::ranges::find_end; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::find_end' is a}}
+ std::ranges::find_first_of; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::find_first_of' is a}}
+ std::ranges::find_if; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::find_if' is a}}
+ std::ranges::find_if_not; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::find_if_not' is a}}
+ std::ranges::find_last; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::find_last' is a}}
+ std::ranges::find_last_if; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::find_last_if' is a}}
+ std::ranges::find_last_if_not; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::find_last_if_not' is a}}
+ std::ranges::fold_left; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::fold_left' is a}}
+ std::ranges::fold_left_first; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::fold_left_first' is a}}
+ std::ranges::fold_left_first_with_iter; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::fold_left_first_with_iter' is a}}
+ std::ranges::fold_left_with_iter; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::fold_left_with_iter' is a}}
+ std::ranges::fold_right; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::fold_right' is a}}
+ std::ranges::fold_right_last; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::fold_right_last' is a}}
+ std::ranges::for_each; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::for_each' is a}}
+ std::ranges::for_each_n; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::for_each_n' is a}}
+ std::ranges::for_each_n_result; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::for_each_n_result' is a}}
+ std::ranges::for_each_result; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::for_each_result' is a}}
+ std::ranges::forward_range; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::forward_range' is a}}
+ std::ranges::generate; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::generate' is a}}
+ std::ranges::generate_n; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::generate_n' is a}}
+ std::ranges::get; // expected-error {{no member}} expected-note {{maybe try}}
+ std::ranges::greater; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::greater' is a}}
+ std::ranges::greater_equal; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::greater_equal' is a}}
+ std::ranges::in_found_result; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::in_found_result' is a}}
+ std::ranges::in_fun_result; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::in_fun_result' is a}}
+ std::ranges::in_in_out_result; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::in_in_out_result' is a}}
+ std::ranges::in_in_result; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::in_in_result' is a}}
+ std::ranges::in_out_out_result; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::in_out_out_result' is a}}
+ std::ranges::in_out_result; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::in_out_result' is a}}
+ std::ranges::in_value_result; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::in_value_result' is a}}
+ std::ranges::includes; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::includes' is a}}
+ std::ranges::inplace_merge; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::inplace_merge' is a}}
+ std::ranges::input_range; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::input_range' is a}}
+ std::ranges::iota; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::iota' is a}}
+ std::ranges::iota_result; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::iota_result' is a}}
+ std::ranges::iota_view; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::iota_view' is a}}
+ std::ranges::is_heap; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::is_heap' is a}}
+ std::ranges::is_heap_until; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::is_heap_until' is a}}
+ std::ranges::is_partitioned; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::is_partitioned' is a}}
+ std::ranges::is_permutation; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::is_permutation' is a}}
+ std::ranges::is_sorted; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::is_sorted' is a}}
+ std::ranges::is_sorted_until; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::is_sorted_until' is a}}
+ std::ranges::istream_view; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::istream_view' is a}}
+ std::ranges::iter_move; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::iter_move' is a}}
+ std::ranges::iter_swap; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::iter_swap' is a}}
+ std::ranges::iterator_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::iterator_t' is a}}
+ std::ranges::join_view; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::join_view' is a}}
+ std::ranges::join_with_view; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::join_with_view' is a}}
+ std::ranges::keys_view; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::keys_view' is a}}
+ std::ranges::lazy_split_view; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::lazy_split_view' is a}}
+ std::ranges::less; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::less' is a}}
+ std::ranges::less_equal; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::less_equal' is a}}
+ std::ranges::lexicographical_compare; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::lexicographical_compare' is a}}
+ std::ranges::make_heap; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::make_heap' is a}}
+ std::ranges::max_element; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::max_element' is a}}
+ std::ranges::merge; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::merge' is a}}
+ std::ranges::merge_result; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::merge_result' is a}}
+ std::ranges::min; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::min' is a}}
+ std::ranges::min_element; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::min_element' is a}}
+ std::ranges::min_max_result; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::min_max_result' is a}}
+ std::ranges::minmax; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::minmax' is a}}
+ std::ranges::minmax_element; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::minmax_element' is a}}
+ std::ranges::minmax_element_result; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::minmax_element_result' is a}}
+ std::ranges::minmax_result; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::minmax_result' is a}}
+ std::ranges::mismatch; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::mismatch' is a}}
+ std::ranges::mismatch_result; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::mismatch_result' is a}}
+ std::ranges::move; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::move' is a}}
+ std::ranges::move_backward; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::move_backward' is a}}
+ std::ranges::move_backward_result; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::move_backward_result' is a}}
+ std::ranges::move_result; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::move_result' is a}}
+ std::ranges::next; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::next' is a}}
+ std::ranges::next_permutation; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::next_permutation' is a}}
+ std::ranges::next_permutation_result; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::next_permutation_result' is a}}
+ std::ranges::none_of; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::none_of' is a}}
+ std::ranges::not_equal_to; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::not_equal_to' is a}}
+ std::ranges::nth_element; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::nth_element' is a}}
+ std::ranges::out_value_result; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::out_value_result' is a}}
+ std::ranges::output_range; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::output_range' is a}}
+ std::ranges::owning_view; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::owning_view' is a}}
+ std::ranges::partial_sort; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::partial_sort' is a}}
+ std::ranges::partial_sort_copy; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::partial_sort_copy' is a}}
+ std::ranges::partial_sort_copy_result; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::partial_sort_copy_result' is a}}
+ std::ranges::partition; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::partition' is a}}
+ std::ranges::partition_copy; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::partition_copy' is a}}
+ std::ranges::partition_copy_result; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::partition_copy_result' is a}}
+ std::ranges::partition_point; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::partition_point' is a}}
+ std::ranges::pop_heap; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::pop_heap' is a}}
+ std::ranges::prev; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::prev' is a}}
+ std::ranges::prev_permutation; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::prev_permutation' is a}}
+ std::ranges::prev_permutation_result; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::prev_permutation_result' is a}}
+ std::ranges::push_heap; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::push_heap' is a}}
+ std::ranges::random_access_range; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::random_access_range' is a}}
+ std::ranges::range; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::range' is a}}
+ std::ranges::range_adaptor_closure; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::range_adaptor_closure' is a}}
+ std::ranges::range_const_reference_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::range_const_reference_t' is a}}
+ std::ranges::range_difference_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::range_difference_t' is a}}
+ std::ranges::range_reference_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::range_reference_t' is a}}
+ std::ranges::range_rvalue_reference_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::range_rvalue_reference_t' is a}}
+ std::ranges::range_size_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::range_size_t' is a}}
+ std::ranges::range_value_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::range_value_t' is a}}
+ std::ranges::ref_view; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::ref_view' is a}}
+ std::ranges::remove; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::remove' is a}}
+ std::ranges::remove_copy; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::remove_copy' is a}}
+ std::ranges::remove_copy_if; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::remove_copy_if' is a}}
+ std::ranges::remove_copy_if_result; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::remove_copy_if_result' is a}}
+ std::ranges::remove_copy_result; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::remove_copy_result' is a}}
+ std::ranges::remove_if; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::remove_if' is a}}
+ std::ranges::repeat_view; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::repeat_view' is a}}
+ std::ranges::replace; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::replace' is a}}
+ std::ranges::replace_copy; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::replace_copy' is a}}
+ std::ranges::replace_copy_if; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::replace_copy_if' is a}}
+ std::ranges::replace_copy_if_result; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::replace_copy_if_result' is a}}
+ std::ranges::replace_copy_result; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::replace_copy_result' is a}}
+ std::ranges::replace_if; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::replace_if' is a}}
+ std::ranges::reverse; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::reverse' is a}}
+ std::ranges::reverse_copy; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::reverse_copy' is a}}
+ std::ranges::reverse_copy_result; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::reverse_copy_result' is a}}
+ std::ranges::reverse_view; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::reverse_view' is a}}
+ std::ranges::rotate; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::rotate' is a}}
+ std::ranges::rotate_copy; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::rotate_copy' is a}}
+ std::ranges::rotate_copy_result; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::rotate_copy_result' is a}}
+ std::ranges::sample; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::sample' is a}}
+ std::ranges::search; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::search' is a}}
+ std::ranges::search_n; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::search_n' is a}}
+ std::ranges::sentinel_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::sentinel_t' is a}}
+ std::ranges::set_difference; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::set_difference' is a}}
+ std::ranges::set_difference_result; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::set_difference_result' is a}}
+ std::ranges::set_intersection; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::set_intersection' is a}}
+ std::ranges::set_intersection_result; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::set_intersection_result' is a}}
+ std::ranges::set_symmetric_difference; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::set_symmetric_difference' is a}}
+ std::ranges::set_symmetric_difference_result; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::set_symmetric_difference_result' is a}}
+ std::ranges::set_union; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::set_union' is a}}
+ std::ranges::set_union_result; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::set_union_result' is a}}
+ std::ranges::shift_left; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::shift_left' is a}}
+ std::ranges::shift_right; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::shift_right' is a}}
+ std::ranges::shuffle; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::shuffle' is a}}
+ std::ranges::single_view; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::single_view' is a}}
+ std::ranges::sized_range; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::sized_range' is a}}
+ std::ranges::slide_view; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::slide_view' is a}}
+ std::ranges::sort; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::sort' is a}}
+ std::ranges::sort_heap; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::sort_heap' is a}}
+ std::ranges::split_view; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::split_view' is a}}
+ std::ranges::stable_partition; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::stable_partition' is a}}
+ std::ranges::stable_sort; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::stable_sort' is a}}
+ std::ranges::starts_with; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::starts_with' is a}}
+ std::ranges::stride_view; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::stride_view' is a}}
+ std::ranges::subrange; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::subrange' is a}}
+ std::ranges::subrange_kind; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::subrange_kind' is a}}
+ std::ranges::swap; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::swap' is a}}
+ std::ranges::swap_ranges; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::swap_ranges' is a}}
+ std::ranges::swap_ranges_result; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::swap_ranges_result' is a}}
+ std::ranges::take_view; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::take_view' is a}}
+ std::ranges::take_while_view; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::take_while_view' is a}}
+ std::ranges::to; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::to' is a}}
+ std::ranges::transform; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::transform' is a}}
+ std::ranges::transform_view; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::transform_view' is a}}
+ std::ranges::unary_transform_result; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::unary_transform_result' is a}}
+ std::ranges::uninitialized_copy; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::uninitialized_copy' is a}}
+ std::ranges::uninitialized_copy_n; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::uninitialized_copy_n' is a}}
+ std::ranges::uninitialized_copy_n_result; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::uninitialized_copy_n_result' is a}}
+ std::ranges::uninitialized_copy_result; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::uninitialized_copy_result' is a}}
+ std::ranges::uninitialized_default_construct; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::uninitialized_default_construct' is a}}
+ std::ranges::uninitialized_default_construct_n; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::uninitialized_default_construct_n' is a}}
+ std::ranges::uninitialized_fill; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::uninitialized_fill' is a}}
+ std::ranges::uninitialized_fill_n; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::uninitialized_fill_n' is a}}
+ std::ranges::uninitialized_move; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::uninitialized_move' is a}}
+ std::ranges::uninitialized_move_n; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::uninitialized_move_n' is a}}
+ std::ranges::uninitialized_move_n_result; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::uninitialized_move_n_result' is a}}
+ std::ranges::uninitialized_move_result; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::uninitialized_move_result' is a}}
+ std::ranges::uninitialized_value_construct; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::uninitialized_value_construct' is a}}
+ std::ranges::uninitialized_value_construct_n; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::uninitialized_value_construct_n' is a}}
+ std::ranges::unique; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::unique' is a}}
+ std::ranges::unique_copy; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::unique_copy' is a}}
+ std::ranges::unique_copy_result; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::unique_copy_result' is a}}
+ std::ranges::values_view; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::values_view' is a}}
+ std::ranges::view; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::view' is a}}
+ std::ranges::view_interface; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::view_interface' is a}}
+ std::ranges::viewable_range; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::viewable_range' is a}}
+ std::ranges::wistream_view; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::wistream_view' is a}}
+ std::ranges::zip_transform_view; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::zip_transform_view' is a}}
+ std::ranges::zip_view; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::zip_view' is a}}
+ std::ranges::views::adjacent; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::views::adjacent' is a}}
+ std::ranges::views::adjacent_transform; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::views::adjacent_transform' is a}}
+ std::ranges::views::all; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::views::all' is a}}
+ std::ranges::views::all_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::views::all_t' is a}}
+ std::ranges::views::as_const; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::views::as_const' is a}}
+ std::ranges::views::as_rvalue; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::views::as_rvalue' is a}}
+ std::ranges::views::cartesian_product; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::views::cartesian_product' is a}}
+ std::ranges::views::chunk; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::views::chunk' is a}}
+ std::ranges::views::chunk_by; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::views::chunk_by' is a}}
+ std::ranges::views::common; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::views::common' is a}}
+ std::ranges::views::concat; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::views::concat' is a}}
+ std::ranges::views::counted; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::views::counted' is a}}
+ std::ranges::views::drop; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::views::drop' is a}}
+ std::ranges::views::drop_while; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::views::drop_while' is a}}
+ std::ranges::views::elements; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::views::elements' is a}}
+ std::ranges::views::empty; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::views::empty' is a}}
+ std::ranges::views::enumerate; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::views::enumerate' is a}}
+ std::ranges::views::filter; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::views::filter' is a}}
+ std::ranges::views::iota; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::views::iota' is a}}
+ std::ranges::views::istream; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::views::istream' is a}}
+ std::ranges::views::istream; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::views::istream' is a}}
+ std::ranges::views::join; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::views::join' is a}}
+ std::ranges::views::join_with; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::views::join_with' is a}}
+ std::ranges::views::keys; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::views::keys' is a}}
+ std::ranges::views::lazy_split; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::views::lazy_split' is a}}
+ std::ranges::views::pairwise; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::views::pairwise' is a}}
+ std::ranges::views::pairwise_transform; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::views::pairwise_transform' is a}}
+ std::ranges::views::repeat; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::views::repeat' is a}}
+ std::ranges::views::reverse; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::views::reverse' is a}}
+ std::ranges::views::single; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::views::single' is a}}
+ std::ranges::views::slide; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::views::slide' is a}}
+ std::ranges::views::split; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::views::split' is a}}
+ std::ranges::views::stride; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::views::stride' is a}}
+ std::ranges::views::take; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::views::take' is a}}
+ std::ranges::views::take_while; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::views::take_while' is a}}
+ std::ranges::views::transform; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::views::transform' is a}}
+ std::ranges::views::values; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::views::values' is a}}
+ std::ranges::views::zip; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::views::zip' is a}}
+ std::ranges::views::zip_transform; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::views::zip_transform' is a}}
+ std::regex_constants::ECMAScript; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::regex_constants::ECMAScript' is a}}
+ std::regex_constants::awk; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::regex_constants::awk' is a}}
+ std::regex_constants::basic; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::regex_constants::basic' is a}}
+ std::regex_constants::collate; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::regex_constants::collate' is a}}
+ std::regex_constants::egrep; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::regex_constants::egrep' is a}}
+ std::regex_constants::error_backref; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::regex_constants::error_backref' is a}}
+ std::regex_constants::error_badbrace; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::regex_constants::error_badbrace' is a}}
+ std::regex_constants::error_badrepeat; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::regex_constants::error_badrepeat' is a}}
+ std::regex_constants::error_brace; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::regex_constants::error_brace' is a}}
+ std::regex_constants::error_brack; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::regex_constants::error_brack' is a}}
+ std::regex_constants::error_collate; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::regex_constants::error_collate' is a}}
+ std::regex_constants::error_complexity; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::regex_constants::error_complexity' is a}}
+ std::regex_constants::error_ctype; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::regex_constants::error_ctype' is a}}
+ std::regex_constants::error_escape; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::regex_constants::error_escape' is a}}
+ std::regex_constants::error_paren; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::regex_constants::error_paren' is a}}
+ std::regex_constants::error_range; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::regex_constants::error_range' is a}}
+ std::regex_constants::error_space; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::regex_constants::error_space' is a}}
+ std::regex_constants::error_stack; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::regex_constants::error_stack' is a}}
+ std::regex_constants::error_type; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::regex_constants::error_type' is a}}
+ std::regex_constants::extended; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::regex_constants::extended' is a}}
+ std::regex_constants::format_default; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::regex_constants::format_default' is a}}
+ std::regex_constants::format_first_only; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::regex_constants::format_first_only' is a}}
+ std::regex_constants::format_no_copy; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::regex_constants::format_no_copy' is a}}
+ std::regex_constants::format_sed; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::regex_constants::format_sed' is a}}
+ std::regex_constants::grep; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::regex_constants::grep' is a}}
+ std::regex_constants::icase; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::regex_constants::icase' is a}}
+ std::regex_constants::match_any; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::regex_constants::match_any' is a}}
+ std::regex_constants::match_continuous; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::regex_constants::match_continuous' is a}}
+ std::regex_constants::match_default; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::regex_constants::match_default' is a}}
+ std::regex_constants::match_flag_type; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::regex_constants::match_flag_type' is a}}
+ std::regex_constants::match_not_bol; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::regex_constants::match_not_bol' is a}}
+ std::regex_constants::match_not_bow; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::regex_constants::match_not_bow' is a}}
+ std::regex_constants::match_not_eol; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::regex_constants::match_not_eol' is a}}
+ std::regex_constants::match_not_eow; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::regex_constants::match_not_eow' is a}}
+ std::regex_constants::match_not_null; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::regex_constants::match_not_null' is a}}
+ std::regex_constants::match_prev_avail; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::regex_constants::match_prev_avail' is a}}
+ std::regex_constants::multiline; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::regex_constants::multiline' is a}}
+ std::regex_constants::nosubs; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::regex_constants::nosubs' is a}}
+ std::regex_constants::optimize; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::regex_constants::optimize' is a}}
+ std::regex_constants::syntax_option_type; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::regex_constants::syntax_option_type' is a}}
+ std::this_thread::get_id; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::this_thread::get_id' is a}}
+ std::this_thread::sleep_for; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::this_thread::sleep_for' is a}}
+ std::this_thread::sleep_until; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::this_thread::sleep_until' is a}}
+ std::this_thread::yield; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::this_thread::yield' is a}}
+ std::views::adjacent; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::views::adjacent' is a}}
+ std::views::adjacent_transform; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::views::adjacent_transform' is a}}
+ std::views::all; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::views::all' is a}}
+ std::views::all_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::views::all_t' is a}}
+ std::views::as_const; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::views::as_const' is a}}
+ std::views::as_rvalue; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::views::as_rvalue' is a}}
+ std::views::cartesian_product; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::views::cartesian_product' is a}}
+ std::views::chunk; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::views::chunk' is a}}
+ std::views::chunk_by; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::views::chunk_by' is a}}
+ std::views::common; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::views::common' is a}}
+ std::views::concat; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::views::concat' is a}}
+ std::views::counted; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::views::counted' is a}}
+ std::views::drop; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::views::drop' is a}}
+ std::views::drop_while; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::views::drop_while' is a}}
+ std::views::elements; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::views::elements' is a}}
+ std::views::empty; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::views::empty' is a}}
+ std::views::enumerate; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::views::enumerate' is a}}
+ std::views::filter; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::views::filter' is a}}
+ std::views::iota; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::views::iota' is a}}
+ std::views::istream; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::views::istream' is a}}
+ std::views::istream; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::views::istream' is a}}
+ std::views::join; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::views::join' is a}}
+ std::views::join_with; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::views::join_with' is a}}
+ std::views::keys; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::views::keys' is a}}
+ std::views::lazy_split; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::views::lazy_split' is a}}
+ std::views::pairwise; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::views::pairwise' is a}}
+ std::views::pairwise_transform; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::views::pairwise_transform' is a}}
+ std::views::repeat; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::views::repeat' is a}}
+ std::views::reverse; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::views::reverse' is a}}
+ std::views::single; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::views::single' is a}}
+ std::views::slide; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::views::slide' is a}}
+ std::views::split; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::views::split' is a}}
+ std::views::stride; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::views::stride' is a}}
+ std::views::take; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::views::take' is a}}
+ std::views::take_while; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::views::take_while' is a}}
+ std::views::transform; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::views::transform' is a}}
+ std::views::values; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::views::values' is a}}
+ std::views::zip; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::views::zip' is a}}
+ std::views::zip_transform; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::views::zip_transform' is a}}
+}
diff --git a/clang/test/SemaCXX/no-implicit-builtin-decls.cpp b/clang/test/SemaCXX/no-implicit-builtin-decls.cpp
index d82f7f18bffe0..3707799ec4ee0 100644
--- a/clang/test/SemaCXX/no-implicit-builtin-decls.cpp
+++ b/clang/test/SemaCXX/no-implicit-builtin-decls.cpp
@@ -1,7 +1,7 @@
// RUN: %clang_cc1 -fsyntax-only -verify %s
void f() {
- void *p = malloc(sizeof(int) * 10); // expected-error{{use of undeclared identifier 'malloc'}}
+ void *p = malloc(sizeof(int) * 10); // expected-error{{use of undeclared identifier 'malloc'}} expected-note {{maybe try to include <cstdlib>; 'malloc' is defined in <cstdlib>}}
}
int malloc(double);
>From e16383a8295aad89af3f51bbac7d605129502e44 Mon Sep 17 00:00:00 2001
From: Vincent <llvm at viceroygroup.ca>
Date: Sat, 5 Jul 2025 18:05:34 +0800
Subject: [PATCH 2/2] Address Commments
---
clang/docs/ReleaseNotes.rst | 2 +-
.../clang/Basic/DiagnosticSemaKinds.td | 4 +-
.../Tooling/Inclusions/StandardLibrary.h | 25 +-
clang/lib/Parse/ParseExprCXX.cpp | 14 -
clang/lib/Sema/SemaDecl.cpp | 32 +-
.../Inclusions/Stdlib/StandardLibrary.cpp | 51 +-
clang/test/Headers/stddef.c | 52 +-
clang/test/Headers/stddefneeds.c | 68 +-
clang/test/Headers/stddefneeds.cpp | 20 +-
...mplicit-declared-allocation-functions.cppm | 18 +-
clang/test/Modules/macro-reexport.cpp | 6 +-
clang/test/Modules/stddef.cpp | 2 +-
clang/test/Sema/MicrosoftCompatibility.c | 2 +-
clang/test/Sema/builtin-setjmp.c | 4 +-
.../c23-delayed-typo-correction-crashes.c | 2 +-
clang/test/Sema/implicit-builtin-decl.c | 2 +-
clang/test/Sema/include-suggestion.c | 2 +-
.../test/SemaCXX/constructor-initializer.cpp | 2 +-
.../test/SemaCXX/include-suggestions-cxx.cpp | 4317 +++++++----------
.../SemaCXX/no-implicit-builtin-decls.cpp | 2 +-
20 files changed, 1998 insertions(+), 2629 deletions(-)
diff --git a/clang/docs/ReleaseNotes.rst b/clang/docs/ReleaseNotes.rst
index 73bf23887b412..0fd5681defe03 100644
--- a/clang/docs/ReleaseNotes.rst
+++ b/clang/docs/ReleaseNotes.rst
@@ -478,7 +478,7 @@ Improvements to Clang's diagnostics
diagnostics. This fixes a bunch of `bool` being printed as `_Bool`, and also
a bunch of HLSL types being printed as their C++ equivalents.
- Clang now consistently quotes expressions in diagnostics.
-- Clang now suggest standard library include path and its associated C++ or C language version.
+- Clang now suggests including standard library headers when encountering standard types.
- When printing types for diagnostics, clang now doesn't suppress the scopes of
template arguments contained within nested names.
- The ``-Wshift-bool`` warning has been added to warn about shifting a boolean. (#GH28334)
diff --git a/clang/include/clang/Basic/DiagnosticSemaKinds.td b/clang/include/clang/Basic/DiagnosticSemaKinds.td
index 1ef776f8d82c5..9ad0800c5ec71 100644
--- a/clang/include/clang/Basic/DiagnosticSemaKinds.td
+++ b/clang/include/clang/Basic/DiagnosticSemaKinds.td
@@ -5991,9 +5991,9 @@ def err_template_expansion_into_fixed_list : Error<
def note_parameter_type : Note<
"parameter of type %0 is declared here">;
def note_standard_lib_include_suggestion : Note<
- "maybe try to include %0; '%1' is defined in %0">;
+ "'%1%2' is defined in %0; did you mean to include it?">;
def note_standard_lib_version : Note<
- "'%0' is a %1 feature">;
+ "'%0%1' is a %select{c99|c11|c++11|c++14|c++17|c++20|c++23|c++26}2 feature">;
// C++11 Variadic Templates
def err_template_param_pack_default_arg : Error<
diff --git a/clang/include/clang/Tooling/Inclusions/StandardLibrary.h b/clang/include/clang/Tooling/Inclusions/StandardLibrary.h
index 42bbb5b3f0d8c..d499a76d63d2d 100644
--- a/clang/include/clang/Tooling/Inclusions/StandardLibrary.h
+++ b/clang/include/clang/Tooling/Inclusions/StandardLibrary.h
@@ -15,6 +15,7 @@
#ifndef LLVM_CLANG_TOOLING_INCLUSIONS_STANDARDLIBRARY_H
#define LLVM_CLANG_TOOLING_INCLUSIONS_STANDARDLIBRARY_H
+#include "clang/Basic/LangStandard.h"
#include "llvm/ADT/DenseMap.h"
#include "llvm/ADT/Hashing.h"
#include "llvm/ADT/StringRef.h"
@@ -29,28 +30,6 @@ class NamespaceDecl;
class DeclContext;
namespace tooling {
namespace stdlib {
-enum Version {
- Unknown,
-
- // c++ versions
- CPlusPlusStart,
- CPlusPlus11,
- CPlusPlus14,
- CPlusPlus17,
- CPlusPlus20,
- CPlusPlus23,
- CPlusPlus26,
- CPlusPlusEnd,
-
- // c version
- CStart,
- C99,
- C11,
- CEnd
-};
-
-llvm::StringRef GetAsString(Version Ver);
-
class Symbol;
enum class Lang { C = 0, CXX, LastValue = CXX };
@@ -106,7 +85,7 @@ class Symbol {
std::optional<Header> header() const;
// Some symbols may be provided by multiple headers.
llvm::SmallVector<Header> headers() const;
- Version version() const;
+ std::optional<LangFeatures> version() const;
private:
Symbol(unsigned ID, Lang Language) : ID(ID), Language(Language) {}
diff --git a/clang/lib/Parse/ParseExprCXX.cpp b/clang/lib/Parse/ParseExprCXX.cpp
index 9de0e9ca74c6f..1ea0cf52933f6 100644
--- a/clang/lib/Parse/ParseExprCXX.cpp
+++ b/clang/lib/Parse/ParseExprCXX.cpp
@@ -226,11 +226,6 @@ bool Parser::ParseOptionalCXXScopeSpecifier(
HasScopeSpecifier = true;
}
- // If `FailedNestedNameBuilding` is true, attempt to suggest the standard
- // include file corresponding to the current `FullNamespace` and symbol.
- std::string FullNamespace = "";
- bool FailedNesatedNameBuilding = false;
-
// Preferred type might change when parsing qualifiers, we need the original.
auto SavedType = PreferredType;
while (true) {
@@ -459,9 +454,6 @@ bool Parser::ParseOptionalCXXScopeSpecifier(
// We have an identifier followed by a '::'. Lookup this name
// as the name in a nested-name-specifier.
Token Identifier = Tok;
- FullNamespace += Identifier.getIdentifierInfo()->getName();
- FullNamespace += "::";
-
SourceLocation IdLoc = ConsumeToken();
assert(Tok.isOneOf(tok::coloncolon, tok::colon) &&
"NextToken() not working properly!");
@@ -473,7 +465,6 @@ bool Parser::ParseOptionalCXXScopeSpecifier(
if (Actions.ActOnCXXNestedNameSpecifier(
getCurScope(), IdInfo, EnteringContext, SS, CorrectionFlagPtr,
OnlyNamespace)) {
- FailedNesatedNameBuilding = true;
// Identifier is not recognized as a nested name, but we can have
// mistyped '::' instead of ':'.
if (CorrectionFlagPtr && IsCorrectedToColon) {
@@ -563,11 +554,6 @@ bool Parser::ParseOptionalCXXScopeSpecifier(
break;
}
- if (FailedNesatedNameBuilding && Tok.getKind() == tok::identifier) {
- Actions.NoteStandardIncludes(Tok.getIdentifierInfo()->getName(),
- Tok.getLocation(), FullNamespace);
- }
-
// Even if we didn't see any pieces of a nested-name-specifier, we
// still check whether there is a tilde in this position, which
// indicates a potential pseudo-destructor.
diff --git a/clang/lib/Sema/SemaDecl.cpp b/clang/lib/Sema/SemaDecl.cpp
index caf162a3e79c0..a8fd98f817fdb 100644
--- a/clang/lib/Sema/SemaDecl.cpp
+++ b/clang/lib/Sema/SemaDecl.cpp
@@ -814,6 +814,29 @@ void Sema::DiagnoseUnknownTypeName(IdentifierInfo *&II,
NoteStandardIncludes(II->getName(), IILoc, SS);
}
+static unsigned int GetLangFeatureDiagNum(LangFeatures Feature) {
+ switch (Feature) {
+ case C99:
+ return 0;
+ case C11:
+ return 1;
+ case CPlusPlus11:
+ return 2;
+ case CPlusPlus14:
+ return 3;
+ case CPlusPlus17:
+ return 4;
+ case CPlusPlus20:
+ return 5;
+ case CPlusPlus23:
+ return 6;
+ case CPlusPlus26:
+ return 7;
+ default:
+ llvm_unreachable("Invalid LangFeatures options.");
+ }
+}
+
void Sema::NoteStandardIncludes(StringRef SymbolName, SourceLocation IILoc,
StringRef Namespace) {
using clang::tooling::stdlib::Lang;
@@ -828,15 +851,12 @@ void Sema::NoteStandardIncludes(StringRef SymbolName, SourceLocation IILoc,
if (auto Header = StdSym->header()) {
HeaderName = Header->name();
Diag(IILoc, diag::note_standard_lib_include_suggestion)
- << HeaderName << (Namespace + SymbolName).str();
+ << HeaderName << Namespace << SymbolName;
// Noting the C/C++ version as well
- if (StdSym->version() != tooling::stdlib::Unknown) {
- llvm::StringRef CPlusPlusVersion =
- tooling::stdlib::GetAsString(StdSym->version());
-
+ if (auto LangVersion = StdSym->version()) {
Diag(IILoc, diag::note_standard_lib_version)
- << (Namespace + SymbolName).str() << CPlusPlusVersion;
+ << Namespace << SymbolName << GetLangFeatureDiagNum(*LangVersion);
}
}
}
diff --git a/clang/lib/Tooling/Inclusions/Stdlib/StandardLibrary.cpp b/clang/lib/Tooling/Inclusions/Stdlib/StandardLibrary.cpp
index 562faa2cbf5eb..e187f742ad725 100644
--- a/clang/lib/Tooling/Inclusions/Stdlib/StandardLibrary.cpp
+++ b/clang/lib/Tooling/Inclusions/Stdlib/StandardLibrary.cpp
@@ -36,9 +36,9 @@ struct SymbolHeaderMapping {
const char *Data; // std::vector
unsigned ScopeLen; // ~~~~~
unsigned NameLen; // ~~~~~~
- Version CurrentVersion;
+ std::optional<LangFeatures> CurrentVersion;
- Version version() const { return CurrentVersion; }
+ std::optional<LangFeatures> version() const { return CurrentVersion; }
StringRef scope() const { return StringRef(Data, ScopeLen); }
StringRef name() const { return StringRef(Data + ScopeLen, NameLen); }
StringRef qualifiedName() const {
@@ -135,17 +135,17 @@ static int initialize(Lang Language) {
++SymIndex;
} // Else use the same index.
- Version CurrentVersion = llvm::StringSwitch<Version>(Ver)
- .Case("c++11", CPlusPlus11)
- .Case("c++14", CPlusPlus14)
- .Case("c++17", CPlusPlus17)
- .Case("c++20", CPlusPlus20)
- .Case("c++23", CPlusPlus23)
- .Case("c++26", CPlusPlus26)
- .Case("c99", C99)
- .Case("c11", C11)
- .Case("unknown", Unknown)
- .Default(Unknown);
+ std::optional<LangFeatures> CurrentVersion =
+ llvm::StringSwitch<std::optional<LangFeatures>>(Ver)
+ .Case("c++11", std::make_optional(CPlusPlus11))
+ .Case("c++14", std::make_optional(CPlusPlus14))
+ .Case("c++17", std::make_optional(CPlusPlus17))
+ .Case("c++20", std::make_optional(CPlusPlus20))
+ .Case("c++23", std::make_optional(CPlusPlus23))
+ .Case("c++26", std::make_optional(CPlusPlus26))
+ .Case("c99", std::make_optional(C99))
+ .Case("c11", std::make_optional(C11))
+ .Default(std::nullopt);
Mapping->SymbolNames[SymIndex] = {
QName.data(), NSLen, static_cast<unsigned int>(QName.size() - NSLen),
@@ -248,7 +248,7 @@ llvm::StringRef Symbol::name() const {
llvm::StringRef Symbol::qualifiedName() const {
return getMappingPerLang(Language)->SymbolNames[ID].qualifiedName();
}
-Version Symbol::version() const {
+std::optional<LangFeatures> Symbol::version() const {
return getMappingPerLang(Language)->SymbolNames[ID].version();
}
std::optional<Symbol> Symbol::named(llvm::StringRef Scope, llvm::StringRef Name,
@@ -347,29 +347,6 @@ std::optional<Symbol> Recognizer::operator()(const Decl *D) {
return std::nullopt;
return Symbol(It->second, L);
}
-
-llvm::StringRef GetAsString(Version Ver) {
- switch (Ver) {
- case tooling::stdlib::CPlusPlus11:
- return "c++11";
- case tooling::stdlib::CPlusPlus14:
- return "c++14";
- case tooling::stdlib::CPlusPlus17:
- return "c++17";
- case tooling::stdlib::CPlusPlus20:
- return "c++20";
- case tooling::stdlib::CPlusPlus23:
- return "c++23";
- case tooling::stdlib::CPlusPlus26:
- return "c++26";
- case tooling::stdlib::C99:
- return "c99";
- case tooling::stdlib::C11:
- return "c11";
- default:
- llvm_unreachable("other optinos shouldn't be possible!");
- }
-}
} // namespace stdlib
} // namespace tooling
} // namespace clang
diff --git a/clang/test/Headers/stddef.c b/clang/test/Headers/stddef.c
index 23564325d0088..ff8af1c2b1492 100644
--- a/clang/test/Headers/stddef.c
+++ b/clang/test/Headers/stddef.c
@@ -10,20 +10,20 @@ struct astruct { char member; };
ptrdiff_t p0; // c99-error{{unknown type name 'ptrdiff_t'}} c11-error{{unknown type}} c23-error{{unknown type}} \
c99-modules-error{{unknown type}} c11-modules-error{{unknown type}} c23-modules-error{{unknown type}} \
- c99-note {{maybe try to include <stddef.h>; 'ptrdiff_t' is defined in <stddef.h>}} \
- c11-note {{maybe try to include <stddef.h>; 'ptrdiff_t' is defined in <stddef.h>}} \
- c23-note {{maybe try to include <stddef.h>; 'ptrdiff_t' is defined in <stddef.h>}} \
- c99-modules-note {{maybe try to include <stddef.h>; 'ptrdiff_t' is defined in <stddef.h>}} \
- c11-modules-note {{maybe try to include <stddef.h>; 'ptrdiff_t' is defined in <stddef.h>}} \
- c23-modules-note {{maybe try to include <stddef.h>; 'ptrdiff_t' is defined in <stddef.h>}}
+ c99-note {{'ptrdiff_t' is defined in <stddef.h>}} \
+ c11-note {{'ptrdiff_t' is defined in <stddef.h>}} \
+ c23-note {{'ptrdiff_t' is defined in <stddef.h>}} \
+ c99-modules-note {{'ptrdiff_t' is defined in <stddef.h>}} \
+ c11-modules-note {{'ptrdiff_t' is defined in <stddef.h>}} \
+ c23-modules-note {{'ptrdiff_t' is defined in <stddef.h>}}
size_t s0; // c99-error{{unknown type name 'size_t'}} c11-error{{unknown type}} c23-error{{unknown type}} \
c99-modules-error{{unknown type}} c11-modules-error{{unknown type}} c23-modules-error{{unknown type}} \
- c99-note {{maybe try}} \
- c11-note {{maybe try}} \
- c23-note {{maybe try}} \
- c99-modules-note {{maybe try to include <stddef.h>; 'size_t' is defined in <stddef.h>}} \
- c11-modules-note {{maybe try to include <stddef.h>; 'size_t' is defined in <stddef.h>}} \
- c23-modules-note {{maybe try to include <stddef.h>; 'size_t' is defined in <stddef.h>}}
+ c99-note {{'size_t' is defined in}} \
+ c11-note {{'size_t' is defined in}} \
+ c23-note {{'size_t' is defined in}} \
+ c99-modules-note {{'size_t' is defined in <stddef.h>}} \
+ c11-modules-note {{'size_t' is defined in <stddef.h>}} \
+ c23-modules-note {{'size_t' is defined in <stddef.h>}}
rsize_t r0; // c99-error{{unknown type name 'rsize_t'}} c11-error{{unknown type}} c23-error{{unknown type}} \
c99-modules-error{{unknown type}} c11-modules-error{{unknown type}} c23-modules-error{{unknown type}}
wchar_t wc0; // c99-error{{unknown type name 'wchar_t'}} c11-error{{unknown type}} c23-error{{unknown type}} \
@@ -36,17 +36,17 @@ static void f0(void) { unreachable(); } // c99-error{{call to undeclared functio
c99-modules-error{{undeclared function}} c11-modules-error{{undeclared function}} c23-modules-error{{undeclared identifier}}
max_align_t m0; // c99-error{{unknown type name 'max_align_t'}} c11-error{{unknown type}} c23-error{{unknown type}} \
c99-modules-error{{unknown type}} c11-modules-error{{unknown type}} c23-modules-error{{unknown type}} \
- c99-note {{maybe try}} \
+ c99-note {{'max_align_t' is defined in}} \
c99-note {{'max_align_t' is a c11 feature}} \
- c11-note {{maybe try}} \
+ c11-note {{'max_align_t' is defined in}} \
c11-note {{'max_align_t' is a c11 feature}} \
- c23-note {{maybe try}} \
+ c23-note {{'max_align_t' is defined in}} \
c23-note {{'max_align_t' is a c11 feature}} \
- c99-modules-note {{maybe try to include <stddef.h>; 'max_align_t' is defined in <stddef.h>}} \
+ c99-modules-note {{'max_align_t' is defined in <stddef.h>}} \
c99-modules-note {{'max_align_t' is a c11 feature}} \
- c11-modules-note {{maybe try to include <stddef.h>; 'max_align_t' is defined in <stddef.h>}} \
+ c11-modules-note {{'max_align_t' is defined in <stddef.h>}} \
c11-modules-note {{'max_align_t' is a c11 feature}} \
- c23-modules-note {{maybe try to include <stddef.h>; 'max_align_t' is defined in <stddef.h>}} \
+ c23-modules-note {{'max_align_t' is defined in <stddef.h>}} \
c23-modules-note {{'max_align_t' is a c11 feature}}
size_t o0 = offsetof(struct astruct, member); // c99-error{{unknown type name 'size_t'}} c99-error{{call to undeclared function 'offsetof'}} c99-error{{expected expression}} c99-error{{use of undeclared identifier 'member'}} \
c11-error{{unknown type}} c11-error{{undeclared function}} c11-error{{expected expression}} c11-error{{undeclared identifier}} \
@@ -54,12 +54,12 @@ size_t o0 = offsetof(struct astruct, member); // c99-error{{unknown type name 's
c99-modules-error{{unknown type}} c99-modules-error{{undeclared function}} c99-modules-error{{expected expression}} c99-modules-error{{undeclared identifier}} \
c11-modules-error{{unknown type}} c11-modules-error{{undeclared function}} c11-modules-error{{expected expression}} c11-modules-error{{undeclared identifier}} \
c23-modules-error{{unknown type}} c23-modules-error{{undeclared identifier}} c23-modules-error{{expected expression}} c23-modules-error{{undeclared identifier}} \
- c99-note {{maybe try}} \
- c11-note {{maybe try}} \
- c23-note {{maybe try}} \
- c99-modules-note {{maybe try}} \
- c11-modules-note {{maybe try}} \
- c23-modules-note {{maybe try}}
+ c99-note {{'size_t' is defined in}} \
+ c11-note {{'size_t' is defined in}} \
+ c23-note {{'size_t' is defined in}} \
+ c99-modules-note {{'size_t' is defined in}} \
+ c11-modules-note {{'size_t' is defined in}} \
+ c23-modules-note {{'size_t' is defined in}}
wint_t wi0; // c99-error{{unknown type name 'wint_t'}} c11-error{{unknown type}} c23-error{{unknown type}} \
c99-modules-error{{unknown type name 'wint_t'}} c11-modules-error{{unknown type}} c23-modules-error{{unknown type}}
@@ -79,7 +79,7 @@ static void f1(void) { unreachable(); } // c99-error{{undeclared function}} c11-
c99-modules-error{{undeclared function}} c11-modules-error{{undeclared function}}
max_align_t m1; // c99-error{{unknown type}} c99-modules-error{{'max_align_t' must be declared before it is used}} \
c99-modules-note at __stddef_max_align_t.h:*{{declaration here is not visible}} \
- c99-note {{maybe try}} \
+ c99-note {{'max_align_t' is defined in}} \
c99-note {{'max_align_t' is a c11 feature}}
size_t o1 = offsetof(struct astruct, member);
wint_t wi1; // c99-error{{unknown type}} c11-error{{unknown type}} c23-error{{unknown type}} \
@@ -98,7 +98,7 @@ nullptr_t n2; // c99-error{{unknown type}} c11-error{{unknown type}} \
static void f2(void) { unreachable(); } // c99-error{{undeclared function}} c11-error{{undeclared function}} \
c99-modules-error{{undeclared function}} c11-modules-error{{undeclared function}}
max_align_t m2; // c99-error{{unknown type}} \
- c99-note {{maybe try}} \
+ c99-note {{'max_align_t' is defined in}} \
c99-note {{'max_align_t' is a c11 feature}}
size_t o2 = offsetof(struct astruct, member);
wint_t wi2; // c99-error{{unknown type}} c11-error{{unknown type}} c23-error{{unknown type}} \
diff --git a/clang/test/Headers/stddefneeds.c b/clang/test/Headers/stddefneeds.c
index 5766d589ea81d..e41b05308ba05 100644
--- a/clang/test/Headers/stddefneeds.c
+++ b/clang/test/Headers/stddefneeds.c
@@ -10,16 +10,16 @@ struct astruct { char member; };
ptrdiff_t p0; // c99-error{{unknown type name 'ptrdiff_t'}} c23-error{{unknown type}} \
c99-modules-error{{unknown type}} c23-modules-error{{unknown type}} \
- c99-note {{maybe try to include <stddef.h>; 'ptrdiff_t' is defined in <stddef.h>}} \
- c23-note {{maybe try to include <stddef.h>; 'ptrdiff_t' is defined in <stddef.h>}} \
- c99-modules-note {{maybe try to include <stddef.h>; 'ptrdiff_t' is defined in <stddef.h>}} \
- c23-modules-note {{maybe try to include <stddef.h>; 'ptrdiff_t' is defined in <stddef.h>}}
+ c99-note {{'ptrdiff_t' is defined in <stddef.h>}} \
+ c23-note {{'ptrdiff_t' is defined in <stddef.h>}} \
+ c99-modules-note {{'ptrdiff_t' is defined in <stddef.h>}} \
+ c23-modules-note {{'ptrdiff_t' is defined in <stddef.h>}}
size_t s0; // c99-error{{unknown type name 'size_t'}} c23-error{{unknown type}} \
c99-modules-error{{unknown type}} c23-modules-error{{unknown type}}\
- c99-note {{maybe try to include <stddef.h>; 'size_t' is defined in <stddef.h>}} \
- c23-note {{maybe try to include <stddef.h>; 'size_t' is defined in <stddef.h>}} \
- c99-modules-note {{maybe try to include <stddef.h>; 'size_t' is defined in <stddef.h>}} \
- c23-modules-note {{maybe try to include <stddef.h>; 'size_t' is defined in <stddef.h>}}
+ c99-note {{'size_t' is defined in <stddef.h>}} \
+ c23-note {{'size_t' is defined in <stddef.h>}} \
+ c99-modules-note {{'size_t' is defined in <stddef.h>}} \
+ c23-modules-note {{'size_t' is defined in <stddef.h>}}
rsize_t r0; // c99-error{{unknown type name 'rsize_t'}} c23-error{{unknown type}} \
c99-modules-error{{unknown type}} c23-modules-error{{unknown type}}
wchar_t wc0; // c99-error{{unknown type name 'wchar_t'}} c23-error{{unknown type}} \
@@ -32,22 +32,22 @@ static void f0(void) { unreachable(); } // c99-error{{call to undeclared functio
c99-modules-error{{undeclared function}} c23-modules-error{{undeclared identifier}}
max_align_t m0; // c99-error{{unknown type name 'max_align_t'}} c23-error{{unknown type}} \
c99-modules-error{{unknown type}} c23-modules-error{{unknown type}} \
- c99-note {{maybe try to include <stddef.h>; 'max_align_t' is defined in <stddef.h>}} \
+ c99-note {{'max_align_t' is defined in <stddef.h>}} \
c99-note {{max_align_t' is a c11 feature}} \
- c23-note {{maybe try to include <stddef.h>; 'max_align_t' is defined in <stddef.h>}} \
+ c23-note {{'max_align_t' is defined in <stddef.h>}} \
c23-note {{max_align_t' is a c11 feature}}\
- c99-modules-note {{maybe try to include <stddef.h>; 'max_align_t' is defined in <stddef.h>}} \
+ c99-modules-note {{'max_align_t' is defined in <stddef.h>}} \
c99-modules-note {{max_align_t' is a c11 feature}} \
- c23-modules-note {{maybe try to include <stddef.h>; 'max_align_t' is defined in <stddef.h>}} \
+ c23-modules-note {{'max_align_t' is defined in <stddef.h>}} \
c23-modules-note {{max_align_t' is a c11 feature}}
size_t o0 = offsetof(struct astruct, member); // c99-error{{unknown type name 'size_t'}} c99-error{{call to undeclared function 'offsetof'}} c99-error{{expected expression}} c99-error{{use of undeclared identifier 'member'}} \
c23-error{{unknown type name 'size_t'}} c23-error{{undeclared identifier 'offsetof'}} c23-error{{expected expression}} c23-error{{use of undeclared identifier 'member'}} \
c99-modules-error{{unknown type}} c99-modules-error{{undeclared function}} c99-modules-error{{expected expression}} c99-modules-error{{undeclared identifier}} \
c23-modules-error{{unknown type}} c23-modules-error{{undeclared identifier}} c23-modules-error{{expected expression}} c23-modules-error{{undeclared identifier}}\
- c99-note {{maybe try to include <stddef.h>; 'size_t' is defined in <stddef.h>}} \
- c23-note {{maybe try to include <stddef.h>; 'size_t' is defined in <stddef.h>}}\
- c99-modules-note {{maybe try to include <stddef.h>; 'size_t' is defined in <stddef.h>}} \
- c23-modules-note {{maybe try to include <stddef.h>; 'size_t' is defined in <stddef.h>}}
+ c99-note {{'size_t' is defined in <stddef.h>}} \
+ c23-note {{'size_t' is defined in <stddef.h>}}\
+ c99-modules-note {{'size_t' is defined in <stddef.h>}} \
+ c23-modules-note {{'size_t' is defined in <stddef.h>}}
wint_t wi0; // c99-error{{unknown type name 'wint_t'}} c23-error{{unknown type}} \
c99-modules-error{{unknown type}} c23-modules-error{{unknown type}}
@@ -59,8 +59,8 @@ ptrdiff_t p1;
size_t s1; // c99-error{{unknown type}} c23-error{{unknown type}} \
c99-modules-error{{'size_t' must be declared before it is used}} c23-modules-error{{must be declared}} \
c99-modules-note at __stddef_size_t.h:*{{declaration here is not visible}} c23-modules-note at __stddef_size_t.h:*{{declaration here is not visible}} \
- c99-note {{maybe try to include <stddef.h>; 'size_t' is defined in <stddef.h>}} \
- c23-note {{maybe try to include <stddef.h>; 'size_t' is defined in <stddef.h>}}
+ c99-note {{'size_t' is defined in <stddef.h>}} \
+ c23-note {{'size_t' is defined in <stddef.h>}}
rsize_t r1; // c99-error{{unknown type}} c23-error{{unknown type}} \
c99-modules-error{{'rsize_t' must be declared before it is used}} c23-modules-error{{must be declared}} \
c99-modules-note at __stddef_rsize_t.h:*{{declaration here is not visible}} c23-modules-note at __stddef_rsize_t.h:*{{declaration here is not visible}}
@@ -77,17 +77,17 @@ static void f1(void) { unreachable(); } // c99-error{{undeclared function}} c23-
max_align_t m1; // c99-error{{unknown type}} c23-error{{unknown type}} \
c99-modules-error{{'max_align_t' must be declared before it is used}} c23-modules-error{{must be declared}} \
c99-modules-note at __stddef_max_align_t.h:*{{declaration here is not visible}} c23-modules-note at __stddef_max_align_t.h:*{{declaration here is not visible}} \
- c99-note {{maybe try to include <stddef.h>; 'max_align_t' is defined in <stddef.h>}} \
+ c99-note {{'max_align_t' is defined in <stddef.h>}} \
c99-note {{'max_align_t' is a c11 feature}} \
- c23-note {{maybe try to include <stddef.h>; 'max_align_t' is defined in <stddef.h>}} \
+ c23-note {{'max_align_t' is defined in <stddef.h>}} \
c23-note {{'max_align_t' is a c11 feature}}
size_t o1 = offsetof(struct astruct, member); // c99-error{{unknown type}} c99-error{{expected expression}} c99-error{{undeclared identifier}} \
c23-error{{unknown type}} c23-error{{undeclared identifier}} c23-error{{expected expression}} c23-error{{undeclared identifier}} \
c99-modules-error{{expected expression}} c99-modules-error{{undeclared identifier}} \
c23-modules-error{{undeclared identifier}} c23-modules-error{{expected expression}} c23-modules-error{{undeclared identifier}} \
- c99-note {{maybe try to include <stddef.h>; 'size_t' is defined in <stddef.h>}} \
- c23-note {{maybe try to include <stddef.h>; 'size_t' is defined in <stddef.h>}}
+ c99-note {{'size_t' is defined in <stddef.h>}} \
+ c23-note {{'size_t' is defined in <stddef.h>}}
wint_t wi1; // c99-error{{unknown type}} c23-error{{unknown type}} \
c99-modules-error{{unknown type}} c23-modules-error{{unknown type}}
@@ -113,9 +113,9 @@ nullptr_t n2; // c99-error{{unknown type}} c23-error{{unknown type}} \
static void f2(void) { unreachable(); } // c99-error{{undeclared function}} c23-error{{undeclared identifier}} \
c99-modules-error{{undeclared function}} c23-modules-error{{undeclared identifier}}
max_align_t m2; // c99-error{{unknown type}} c23-error{{unknown type}} \
- c99-note {{maybe try to include <stddef.h>; 'max_align_t' is defined in <stddef.h>}} \
+ c99-note {{'max_align_t' is defined in <stddef.h>}} \
c99-note {{'max_align_t' is a c11 feature}} \
- c23-note {{maybe try to include <stddef.h>; 'max_align_t' is defined in <stddef.h>}} \
+ c23-note {{'max_align_t' is defined in <stddef.h>}} \
c23-note {{'max_align_t' is a c11 feature}}
size_t o2 = offsetof(struct astruct, member); // c99-error{{expected expression}} c99-error{{undeclared identifier}} \
c23-error{{undeclared identifier}} c23-error{{expected expression}} c23-error{{undeclared identifier}} \
@@ -138,9 +138,9 @@ nullptr_t n3; // c99-error{{unknown type}} c23-error{{unknown type}} \
static void f3(void) { unreachable(); } // c99-error{{undeclared function}} c23-error{{undeclared identifier}} \
c99-modules-error{{undeclared function}} c23-modules-error{{undeclared identifier}}
max_align_t m3; // c99-error{{unknown type}} c23-error{{unknown type}} \
- c99-note {{maybe try to include <stddef.h>; 'max_align_t' is defined in <stddef.h>}} \
+ c99-note {{'max_align_t' is defined in <stddef.h>}} \
c99-note {{'max_align_t' is a c11 feature}} \
- c23-note {{maybe try to include <stddef.h>; 'max_align_t' is defined in <stddef.h>}} \
+ c23-note {{'max_align_t' is defined in <stddef.h>}} \
c23-note {{'max_align_t' is a c11 feature}}
size_t o3 = offsetof(struct astruct, member); // c99-error{{expected expression}} c99-error{{undeclared identifier}} \
c23-error{{undeclared identifier}} c23-error{{expected expression}} c23-error{{undeclared identifier}} \
@@ -163,9 +163,9 @@ nullptr_t n4; // c99-error{{unknown type}} c23-error{{unknown type}} \
static void f4(void) { unreachable(); } // c99-error{{undeclared function}} c23-error{{undeclared identifier}} \
c99-modules-error{{undeclared function}} c23-modules-error{{undeclared identifier}}
max_align_t m4; // c99-error{{unknown type}} c23-error{{unknown type}} \
- c99-note {{maybe try to include <stddef.h>; 'max_align_t' is defined in <stddef.h>}} \
+ c99-note {{'max_align_t' is defined in <stddef.h>}} \
c99-note {{'max_align_t' is a c11 feature}} \
- c23-note {{maybe try to include <stddef.h>; 'max_align_t' is defined in <stddef.h>}} \
+ c23-note {{'max_align_t' is defined in <stddef.h>}} \
c23-note {{'max_align_t' is a c11 feature}}
size_t o4 = offsetof(struct astruct, member); // c99-error{{expected expression}} c99-error{{undeclared identifier}} \
c23-error{{undeclared identifier}} c23-error{{expected expression}} c23-error{{undeclared identifier}} \
@@ -187,9 +187,9 @@ nullptr_t n5; // c99-error{{unknown type}} c23-error{{unknown type}} \
static void f5(void) { unreachable(); } // c99-error{{undeclared function}} c23-error{{undeclared identifier}} \
c99-modules-error{{undeclared function}} c23-modules-error{{undeclared identifier}}
max_align_t m5; // c99-error{{unknown type}} c23-error{{unknown type}} \
- c99-note {{maybe try to include <stddef.h>; 'max_align_t' is defined in <stddef.h>}} \
+ c99-note {{'max_align_t' is defined in <stddef.h>}} \
c99-note {{'max_align_t' is a c11 feature}} \
- c23-note {{maybe try to include <stddef.h>; 'max_align_t' is defined in <stddef.h>}} \
+ c23-note {{'max_align_t' is defined in <stddef.h>}} \
c23-note {{'max_align_t' is a c11 feature}}
size_t o5 = offsetof(struct astruct, member); // c99-error{{expected expression}} c99-error{{undeclared identifier}} \
c23-error{{undeclared identifier}} c23-error{{expected expression}} c23-error{{undeclared identifier}} \
@@ -212,9 +212,9 @@ nullptr_t n6; // c99-error{{unknown type}} c99-modules-error{{unknown type}}
static void f6(void) { unreachable(); } // c99-error{{undeclared function}} c23-error{{undeclared identifier}} \
c99-modules-error{{undeclared function}} c23-modules-error{{undeclared identifier}}
max_align_t m6; // c99-error{{unknown type}} c23-error{{unknown type}} \
- c99-note {{maybe try to include <stddef.h>; 'max_align_t' is defined in <stddef.h>}} \
+ c99-note {{'max_align_t' is defined in <stddef.h>}} \
c99-note {{'max_align_t' is a c11 feature}} \
- c23-note {{maybe try to include <stddef.h>; 'max_align_t' is defined in <stddef.h>}} \
+ c23-note {{'max_align_t' is defined in <stddef.h>}} \
c23-note {{'max_align_t' is a c11 feature}}
size_t o6 = offsetof(struct astruct, member); // c99-error{{expected expression}} c99-error{{undeclared identifier}} \
c23-error{{undeclared identifier}} c23-error{{expected expression}} c23-error{{undeclared identifier}} \
@@ -234,9 +234,9 @@ void *v7 = NULL;
nullptr_t n7 ; // c99-error{{unknown type}} c99-modules-error{{unknown type}}
static void f7(void) { unreachable(); }
max_align_t m7; // c99-error{{unknown type}} c23-error{{unknown type}} \
- c99-note {{maybe try to include <stddef.h>; 'max_align_t' is defined in <stddef.h>}} \
+ c99-note {{'max_align_t' is defined in <stddef.h>}} \
c99-note {{'max_align_t' is a c11 feature}} \
- c23-note {{maybe try to include <stddef.h>; 'max_align_t' is defined in <stddef.h>}} \
+ c23-note {{'max_align_t' is defined in <stddef.h>}} \
c23-note {{'max_align_t' is a c11 feature}}
size_t o7 = offsetof(struct astruct, member); // c99-error{{expected expression}} c99-error{{undeclared identifier}} \
c23-error{{undeclared identifier}} c23-error{{expected expression}} c23-error{{undeclared identifier}} \
diff --git a/clang/test/Headers/stddefneeds.cpp b/clang/test/Headers/stddefneeds.cpp
index 4e73a3d7fbd07..aa0e610c37aac 100644
--- a/clang/test/Headers/stddefneeds.cpp
+++ b/clang/test/Headers/stddefneeds.cpp
@@ -1,28 +1,28 @@
// RUN: %clang_cc1 -fsyntax-only -triple x86_64-apple-macosx10.9.0 -verify -Wsentinel -std=c++11 %s
-ptrdiff_t p0; // expected-error{{unknown}} expected-note {{maybe try to include <cstddef>; 'ptrdiff_t' is defined in <cstddef>}}
-size_t s0; // expected-error{{unknown}} expected-note {{maybe try to include <cstddef>; 'size_t' is defined in <cstddef>}}
-void* v0 = NULL; // expected-error{{undeclared}} expected-note {{maybe try to include <cstddef>; 'NULL' is defined in <cstddef>}}
+ptrdiff_t p0; // expected-error{{unknown}} expected-note {{'ptrdiff_t' is defined in <cstddef>}}
+size_t s0; // expected-error{{unknown}} expected-note {{'size_t' is defined in <cstddef>}}
+void* v0 = NULL; // expected-error{{undeclared}} expected-note {{'NULL' is defined in <cstddef>}}
wint_t w0; // expected-error{{unknown}}
-max_align_t m0; // expected-error{{unknown}} expected-note {{maybe try to include <cstddef>; 'max_align_t' is defined in <cstddef>}}
+max_align_t m0; // expected-error{{unknown}} expected-note {{'max_align_t' is defined in <cstddef>}}
#define __need_ptrdiff_t
#include <stddef.h>
ptrdiff_t p1;
-size_t s1; // expected-error{{unknown}} expected-note {{maybe try to include <cstddef>; 'size_t' is defined in <cstddef>}}
-void* v1 = NULL; // expected-error{{undeclared}} expected-note {{maybe try to include <cstddef>; 'NULL' is defined in <cstddef>}}
+size_t s1; // expected-error{{unknown}} expected-note {{'size_t' is defined in <cstddef>}}
+void* v1 = NULL; // expected-error{{undeclared}} expected-note {{'NULL' is defined in <cstddef>}}
wint_t w1; // expected-error{{unknown}}
-max_align_t m1; // expected-error{{unknown}} expected-note {{maybe try to include <cstddef>; 'max_align_t' is defined in <cstddef>}}
+max_align_t m1; // expected-error{{unknown}} expected-note {{'max_align_t' is defined in <cstddef>}}
#define __need_size_t
#include <stddef.h>
ptrdiff_t p2;
size_t s2;
-void* v2 = NULL; // expected-error{{undeclared}} expected-note {{maybe try to include <cstddef>; 'NULL' is defined in <cstddef>}}
+void* v2 = NULL; // expected-error{{undeclared}} expected-note {{'NULL' is defined in <cstddef>}}
wint_t w2; // expected-error{{unknown}}
-max_align_t m2; // expected-error{{unknown}} expected-note {{maybe try to include <cstddef>; 'max_align_t' is defined in <cstddef>}}
+max_align_t m2; // expected-error{{unknown}} expected-note {{'max_align_t' is defined in <cstddef>}}
#define __need_NULL
#include <stddef.h>
@@ -31,7 +31,7 @@ ptrdiff_t p3;
size_t s3;
void* v3 = NULL;
wint_t w3; // expected-error{{unknown}}
-max_align_t m3; // expected-error{{unknown}} expected-note {{maybe try to include <cstddef>; 'max_align_t' is defined in <cstddef>}}
+max_align_t m3; // expected-error{{unknown}} expected-note {{'max_align_t' is defined in <cstddef>}}
// Shouldn't bring in wint_t by default:
#include <stddef.h>
diff --git a/clang/test/Modules/implicit-declared-allocation-functions.cppm b/clang/test/Modules/implicit-declared-allocation-functions.cppm
index cc6b1f0951bb5..b378a1d1365ee 100644
--- a/clang/test/Modules/implicit-declared-allocation-functions.cppm
+++ b/clang/test/Modules/implicit-declared-allocation-functions.cppm
@@ -17,20 +17,14 @@ export void alloc_wrapper() {
// std::align_Âval_Ât is ill-formed unless a standard library declaration
// ([cstddef.syn], [new.syn], [std.modules]) of that name precedes
// ([basic.lookup.general]) the use of that name.
- void *b = ::operator new((std::size_t)32); // expected-error {{use of undeclared identifier 'std'}} expected-note {{maybe try to include <cstddef>; 'std::size_t' is defined in <cstddef>}}
- void *c = ::operator new((std::size_t)32, // expected-error {{use of undeclared identifier 'std'}} expected-note {{maybe try to include <cstddef>; 'std::size_t' is defined in <cstddef>}}
- (std::align_val_t)64); // expected-error {{use of undeclared identifier 'std'}} \
- expected-note {{maybe try to include <new>; 'std::align_val_t' is defined in <new>}} \
- expected-note {{'std::align_val_t' is a c++17 feature}}
+ void *b = ::operator new((std::size_t)32); // expected-error {{use of undeclared identifier 'std'}}
+ void *c = ::operator new((std::size_t)32, // expected-error {{use of undeclared identifier 'std'}}
+ (std::align_val_t)64); // expected-error {{use of undeclared identifier 'std'}}
::operator delete(a);
- ::operator delete(b, (std::size_t)32); // expected-error {{use of undeclared identifier 'std'}} \
- expected-note {{maybe try to include <cstddef>; 'std::size_t' is defined in <cstddef>}}
- ::operator delete(c, (std::size_t)32, // expected-error {{use of undeclared identifier 'std'}} \
- expected-note {{maybe try to include <cstddef>; 'std::size_t' is defined in <cstddef>}}
- (std::align_val_t)64); // expected-error {{use of undeclared identifier 'std'}} \
- expected-note {{maybe try to include <new>; 'std::align_val_t' is defined in <new>}} \
- expected-note {{'std::align_val_t' is a c++17 feature}}
+ ::operator delete(b, (std::size_t)32); // expected-error {{use of undeclared identifier 'std'}}
+ ::operator delete(c, (std::size_t)32, // expected-error {{use of undeclared identifier 'std'}}
+ (std::align_val_t)64); // expected-error {{use of undeclared identifier 'std'}}
}
//--- new
diff --git a/clang/test/Modules/macro-reexport.cpp b/clang/test/Modules/macro-reexport.cpp
index 2a76f4d800386..972733f46bf69 100644
--- a/clang/test/Modules/macro-reexport.cpp
+++ b/clang/test/Modules/macro-reexport.cpp
@@ -21,13 +21,13 @@
#include "f1.h"
void f() { return assert(true); } // expected-error {{undeclared identifier 'd'}}
#include "e2.h" // undefines d1's macro
-void g() { return assert(true); } // expected-error {{undeclared identifier 'assert'}} expected-note {{maybe try to include <cassert>; 'assert' is defined in <cassert>}}
+void g() { return assert(true); } // expected-error {{undeclared identifier 'assert'}} expected-note {{'assert' is defined in <cassert>}}
#elif defined(D1)
#include "e1.h" // undefines c1's macro but not d1's macro
#include "d1.h"
void f() { return assert(true); } // expected-error {{undeclared identifier 'd'}}
#include "e2.h" // undefines d1's macro
-void g() { return assert(true); } // expected-error {{undeclared identifier 'assert'}} expected-note {{maybe try to include <cassert>; 'assert' is defined in <cassert>}}
+void g() { return assert(true); } // expected-error {{undeclared identifier 'assert'}} expected-note {{'assert' is defined in <cassert>}}
#elif defined(D2)
#include "d2.h"
void f() { return assert(true); } // expected-error {{undeclared identifier 'b'}}
@@ -35,5 +35,5 @@ void f() { return assert(true); } // expected-error {{undeclared identifier 'b'}
// e2 undefines d1's macro, which overrides c1's macro.
#include "e2.h"
#include "c1.h"
-void f() { return assert(true); } // expected-error {{undeclared identifier 'assert'}} expected-note {{maybe try to include <cassert>; 'assert' is defined in <cassert>}}
+void f() { return assert(true); } // expected-error {{undeclared identifier 'assert'}} expected-note {{'assert' is defined in <cassert>}}
#endif
diff --git a/clang/test/Modules/stddef.cpp b/clang/test/Modules/stddef.cpp
index 86622f0fef510..6b335fff48e6a 100644
--- a/clang/test/Modules/stddef.cpp
+++ b/clang/test/Modules/stddef.cpp
@@ -16,7 +16,7 @@ size_t size = 0;
#undef NULL
#include <stddef.h>
-void *anotherPointer = NULL; // expected-error{{use of undeclared identifier 'NULL'}} expected-note {{maybe try to include <cstddef>; 'NULL' is defined in <cstddef>}}
+void *anotherPointer = NULL; // expected-error{{use of undeclared identifier 'NULL'}} expected-note {{'NULL' is defined in <cstddef>}}
// stddef.h needs to be a `textual` header to support clients doing things like
// this.
diff --git a/clang/test/Sema/MicrosoftCompatibility.c b/clang/test/Sema/MicrosoftCompatibility.c
index 131d044d3f9c0..8426468a7fdb2 100644
--- a/clang/test/Sema/MicrosoftCompatibility.c
+++ b/clang/test/Sema/MicrosoftCompatibility.c
@@ -33,7 +33,7 @@ __declspec(__noreturn__) void f7(void); /* expected-warning {{__declspec attribu
#ifdef MSVCCOMPAT
size_t x;
#else
-size_t x; // expected-error {{unknown type name 'size_t'}} expected-note {{maybe try to include <stddef.h>; 'size_t' is defined in <stddef.h>}}
+size_t x; // expected-error {{unknown type name 'size_t'}} expected-note {{'size_t' is defined in}}
#endif
/* Microsoft allows inline, __inline, and __forceinline to appear on a typedef
diff --git a/clang/test/Sema/builtin-setjmp.c b/clang/test/Sema/builtin-setjmp.c
index 3231ca4373fd4..e0a45652ef8a7 100644
--- a/clang/test/Sema/builtin-setjmp.c
+++ b/clang/test/Sema/builtin-setjmp.c
@@ -36,12 +36,12 @@ void use(void) {
#if NO_SETJMP
// cxx-error at -2 {{undeclared identifier 'setjmp'}}
// c-error at -3 {{call to undeclared function 'setjmp'; ISO C99 and later do not support implicit function declarations}}
- // cxx-note at -4 {{maybe try to include <csetjmp>; 'setjmp' is defined in <csetjmp>}}
+ // cxx-note at -4 {{defined in}}
#elif ONLY_JMP_BUF
// cxx-error at -6 {{undeclared identifier 'setjmp'}}
// c-error at -7 {{call to undeclared library function 'setjmp' with type 'int (jmp_buf)' (aka 'int (int *)'); ISO C99 and later do not support implicit function declarations}}
// c-note at -8 {{include the header <setjmp.h> or explicitly provide a declaration for 'setjmp'}}
- // cxx-note at -9 {{maybe try to include <csetjmp>; 'setjmp' is defined in <csetjmp>}}
+ // cxx-note at -9 {{defined in}}
#else
// cxx-no-diagnostics
#endif
diff --git a/clang/test/Sema/c23-delayed-typo-correction-crashes.c b/clang/test/Sema/c23-delayed-typo-correction-crashes.c
index 53646fef1cb25..f84b7f30970e3 100644
--- a/clang/test/Sema/c23-delayed-typo-correction-crashes.c
+++ b/clang/test/Sema/c23-delayed-typo-correction-crashes.c
@@ -14,6 +14,6 @@ void GH137867_test() {
_Atomic(struct GH137867) t;
while (!atomic_load(&t.value)->value) // expected-error {{use of undeclared identifier 'atomic_load'}} \
expected-error {{accessing a member of an atomic structure or union is undefined behavior}} \
- expected-note {{maybe try to include <stdatomic.h>; 'atomic_load' is defined in <stdatomic.h>}}
+ expected-note {{'atomic_load' is defined in <stdatomic.h>}}
;
}
diff --git a/clang/test/Sema/implicit-builtin-decl.c b/clang/test/Sema/implicit-builtin-decl.c
index d2997ccdfa2e1..290fe04c8bbe1 100644
--- a/clang/test/Sema/implicit-builtin-decl.c
+++ b/clang/test/Sema/implicit-builtin-decl.c
@@ -25,7 +25,7 @@ void h() {
void f2() {
fprintf(0, "foo"); // expected-warning{{declaration of built-in function 'fprintf' requires inclusion of the header <stdio.h>}} \
expected-error {{call to undeclared function 'fprintf'; ISO C99 and later do not support implicit function declarations}} \
- expected-note {{maybe try to include <stdio.h>; 'fprintf' is defined in <stdio.h>}}
+ expected-note {{'fprintf' is defined in}}
}
// PR2892
diff --git a/clang/test/Sema/include-suggestion.c b/clang/test/Sema/include-suggestion.c
index f47039102840e..1ac4e19e2f9fb 100644
--- a/clang/test/Sema/include-suggestion.c
+++ b/clang/test/Sema/include-suggestion.c
@@ -1,5 +1,5 @@
// RUN: %clang_cc1 -fsyntax-only -verify %s
void test(){
- (void) atoll;// expected-error {{use of undeclared identifier}} expected-note {{maybe try}} expected-note {{'atoll' is a}}
+ (void) atoll;// expected-error {{use of undeclared identifier}} expected-note {{'atoll' is defined in}} expected-note {{'atoll' is a}}
}
diff --git a/clang/test/SemaCXX/constructor-initializer.cpp b/clang/test/SemaCXX/constructor-initializer.cpp
index 59db750f856c6..96be8dda97735 100644
--- a/clang/test/SemaCXX/constructor-initializer.cpp
+++ b/clang/test/SemaCXX/constructor-initializer.cpp
@@ -238,7 +238,7 @@ namespace PR7402 {
// Don't crash. Lots of questionable recovery here; errors can change.
namespace test3 {
- class A : public std::exception {}; // expected-error {{undeclared identifier}} expected-error {{expected class name}} expected-note {{maybe try to include <exception>; 'std::exception' is defined in <exception>}}
+ class A : public std::exception {}; // expected-error {{undeclared identifier}} expected-error {{expected class name}}
// expected-note at -1 {{candidate constructor (the implicit copy constructor) not viable}}
#if __cplusplus >= 201103L // C++11 or later
// expected-note at -3 {{candidate constructor (the implicit move constructor) not viable}}
diff --git a/clang/test/SemaCXX/include-suggestions-cxx.cpp b/clang/test/SemaCXX/include-suggestions-cxx.cpp
index 97f0a9347b2e8..b93fbaebfb94c 100644
--- a/clang/test/SemaCXX/include-suggestions-cxx.cpp
+++ b/clang/test/SemaCXX/include-suggestions-cxx.cpp
@@ -3,2456 +3,1869 @@
namespace std{};
void test(){
- std::FILE; // expected-error {{no member}} expected-note {{maybe try}}
- std::_Exit; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::_Exit' is a}}
- std::accumulate; // expected-error {{no member}} expected-note {{maybe try}}
- std::acosf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::acosf' is a}}
- std::acoshf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::acoshf' is a}}
- std::acoshl; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::acoshl' is a}}
- std::acosl; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::acosl' is a}}
- std::add_const; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::add_const' is a}}
- std::add_const_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::add_const_t' is a}}
- std::add_cv; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::add_cv' is a}}
- std::add_cv_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::add_cv_t' is a}}
- std::add_lvalue_reference; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::add_lvalue_reference' is a}}
- std::add_lvalue_reference_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::add_lvalue_reference_t' is a}}
- std::add_pointer; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::add_pointer' is a}}
- std::add_pointer_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::add_pointer_t' is a}}
- std::add_rvalue_reference; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::add_rvalue_reference' is a}}
- std::add_rvalue_reference_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::add_rvalue_reference_t' is a}}
- std::add_sat; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::add_sat' is a}}
- std::add_volatile; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::add_volatile' is a}}
- std::add_volatile_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::add_volatile_t' is a}}
- std::addressof; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::addressof' is a}}
- std::adjacent_difference; // expected-error {{no member}} expected-note {{maybe try}}
- std::adjacent_find; // expected-error {{no member}} expected-note {{maybe try}}
- std::adopt_lock; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::adopt_lock' is a}}
- std::adopt_lock_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::adopt_lock_t' is a}}
- std::advance; // expected-error {{no member}} expected-note {{maybe try}}
- std::align; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::align' is a}}
- std::align_val_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::align_val_t' is a}}
- std::aligned_alloc; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::aligned_alloc' is a}}
- std::aligned_storage; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::aligned_storage' is a}}
- std::aligned_storage_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::aligned_storage_t' is a}}
- std::aligned_union; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::aligned_union' is a}}
- std::aligned_union_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::aligned_union_t' is a}}
- std::alignment_of; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::alignment_of' is a}}
- std::alignment_of_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::alignment_of_v' is a}}
- std::all_of; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::all_of' is a}}
- std::allocate_shared; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::allocate_shared' is a}}
- std::allocate_shared_for_overwrite; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::allocate_shared_for_overwrite' is a}}
- std::allocation_result; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::allocation_result' is a}}
- std::allocator; // expected-error {{no member}} expected-note {{maybe try}}
- std::allocator_arg; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::allocator_arg' is a}}
- std::allocator_arg_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::allocator_arg_t' is a}}
- std::allocator_traits; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::allocator_traits' is a}}
- std::any; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::any' is a}}
- std::any_cast; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::any_cast' is a}}
- std::any_of; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::any_of' is a}}
- std::apply; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::apply' is a}}
- std::arg; // expected-error {{no member}} expected-note {{maybe try}}
- std::array; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::array' is a}}
- std::as_bytes; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::as_bytes' is a}}
- std::as_const; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::as_const' is a}}
- std::as_writable_bytes; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::as_writable_bytes' is a}}
- std::asctime; // expected-error {{no member}} expected-note {{maybe try}}
- std::asinf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::asinf' is a}}
- std::asinhf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::asinhf' is a}}
- std::asinhl; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::asinhl' is a}}
- std::asinl; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::asinl' is a}}
- std::assignable_from; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::assignable_from' is a}}
- std::assoc_laguerre; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::assoc_laguerre' is a}}
- std::assoc_laguerref; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::assoc_laguerref' is a}}
- std::assoc_laguerrel; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::assoc_laguerrel' is a}}
- std::assoc_legendre; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::assoc_legendre' is a}}
- std::assoc_legendref; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::assoc_legendref' is a}}
- std::assoc_legendrel; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::assoc_legendrel' is a}}
- std::assume_aligned; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::assume_aligned' is a}}
- std::async; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::async' is a}}
- std::at_quick_exit; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::at_quick_exit' is a}}
- std::atan2f; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::atan2f' is a}}
- std::atan2l; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::atan2l' is a}}
- std::atanf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::atanf' is a}}
- std::atanhf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::atanhf' is a}}
- std::atanhl; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::atanhl' is a}}
- std::atanl; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::atanl' is a}}
- std::atexit; // expected-error {{no member}} expected-note {{maybe try}}
- std::atof; // expected-error {{no member}} expected-note {{maybe try}}
- std::atoi; // expected-error {{no member}} expected-note {{maybe try}}
- std::atol; // expected-error {{no member}} expected-note {{maybe try}}
- std::atoll; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::atoll' is a}}
- std::atomic_compare_exchange_strong; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::atomic_compare_exchange_strong' is a}}
- std::atomic_compare_exchange_strong_explicit; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::atomic_compare_exchange_strong_explicit' is a}}
- std::atomic_compare_exchange_weak; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::atomic_compare_exchange_weak' is a}}
- std::atomic_compare_exchange_weak_explicit; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::atomic_compare_exchange_weak_explicit' is a}}
- std::atomic_exchange; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::atomic_exchange' is a}}
- std::atomic_exchange_explicit; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::atomic_exchange_explicit' is a}}
- std::atomic_fetch_add; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::atomic_fetch_add' is a}}
- std::atomic_fetch_add_explicit; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::atomic_fetch_add_explicit' is a}}
- std::atomic_fetch_and; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::atomic_fetch_and' is a}}
- std::atomic_fetch_and_explicit; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::atomic_fetch_and_explicit' is a}}
- std::atomic_fetch_max; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::atomic_fetch_max' is a}}
- std::atomic_fetch_max_explicit; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::atomic_fetch_max_explicit' is a}}
- std::atomic_fetch_min; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::atomic_fetch_min' is a}}
- std::atomic_fetch_min_explicit; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::atomic_fetch_min_explicit' is a}}
- std::atomic_fetch_or; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::atomic_fetch_or' is a}}
- std::atomic_fetch_or_explicit; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::atomic_fetch_or_explicit' is a}}
- std::atomic_fetch_sub; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::atomic_fetch_sub' is a}}
- std::atomic_fetch_sub_explicit; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::atomic_fetch_sub_explicit' is a}}
- std::atomic_fetch_xor; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::atomic_fetch_xor' is a}}
- std::atomic_fetch_xor_explicit; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::atomic_fetch_xor_explicit' is a}}
- std::atomic_flag; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::atomic_flag' is a}}
- std::atomic_flag_clear; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::atomic_flag_clear' is a}}
- std::atomic_flag_clear_explicit; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::atomic_flag_clear_explicit' is a}}
- std::atomic_flag_notify_all; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::atomic_flag_notify_all' is a}}
- std::atomic_flag_notify_one; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::atomic_flag_notify_one' is a}}
- std::atomic_flag_test; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::atomic_flag_test' is a}}
- std::atomic_flag_test_and_set; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::atomic_flag_test_and_set' is a}}
- std::atomic_flag_test_and_set_explicit; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::atomic_flag_test_and_set_explicit' is a}}
- std::atomic_flag_test_explicit; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::atomic_flag_test_explicit' is a}}
- std::atomic_flag_wait; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::atomic_flag_wait' is a}}
- std::atomic_flag_wait_explicit; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::atomic_flag_wait_explicit' is a}}
- std::atomic_init; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::atomic_init' is a}}
- std::atomic_is_lock_free; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::atomic_is_lock_free' is a}}
- std::atomic_load; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::atomic_load' is a}}
- std::atomic_load_explicit; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::atomic_load_explicit' is a}}
- std::atomic_notify_all; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::atomic_notify_all' is a}}
- std::atomic_notify_one; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::atomic_notify_one' is a}}
- std::atomic_ref; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::atomic_ref' is a}}
- std::atomic_signal_fence; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::atomic_signal_fence' is a}}
- std::atomic_store; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::atomic_store' is a}}
- std::atomic_store_explicit; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::atomic_store_explicit' is a}}
- std::atomic_thread_fence; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::atomic_thread_fence' is a}}
- std::atomic_wait; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::atomic_wait' is a}}
- std::atomic_wait_explicit; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::atomic_wait_explicit' is a}}
- std::atto; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::atto' is a}}
- std::auto_ptr; // expected-error {{no member}} expected-note {{maybe try}}
- std::back_insert_iterator; // expected-error {{no member}} expected-note {{maybe try}}
- std::back_inserter; // expected-error {{no member}} expected-note {{maybe try}}
- std::bad_alloc; // expected-error {{no member}} expected-note {{maybe try}}
- std::bad_any_cast; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::bad_any_cast' is a}}
- std::bad_array_new_length; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::bad_array_new_length' is a}}
- std::bad_cast; // expected-error {{no member}} expected-note {{maybe try}}
- std::bad_exception; // expected-error {{no member}} expected-note {{maybe try}}
- std::bad_expected_access; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::bad_expected_access' is a}}
- std::bad_function_call; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::bad_function_call' is a}}
- std::bad_optional_access; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::bad_optional_access' is a}}
- std::bad_typeid; // expected-error {{no member}} expected-note {{maybe try}}
- std::bad_variant_access; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::bad_variant_access' is a}}
- std::bad_weak_ptr; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::bad_weak_ptr' is a}}
- std::barrier; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::barrier' is a}}
- std::basic_common_reference; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::basic_common_reference' is a}}
- std::basic_const_iterator; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::basic_const_iterator' is a}}
- std::basic_filebuf; // expected-error {{no member}} expected-note {{maybe try}}
- std::basic_filebuf; // expected-error {{no member}} expected-note {{maybe try}}
- std::basic_format_arg; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::basic_format_arg' is a}}
- std::basic_format_args; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::basic_format_args' is a}}
- std::basic_format_context; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::basic_format_context' is a}}
- std::basic_format_parse_context; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::basic_format_parse_context' is a}}
- std::basic_format_string; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::basic_format_string' is a}}
- std::basic_fstream; // expected-error {{no member}} expected-note {{maybe try}}
- std::basic_fstream; // expected-error {{no member}} expected-note {{maybe try}}
- std::basic_ifstream; // expected-error {{no member}} expected-note {{maybe try}}
- std::basic_ifstream; // expected-error {{no member}} expected-note {{maybe try}}
- std::basic_ios; // expected-error {{no member}} expected-note {{maybe try}}
- std::basic_ios; // expected-error {{no member}} expected-note {{maybe try}}
- std::basic_ios; // expected-error {{no member}} expected-note {{maybe try}}
- std::basic_iostream; // expected-error {{no member}} expected-note {{maybe try}}
- std::basic_iostream; // expected-error {{no member}} expected-note {{maybe try}}
- std::basic_iostream; // expected-error {{no member}} expected-note {{maybe try}}
- std::basic_ispanstream; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::basic_ispanstream' is a}}
- std::basic_ispanstream; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::basic_ispanstream' is a}}
- std::basic_istream; // expected-error {{no member}} expected-note {{maybe try}}
- std::basic_istream; // expected-error {{no member}} expected-note {{maybe try}}
- std::basic_istream; // expected-error {{no member}} expected-note {{maybe try}}
- std::basic_istringstream; // expected-error {{no member}} expected-note {{maybe try}}
- std::basic_istringstream; // expected-error {{no member}} expected-note {{maybe try}}
- std::basic_ofstream; // expected-error {{no member}} expected-note {{maybe try}}
- std::basic_ofstream; // expected-error {{no member}} expected-note {{maybe try}}
- std::basic_ospanstream; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::basic_ospanstream' is a}}
- std::basic_ospanstream; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::basic_ospanstream' is a}}
- std::basic_ostream; // expected-error {{no member}} expected-note {{maybe try}}
- std::basic_ostream; // expected-error {{no member}} expected-note {{maybe try}}
- std::basic_ostream; // expected-error {{no member}} expected-note {{maybe try}}
- std::basic_ostringstream; // expected-error {{no member}} expected-note {{maybe try}}
- std::basic_ostringstream; // expected-error {{no member}} expected-note {{maybe try}}
- std::basic_osyncstream; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::basic_osyncstream' is a}}
- std::basic_osyncstream; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::basic_osyncstream' is a}}
- std::basic_regex; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::basic_regex' is a}}
- std::basic_spanbuf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::basic_spanbuf' is a}}
- std::basic_spanbuf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::basic_spanbuf' is a}}
- std::basic_spanstream; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::basic_spanstream' is a}}
- std::basic_spanstream; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::basic_spanstream' is a}}
- std::basic_stacktrace; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::basic_stacktrace' is a}}
- std::basic_streambuf; // expected-error {{no member}} expected-note {{maybe try}}
- std::basic_streambuf; // expected-error {{no member}} expected-note {{maybe try}}
- std::basic_streambuf; // expected-error {{no member}} expected-note {{maybe try}}
- std::basic_string; // expected-error {{no member}} expected-note {{maybe try}}
- std::basic_string_view; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::basic_string_view' is a}}
- std::basic_stringbuf; // expected-error {{no member}} expected-note {{maybe try}}
- std::basic_stringbuf; // expected-error {{no member}} expected-note {{maybe try}}
- std::basic_stringstream; // expected-error {{no member}} expected-note {{maybe try}}
- std::basic_stringstream; // expected-error {{no member}} expected-note {{maybe try}}
- std::basic_syncbuf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::basic_syncbuf' is a}}
- std::basic_syncbuf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::basic_syncbuf' is a}}
- std::bernoulli_distribution; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::bernoulli_distribution' is a}}
- std::beta; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::beta' is a}}
- std::betaf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::betaf' is a}}
- std::betal; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::betal' is a}}
- std::bidirectional_iterator; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::bidirectional_iterator' is a}}
- std::bidirectional_iterator_tag; // expected-error {{no member}} expected-note {{maybe try}}
- std::binary_function; // expected-error {{no member}} expected-note {{maybe try}}
- std::binary_negate; // expected-error {{no member}} expected-note {{maybe try}}
- std::binary_search; // expected-error {{no member}} expected-note {{maybe try}}
- std::binary_semaphore; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::binary_semaphore' is a}}
- std::bind; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::bind' is a}}
- std::bind1st; // expected-error {{no member}} expected-note {{maybe try}}
- std::bind2nd; // expected-error {{no member}} expected-note {{maybe try}}
- std::bind_back; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::bind_back' is a}}
- std::bind_front; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::bind_front' is a}}
- std::binder1st; // expected-error {{no member}} expected-note {{maybe try}}
- std::binder2nd; // expected-error {{no member}} expected-note {{maybe try}}
- std::binomial_distribution; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::binomial_distribution' is a}}
- std::bit_and; // expected-error {{no member}} expected-note {{maybe try}}
- std::bit_cast; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::bit_cast' is a}}
- std::bit_ceil; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::bit_ceil' is a}}
- std::bit_floor; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::bit_floor' is a}}
- std::bit_not; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::bit_not' is a}}
- std::bit_or; // expected-error {{no member}} expected-note {{maybe try}}
- std::bit_width; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::bit_width' is a}}
- std::bit_xor; // expected-error {{no member}} expected-note {{maybe try}}
- std::bitset; // expected-error {{no member}} expected-note {{maybe try}}
- std::bool_constant; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::bool_constant' is a}}
- std::boolalpha; // expected-error {{no member}} expected-note {{maybe try}}
- std::boolalpha; // expected-error {{no member}} expected-note {{maybe try}}
- std::boyer_moore_horspool_searcher; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::boyer_moore_horspool_searcher' is a}}
- std::boyer_moore_searcher; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::boyer_moore_searcher' is a}}
- std::breakpoint; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::breakpoint' is a}}
- std::breakpoint_if_debugging; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::breakpoint_if_debugging' is a}}
- std::bsearch; // expected-error {{no member}} expected-note {{maybe try}}
- std::btowc; // expected-error {{no member}} expected-note {{maybe try}}
- std::byte; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::byte' is a}}
- std::byteswap; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::byteswap' is a}}
- std::c16rtomb; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::c16rtomb' is a}}
- std::c32rtomb; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::c32rtomb' is a}}
- std::c8rtomb; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::c8rtomb' is a}}
- std::call_once; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::call_once' is a}}
- std::calloc; // expected-error {{no member}} expected-note {{maybe try}}
- std::cauchy_distribution; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::cauchy_distribution' is a}}
- std::cbrtf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::cbrtf' is a}}
- std::cbrtl; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::cbrtl' is a}}
- std::ceilf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ceilf' is a}}
- std::ceill; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ceill' is a}}
- std::centi; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::centi' is a}}
- std::cerr; // expected-error {{no member}} expected-note {{maybe try}}
- std::char_traits; // expected-error {{no member}} expected-note {{maybe try}}
- std::chars_format; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chars_format' is a}}
- std::chi_squared_distribution; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chi_squared_distribution' is a}}
- std::cin; // expected-error {{no member}} expected-note {{maybe try}}
- std::clamp; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::clamp' is a}}
- std::clearerr; // expected-error {{no member}} expected-note {{maybe try}}
- std::clock; // expected-error {{no member}} expected-note {{maybe try}}
- std::clock_t; // expected-error {{no member}} expected-note {{maybe try}}
- std::clog; // expected-error {{no member}} expected-note {{maybe try}}
- std::cmatch; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::cmatch' is a}}
- std::cmp_equal; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::cmp_equal' is a}}
- std::cmp_greater; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::cmp_greater' is a}}
- std::cmp_greater_equal; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::cmp_greater_equal' is a}}
- std::cmp_less; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::cmp_less' is a}}
- std::cmp_less_equal; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::cmp_less_equal' is a}}
- std::cmp_not_equal; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::cmp_not_equal' is a}}
- std::codecvt; // expected-error {{no member}} expected-note {{maybe try}}
- std::codecvt_base; // expected-error {{no member}} expected-note {{maybe try}}
- std::codecvt_byname; // expected-error {{no member}} expected-note {{maybe try}}
- std::codecvt_mode; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::codecvt_mode' is a}}
- std::codecvt_utf16; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::codecvt_utf16' is a}}
- std::codecvt_utf8; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::codecvt_utf8' is a}}
- std::codecvt_utf8_utf16; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::codecvt_utf8_utf16' is a}}
- std::collate; // expected-error {{no member}} expected-note {{maybe try}}
- std::collate_byname; // expected-error {{no member}} expected-note {{maybe try}}
- std::common_comparison_category; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::common_comparison_category' is a}}
- std::common_comparison_category_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::common_comparison_category_t' is a}}
- std::common_iterator; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::common_iterator' is a}}
- std::common_reference; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::common_reference' is a}}
- std::common_reference_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::common_reference_t' is a}}
- std::common_reference_with; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::common_reference_with' is a}}
- std::common_type; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::common_type' is a}}
- std::common_type_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::common_type_t' is a}}
- std::common_with; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::common_with' is a}}
- std::comp_ellint_1; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::comp_ellint_1' is a}}
- std::comp_ellint_1f; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::comp_ellint_1f' is a}}
- std::comp_ellint_1l; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::comp_ellint_1l' is a}}
- std::comp_ellint_2; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::comp_ellint_2' is a}}
- std::comp_ellint_2f; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::comp_ellint_2f' is a}}
- std::comp_ellint_2l; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::comp_ellint_2l' is a}}
- std::comp_ellint_3; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::comp_ellint_3' is a}}
- std::comp_ellint_3f; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::comp_ellint_3f' is a}}
- std::comp_ellint_3l; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::comp_ellint_3l' is a}}
- std::compare_partial_order_fallback; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::compare_partial_order_fallback' is a}}
- std::compare_strong_order_fallback; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::compare_strong_order_fallback' is a}}
- std::compare_three_way_result; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::compare_three_way_result' is a}}
- std::compare_three_way_result_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::compare_three_way_result_t' is a}}
- std::compare_weak_order_fallback; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::compare_weak_order_fallback' is a}}
- std::complex; // expected-error {{no member}} expected-note {{maybe try}}
- std::condition_variable; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::condition_variable' is a}}
- std::condition_variable_any; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::condition_variable_any' is a}}
- std::conditional; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::conditional' is a}}
- std::conditional_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::conditional_t' is a}}
- std::conj; // expected-error {{no member}} expected-note {{maybe try}}
- std::conjunction; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::conjunction' is a}}
- std::conjunction_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::conjunction_v' is a}}
- std::const_iterator; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::const_iterator' is a}}
- std::const_mem_fun1_ref_t; // expected-error {{no member}} expected-note {{maybe try}}
- std::const_mem_fun1_t; // expected-error {{no member}} expected-note {{maybe try}}
- std::const_mem_fun_ref_t; // expected-error {{no member}} expected-note {{maybe try}}
- std::const_mem_fun_t; // expected-error {{no member}} expected-note {{maybe try}}
- std::const_pointer_cast; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::const_pointer_cast' is a}}
- std::const_sentinel; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::const_sentinel' is a}}
- std::construct_at; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::construct_at' is a}}
- std::constructible_from; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::constructible_from' is a}}
- std::contiguous_iterator; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::contiguous_iterator' is a}}
- std::contiguous_iterator_tag; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::contiguous_iterator_tag' is a}}
- std::convertible_to; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::convertible_to' is a}}
- std::copy; // expected-error {{no member}} expected-note {{maybe try}}
- std::copy_backward; // expected-error {{no member}} expected-note {{maybe try}}
- std::copy_constructible; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::copy_constructible' is a}}
- std::copy_if; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::copy_if' is a}}
- std::copy_n; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::copy_n' is a}}
- std::copyable; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::copyable' is a}}
- std::copyable_function; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::copyable_function' is a}}
- std::copysignf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::copysignf' is a}}
- std::copysignl; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::copysignl' is a}}
- std::coroutine_handle; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::coroutine_handle' is a}}
- std::coroutine_traits; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::coroutine_traits' is a}}
- std::cosf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::cosf' is a}}
- std::coshf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::coshf' is a}}
- std::coshl; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::coshl' is a}}
- std::cosl; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::cosl' is a}}
- std::count; // expected-error {{no member}} expected-note {{maybe try}}
- std::count_if; // expected-error {{no member}} expected-note {{maybe try}}
- std::counted_iterator; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::counted_iterator' is a}}
- std::counting_semaphore; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::counting_semaphore' is a}}
- std::countl_one; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::countl_one' is a}}
- std::countl_zero; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::countl_zero' is a}}
- std::countr_one; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::countr_one' is a}}
- std::countr_zero; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::countr_zero' is a}}
- std::cout; // expected-error {{no member}} expected-note {{maybe try}}
- std::cref; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::cref' is a}}
- std::cregex_iterator; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::cregex_iterator' is a}}
- std::cregex_token_iterator; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::cregex_token_iterator' is a}}
- std::csub_match; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::csub_match' is a}}
- std::ctime; // expected-error {{no member}} expected-note {{maybe try}}
- std::ctype; // expected-error {{no member}} expected-note {{maybe try}}
- std::ctype_base; // expected-error {{no member}} expected-note {{maybe try}}
- std::ctype_byname; // expected-error {{no member}} expected-note {{maybe try}}
- std::current_exception; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::current_exception' is a}}
- std::cv_status; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::cv_status' is a}}
- std::cyl_bessel_i; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::cyl_bessel_i' is a}}
- std::cyl_bessel_if; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::cyl_bessel_if' is a}}
- std::cyl_bessel_il; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::cyl_bessel_il' is a}}
- std::cyl_bessel_j; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::cyl_bessel_j' is a}}
- std::cyl_bessel_jf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::cyl_bessel_jf' is a}}
- std::cyl_bessel_jl; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::cyl_bessel_jl' is a}}
- std::cyl_bessel_k; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::cyl_bessel_k' is a}}
- std::cyl_bessel_kf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::cyl_bessel_kf' is a}}
- std::cyl_bessel_kl; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::cyl_bessel_kl' is a}}
- std::cyl_neumann; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::cyl_neumann' is a}}
- std::cyl_neumannf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::cyl_neumannf' is a}}
- std::cyl_neumannl; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::cyl_neumannl' is a}}
- std::dec; // expected-error {{no member}} expected-note {{maybe try}}
- std::dec; // expected-error {{no member}} expected-note {{maybe try}}
- std::deca; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::deca' is a}}
- std::decay; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::decay' is a}}
- std::decay_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::decay_t' is a}}
- std::deci; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::deci' is a}}
- std::declare_no_pointers; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::declare_no_pointers' is a}}
- std::declare_reachable; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::declare_reachable' is a}}
- std::declval; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::declval' is a}}
- std::default_accessor; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::default_accessor' is a}}
- std::default_delete; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::default_delete' is a}}
- std::default_initializable; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::default_initializable' is a}}
- std::default_random_engine; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::default_random_engine' is a}}
- std::default_searcher; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::default_searcher' is a}}
- std::default_sentinel; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::default_sentinel' is a}}
- std::default_sentinel_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::default_sentinel_t' is a}}
- std::defaultfloat; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::defaultfloat' is a}}
- std::defaultfloat; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::defaultfloat' is a}}
- std::defer_lock; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::defer_lock' is a}}
- std::defer_lock_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::defer_lock_t' is a}}
- std::denorm_absent; // expected-error {{no member}} expected-note {{maybe try}}
- std::denorm_indeterminate; // expected-error {{no member}} expected-note {{maybe try}}
- std::denorm_present; // expected-error {{no member}} expected-note {{maybe try}}
- std::deque; // expected-error {{no member}} expected-note {{maybe try}}
- std::derived_from; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::derived_from' is a}}
- std::destroy; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::destroy' is a}}
- std::destroy_at; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::destroy_at' is a}}
- std::destroy_n; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::destroy_n' is a}}
- std::destroying_delete; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::destroying_delete' is a}}
- std::destroying_delete_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::destroying_delete_t' is a}}
- std::destructible; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::destructible' is a}}
- std::dextents; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::dextents' is a}}
- std::difftime; // expected-error {{no member}} expected-note {{maybe try}}
- std::dims; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::dims' is a}}
- std::disable_sized_sentinel_for; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::disable_sized_sentinel_for' is a}}
- std::discard_block_engine; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::discard_block_engine' is a}}
- std::discrete_distribution; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::discrete_distribution' is a}}
- std::disjunction; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::disjunction' is a}}
- std::disjunction_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::disjunction_v' is a}}
- std::distance; // expected-error {{no member}} expected-note {{maybe try}}
- std::div_sat; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::div_sat' is a}}
- std::div_t; // expected-error {{no member}} expected-note {{maybe try}}
- std::divides; // expected-error {{no member}} expected-note {{maybe try}}
- std::domain_error; // expected-error {{no member}} expected-note {{maybe try}}
- std::double_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::double_t' is a}}
- std::dynamic_extent; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::dynamic_extent' is a}}
- std::dynamic_pointer_cast; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::dynamic_pointer_cast' is a}}
- std::ellint_1; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ellint_1' is a}}
- std::ellint_1f; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ellint_1f' is a}}
- std::ellint_1l; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ellint_1l' is a}}
- std::ellint_2; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ellint_2' is a}}
- std::ellint_2f; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ellint_2f' is a}}
- std::ellint_2l; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ellint_2l' is a}}
- std::ellint_3; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ellint_3' is a}}
- std::ellint_3f; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ellint_3f' is a}}
- std::ellint_3l; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ellint_3l' is a}}
- std::emit_on_flush; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::emit_on_flush' is a}}
- std::emit_on_flush; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::emit_on_flush' is a}}
- std::enable_if; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::enable_if' is a}}
- std::enable_if_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::enable_if_t' is a}}
- std::enable_nonlocking_formatter_optimization; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::enable_nonlocking_formatter_optimization' is a}}
- std::enable_shared_from_this; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::enable_shared_from_this' is a}}
- std::endian; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::endian' is a}}
- std::endl; // expected-error {{no member}} expected-note {{maybe try}}
- std::endl; // expected-error {{no member}} expected-note {{maybe try}}
- std::ends; // expected-error {{no member}} expected-note {{maybe try}}
- std::ends; // expected-error {{no member}} expected-note {{maybe try}}
- std::equal; // expected-error {{no member}} expected-note {{maybe try}}
- std::equal_range; // expected-error {{no member}} expected-note {{maybe try}}
- std::equal_to; // expected-error {{no member}} expected-note {{maybe try}}
- std::equality_comparable; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::equality_comparable' is a}}
- std::equality_comparable_with; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::equality_comparable_with' is a}}
- std::equivalence_relation; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::equivalence_relation' is a}}
- std::erfcf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::erfcf' is a}}
- std::erfcl; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::erfcl' is a}}
- std::erff; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::erff' is a}}
- std::erfl; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::erfl' is a}}
- std::errc; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::errc' is a}}
- std::error_category; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::error_category' is a}}
- std::error_code; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::error_code' is a}}
- std::error_condition; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::error_condition' is a}}
- std::exa; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::exa' is a}}
- std::exception; // expected-error {{no member}} expected-note {{maybe try}}
- std::exception_ptr; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::exception_ptr' is a}}
- std::exchange; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::exchange' is a}}
- std::exclusive_scan; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::exclusive_scan' is a}}
- std::exit; // expected-error {{no member}} expected-note {{maybe try}}
- std::exp2f; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::exp2f' is a}}
- std::exp2l; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::exp2l' is a}}
- std::expected; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::expected' is a}}
- std::expf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::expf' is a}}
- std::expint; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::expint' is a}}
- std::expintf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::expintf' is a}}
- std::expintl; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::expintl' is a}}
- std::expl; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::expl' is a}}
- std::expm1f; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::expm1f' is a}}
- std::expm1l; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::expm1l' is a}}
- std::exponential_distribution; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::exponential_distribution' is a}}
- std::extent; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::extent' is a}}
- std::extent_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::extent_v' is a}}
- std::extents; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::extents' is a}}
- std::extreme_value_distribution; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::extreme_value_distribution' is a}}
- std::fabs; // expected-error {{no member}} expected-note {{maybe try}}
- std::fabsf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::fabsf' is a}}
- std::fabsl; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::fabsl' is a}}
- std::false_type; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::false_type' is a}}
- std::fclose; // expected-error {{no member}} expected-note {{maybe try}}
- std::fdimf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::fdimf' is a}}
- std::fdiml; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::fdiml' is a}}
- std::feclearexcept; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::feclearexcept' is a}}
- std::fegetenv; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::fegetenv' is a}}
- std::fegetexceptflag; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::fegetexceptflag' is a}}
- std::fegetround; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::fegetround' is a}}
- std::feholdexcept; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::feholdexcept' is a}}
- std::femto; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::femto' is a}}
- std::fenv_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::fenv_t' is a}}
- std::feof; // expected-error {{no member}} expected-note {{maybe try}}
- std::feraiseexcept; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::feraiseexcept' is a}}
- std::ferror; // expected-error {{no member}} expected-note {{maybe try}}
- std::fesetenv; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::fesetenv' is a}}
- std::fesetexceptflag; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::fesetexceptflag' is a}}
- std::fesetround; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::fesetround' is a}}
- std::fetestexcept; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::fetestexcept' is a}}
- std::feupdateenv; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::feupdateenv' is a}}
- std::fexcept_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::fexcept_t' is a}}
- std::fflush; // expected-error {{no member}} expected-note {{maybe try}}
- std::fgetc; // expected-error {{no member}} expected-note {{maybe try}}
- std::fgetpos; // expected-error {{no member}} expected-note {{maybe try}}
- std::fgets; // expected-error {{no member}} expected-note {{maybe try}}
- std::fgetwc; // expected-error {{no member}} expected-note {{maybe try}}
- std::fgetws; // expected-error {{no member}} expected-note {{maybe try}}
- std::filebuf; // expected-error {{no member}} expected-note {{maybe try}}
- std::filebuf; // expected-error {{no member}} expected-note {{maybe try}}
- std::fill; // expected-error {{no member}} expected-note {{maybe try}}
- std::fill_n; // expected-error {{no member}} expected-note {{maybe try}}
- std::find; // expected-error {{no member}} expected-note {{maybe try}}
- std::find_end; // expected-error {{no member}} expected-note {{maybe try}}
- std::find_first_of; // expected-error {{no member}} expected-note {{maybe try}}
- std::find_if; // expected-error {{no member}} expected-note {{maybe try}}
- std::find_if_not; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::find_if_not' is a}}
- std::fisher_f_distribution; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::fisher_f_distribution' is a}}
- std::fixed; // expected-error {{no member}} expected-note {{maybe try}}
- std::fixed; // expected-error {{no member}} expected-note {{maybe try}}
- std::flat_map; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::flat_map' is a}}
- std::flat_multimap; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::flat_multimap' is a}}
- std::flat_multiset; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::flat_multiset' is a}}
- std::flat_set; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::flat_set' is a}}
- std::float_denorm_style; // expected-error {{no member}} expected-note {{maybe try}}
- std::float_round_style; // expected-error {{no member}} expected-note {{maybe try}}
- std::float_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::float_t' is a}}
- std::floating_point; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::floating_point' is a}}
- std::floorf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::floorf' is a}}
- std::floorl; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::floorl' is a}}
- std::flush; // expected-error {{no member}} expected-note {{maybe try}}
- std::flush; // expected-error {{no member}} expected-note {{maybe try}}
- std::flush_emit; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::flush_emit' is a}}
- std::flush_emit; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::flush_emit' is a}}
- std::fma; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::fma' is a}}
- std::fmaf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::fmaf' is a}}
- std::fmal; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::fmal' is a}}
- std::fmaxf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::fmaxf' is a}}
- std::fmaxl; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::fmaxl' is a}}
- std::fminf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::fminf' is a}}
- std::fminl; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::fminl' is a}}
- std::fmodf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::fmodf' is a}}
- std::fmodl; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::fmodl' is a}}
- std::fopen; // expected-error {{no member}} expected-note {{maybe try}}
- std::for_each; // expected-error {{no member}} expected-note {{maybe try}}
- std::for_each_n; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::for_each_n' is a}}
- std::format; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::format' is a}}
- std::format_args; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::format_args' is a}}
- std::format_context; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::format_context' is a}}
- std::format_error; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::format_error' is a}}
- std::format_kind; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::format_kind' is a}}
- std::format_parse_context; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::format_parse_context' is a}}
- std::format_string; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::format_string' is a}}
- std::format_to; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::format_to' is a}}
- std::format_to_n; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::format_to_n' is a}}
- std::format_to_n_result; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::format_to_n_result' is a}}
- std::formattable; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::formattable' is a}}
- std::formatted_size; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::formatted_size' is a}}
- std::formatter; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::formatter' is a}}
- std::forward; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::forward' is a}}
- std::forward_as_tuple; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::forward_as_tuple' is a}}
- std::forward_iterator; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::forward_iterator' is a}}
- std::forward_iterator_tag; // expected-error {{no member}} expected-note {{maybe try}}
- std::forward_like; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::forward_like' is a}}
- std::forward_list; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::forward_list' is a}}
- std::fpclassify; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::fpclassify' is a}}
- std::fpos; // expected-error {{no member}} expected-note {{maybe try}}
- std::fpos; // expected-error {{no member}} expected-note {{maybe try}}
- std::fpos; // expected-error {{no member}} expected-note {{maybe try}}
- std::fpos_t; // expected-error {{no member}} expected-note {{maybe try}}
- std::fprintf; // expected-error {{no member}} expected-note {{maybe try}}
- std::fputc; // expected-error {{no member}} expected-note {{maybe try}}
- std::fputs; // expected-error {{no member}} expected-note {{maybe try}}
- std::fputwc; // expected-error {{no member}} expected-note {{maybe try}}
- std::fputws; // expected-error {{no member}} expected-note {{maybe try}}
- std::fread; // expected-error {{no member}} expected-note {{maybe try}}
- std::free; // expected-error {{no member}} expected-note {{maybe try}}
- std::freopen; // expected-error {{no member}} expected-note {{maybe try}}
- std::frexp; // expected-error {{no member}} expected-note {{maybe try}}
- std::frexpf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::frexpf' is a}}
- std::frexpl; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::frexpl' is a}}
- std::from_chars; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::from_chars' is a}}
- std::from_chars_result; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::from_chars_result' is a}}
- std::from_range; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::from_range' is a}}
- std::from_range_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::from_range_t' is a}}
- std::front_insert_iterator; // expected-error {{no member}} expected-note {{maybe try}}
- std::front_inserter; // expected-error {{no member}} expected-note {{maybe try}}
- std::fscanf; // expected-error {{no member}} expected-note {{maybe try}}
- std::fseek; // expected-error {{no member}} expected-note {{maybe try}}
- std::fsetpos; // expected-error {{no member}} expected-note {{maybe try}}
- std::fstream; // expected-error {{no member}} expected-note {{maybe try}}
- std::fstream; // expected-error {{no member}} expected-note {{maybe try}}
- std::ftell; // expected-error {{no member}} expected-note {{maybe try}}
- std::function; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::function' is a}}
- std::function_ref; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::function_ref' is a}}
- std::future; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::future' is a}}
- std::future_category; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::future_category' is a}}
- std::future_errc; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::future_errc' is a}}
- std::future_error; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::future_error' is a}}
- std::future_status; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::future_status' is a}}
- std::fwide; // expected-error {{no member}} expected-note {{maybe try}}
- std::fwprintf; // expected-error {{no member}} expected-note {{maybe try}}
- std::fwrite; // expected-error {{no member}} expected-note {{maybe try}}
- std::fwscanf; // expected-error {{no member}} expected-note {{maybe try}}
- std::gamma_distribution; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::gamma_distribution' is a}}
- std::gcd; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::gcd' is a}}
- std::generate; // expected-error {{no member}} expected-note {{maybe try}}
- std::generate_canonical; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::generate_canonical' is a}}
- std::generate_n; // expected-error {{no member}} expected-note {{maybe try}}
- std::generator; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::generator' is a}}
- std::generic_category; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::generic_category' is a}}
- std::geometric_distribution; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::geometric_distribution' is a}}
- std::get_deleter; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::get_deleter' is a}}
- std::get_if; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::get_if' is a}}
- std::get_money; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::get_money' is a}}
- std::get_new_handler; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::get_new_handler' is a}}
- std::get_pointer_safety; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::get_pointer_safety' is a}}
- std::get_temporary_buffer; // expected-error {{no member}} expected-note {{maybe try}}
- std::get_terminate; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::get_terminate' is a}}
- std::get_time; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::get_time' is a}}
- std::get_unexpected; // expected-error {{no member}} expected-note {{maybe try}}
- std::getc; // expected-error {{no member}} expected-note {{maybe try}}
- std::getchar; // expected-error {{no member}} expected-note {{maybe try}}
- std::getenv; // expected-error {{no member}} expected-note {{maybe try}}
- std::getline; // expected-error {{no member}} expected-note {{maybe try}}
- std::gets; // expected-error {{no member}} expected-note {{maybe try}}
- std::getwc; // expected-error {{no member}} expected-note {{maybe try}}
- std::getwchar; // expected-error {{no member}} expected-note {{maybe try}}
- std::giga; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::giga' is a}}
- std::gmtime; // expected-error {{no member}} expected-note {{maybe try}}
- std::greater; // expected-error {{no member}} expected-note {{maybe try}}
- std::greater_equal; // expected-error {{no member}} expected-note {{maybe try}}
- std::gslice; // expected-error {{no member}} expected-note {{maybe try}}
- std::gslice_array; // expected-error {{no member}} expected-note {{maybe try}}
- std::hardware_constructive_interference_size; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::hardware_constructive_interference_size' is a}}
- std::hardware_destructive_interference_size; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::hardware_destructive_interference_size' is a}}
- std::has_facet; // expected-error {{no member}} expected-note {{maybe try}}
- std::has_single_bit; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::has_single_bit' is a}}
- std::has_unique_object_representations; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::has_unique_object_representations' is a}}
- std::has_unique_object_representations_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::has_unique_object_representations_v' is a}}
- std::has_virtual_destructor; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::has_virtual_destructor' is a}}
- std::has_virtual_destructor_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::has_virtual_destructor_v' is a}}
- std::hecto; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::hecto' is a}}
- std::hermite; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::hermite' is a}}
- std::hermitef; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::hermitef' is a}}
- std::hermitel; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::hermitel' is a}}
- std::hex; // expected-error {{no member}} expected-note {{maybe try}}
- std::hex; // expected-error {{no member}} expected-note {{maybe try}}
- std::hexfloat; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::hexfloat' is a}}
- std::hexfloat; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::hexfloat' is a}}
- std::holds_alternative; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::holds_alternative' is a}}
- std::hypot; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::hypot' is a}}
- std::hypotf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::hypotf' is a}}
- std::hypotl; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::hypotl' is a}}
- std::identity; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::identity' is a}}
- std::ifstream; // expected-error {{no member}} expected-note {{maybe try}}
- std::ifstream; // expected-error {{no member}} expected-note {{maybe try}}
- std::ilogb; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ilogb' is a}}
- std::ilogbf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ilogbf' is a}}
- std::ilogbl; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ilogbl' is a}}
- std::imag; // expected-error {{no member}} expected-note {{maybe try}}
- std::imaxabs; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::imaxabs' is a}}
- std::imaxdiv; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::imaxdiv' is a}}
- std::imaxdiv_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::imaxdiv_t' is a}}
- std::in_place; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::in_place' is a}}
- std::in_place_index; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::in_place_index' is a}}
- std::in_place_index_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::in_place_index_t' is a}}
- std::in_place_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::in_place_t' is a}}
- std::in_place_type; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::in_place_type' is a}}
- std::in_place_type_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::in_place_type_t' is a}}
- std::in_range; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::in_range' is a}}
- std::includes; // expected-error {{no member}} expected-note {{maybe try}}
- std::inclusive_scan; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::inclusive_scan' is a}}
- std::incrementable; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::incrementable' is a}}
- std::incrementable_traits; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::incrementable_traits' is a}}
- std::independent_bits_engine; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::independent_bits_engine' is a}}
- std::index_sequence; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::index_sequence' is a}}
- std::index_sequence_for; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::index_sequence_for' is a}}
- std::indirect_array; // expected-error {{no member}} expected-note {{maybe try}}
- std::indirect_binary_predicate; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::indirect_binary_predicate' is a}}
- std::indirect_equivalence_relation; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::indirect_equivalence_relation' is a}}
- std::indirect_result_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::indirect_result_t' is a}}
- std::indirect_strict_weak_order; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::indirect_strict_weak_order' is a}}
- std::indirect_unary_predicate; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::indirect_unary_predicate' is a}}
- std::indirectly_comparable; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::indirectly_comparable' is a}}
- std::indirectly_copyable; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::indirectly_copyable' is a}}
- std::indirectly_copyable_storable; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::indirectly_copyable_storable' is a}}
- std::indirectly_movable; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::indirectly_movable' is a}}
- std::indirectly_movable_storable; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::indirectly_movable_storable' is a}}
- std::indirectly_readable; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::indirectly_readable' is a}}
- std::indirectly_readable_traits; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::indirectly_readable_traits' is a}}
- std::indirectly_regular_unary_invocable; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::indirectly_regular_unary_invocable' is a}}
- std::indirectly_swappable; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::indirectly_swappable' is a}}
- std::indirectly_unary_invocable; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::indirectly_unary_invocable' is a}}
- std::indirectly_writable; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::indirectly_writable' is a}}
- std::initializer_list; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::initializer_list' is a}}
- std::inner_product; // expected-error {{no member}} expected-note {{maybe try}}
- std::inout_ptr; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::inout_ptr' is a}}
- std::inout_ptr_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::inout_ptr_t' is a}}
- std::inplace_merge; // expected-error {{no member}} expected-note {{maybe try}}
- std::inplace_vector; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::inplace_vector' is a}}
- std::input_iterator; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::input_iterator' is a}}
- std::input_iterator_tag; // expected-error {{no member}} expected-note {{maybe try}}
- std::input_or_output_iterator; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::input_or_output_iterator' is a}}
- std::insert_iterator; // expected-error {{no member}} expected-note {{maybe try}}
- std::inserter; // expected-error {{no member}} expected-note {{maybe try}}
- std::int16_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::int16_t' is a}}
- std::int32_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::int32_t' is a}}
- std::int64_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::int64_t' is a}}
- std::int8_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::int8_t' is a}}
- std::int_fast16_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::int_fast16_t' is a}}
- std::int_fast32_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::int_fast32_t' is a}}
- std::int_fast64_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::int_fast64_t' is a}}
- std::int_fast8_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::int_fast8_t' is a}}
- std::int_least16_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::int_least16_t' is a}}
- std::int_least32_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::int_least32_t' is a}}
- std::int_least64_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::int_least64_t' is a}}
- std::int_least8_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::int_least8_t' is a}}
- std::integer_sequence; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::integer_sequence' is a}}
- std::integral; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::integral' is a}}
- std::integral_constant; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::integral_constant' is a}}
- std::internal; // expected-error {{no member}} expected-note {{maybe try}}
- std::internal; // expected-error {{no member}} expected-note {{maybe try}}
- std::intmax_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::intmax_t' is a}}
- std::intptr_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::intptr_t' is a}}
- std::invalid_argument; // expected-error {{no member}} expected-note {{maybe try}}
- std::invocable; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::invocable' is a}}
- std::invoke; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::invoke' is a}}
- std::invoke_r; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::invoke_r' is a}}
- std::invoke_result; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::invoke_result' is a}}
- std::invoke_result_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::invoke_result_t' is a}}
- std::io_errc; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::io_errc' is a}}
- std::io_errc; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::io_errc' is a}}
- std::io_state; // expected-error {{no member}} expected-note {{maybe try}}
- std::io_state; // expected-error {{no member}} expected-note {{maybe try}}
- std::ios; // expected-error {{no member}} expected-note {{maybe try}}
- std::ios; // expected-error {{no member}} expected-note {{maybe try}}
- std::ios; // expected-error {{no member}} expected-note {{maybe try}}
- std::ios_base; // expected-error {{no member}} expected-note {{maybe try}}
- std::ios_base; // expected-error {{no member}} expected-note {{maybe try}}
- std::iostream; // expected-error {{no member}} expected-note {{maybe try}}
- std::iostream; // expected-error {{no member}} expected-note {{maybe try}}
- std::iostream; // expected-error {{no member}} expected-note {{maybe try}}
- std::iostream_category; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::iostream_category' is a}}
- std::iostream_category; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::iostream_category' is a}}
- std::iota; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::iota' is a}}
- std::is_abstract; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_abstract' is a}}
- std::is_abstract_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_abstract_v' is a}}
- std::is_aggregate; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_aggregate' is a}}
- std::is_aggregate_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_aggregate_v' is a}}
- std::is_arithmetic; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_arithmetic' is a}}
- std::is_arithmetic_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_arithmetic_v' is a}}
- std::is_array; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_array' is a}}
- std::is_array_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_array_v' is a}}
- std::is_assignable; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_assignable' is a}}
- std::is_assignable_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_assignable_v' is a}}
- std::is_base_of; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_base_of' is a}}
- std::is_base_of_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_base_of_v' is a}}
- std::is_bind_expression; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_bind_expression' is a}}
- std::is_bind_expression_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_bind_expression_v' is a}}
- std::is_bounded_array; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_bounded_array' is a}}
- std::is_bounded_array_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_bounded_array_v' is a}}
- std::is_class; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_class' is a}}
- std::is_class_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_class_v' is a}}
- std::is_compound; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_compound' is a}}
- std::is_compound_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_compound_v' is a}}
- std::is_const; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_const' is a}}
- std::is_const_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_const_v' is a}}
- std::is_constant_evaluated; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_constant_evaluated' is a}}
- std::is_constructible; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_constructible' is a}}
- std::is_constructible_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_constructible_v' is a}}
- std::is_convertible; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_convertible' is a}}
- std::is_convertible_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_convertible_v' is a}}
- std::is_copy_assignable; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_copy_assignable' is a}}
- std::is_copy_assignable_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_copy_assignable_v' is a}}
- std::is_copy_constructible; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_copy_constructible' is a}}
- std::is_copy_constructible_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_copy_constructible_v' is a}}
- std::is_corresponding_member; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_corresponding_member' is a}}
- std::is_debugger_present; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_debugger_present' is a}}
- std::is_default_constructible; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_default_constructible' is a}}
- std::is_default_constructible_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_default_constructible_v' is a}}
- std::is_destructible; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_destructible' is a}}
- std::is_destructible_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_destructible_v' is a}}
- std::is_empty; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_empty' is a}}
- std::is_empty_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_empty_v' is a}}
- std::is_enum; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_enum' is a}}
- std::is_enum_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_enum_v' is a}}
- std::is_eq; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_eq' is a}}
- std::is_error_code_enum; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_error_code_enum' is a}}
- std::is_error_condition_enum; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_error_condition_enum' is a}}
- std::is_error_condition_enum_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_error_condition_enum_v' is a}}
- std::is_execution_policy; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_execution_policy' is a}}
- std::is_execution_policy_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_execution_policy_v' is a}}
- std::is_final; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_final' is a}}
- std::is_final_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_final_v' is a}}
- std::is_floating_point; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_floating_point' is a}}
- std::is_floating_point_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_floating_point_v' is a}}
- std::is_function; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_function' is a}}
- std::is_function_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_function_v' is a}}
- std::is_fundamental; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_fundamental' is a}}
- std::is_fundamental_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_fundamental_v' is a}}
- std::is_gt; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_gt' is a}}
- std::is_gteq; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_gteq' is a}}
- std::is_heap; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_heap' is a}}
- std::is_heap_until; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_heap_until' is a}}
- std::is_implicit_lifetime; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_implicit_lifetime' is a}}
- std::is_integral; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_integral' is a}}
- std::is_integral_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_integral_v' is a}}
- std::is_invocable; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_invocable' is a}}
- std::is_invocable_r; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_invocable_r' is a}}
- std::is_invocable_r_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_invocable_r_v' is a}}
- std::is_invocable_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_invocable_v' is a}}
- std::is_layout_compatible; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_layout_compatible' is a}}
- std::is_layout_compatible_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_layout_compatible_v' is a}}
- std::is_literal_type; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_literal_type' is a}}
- std::is_literal_type_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_literal_type_v' is a}}
- std::is_lt; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_lt' is a}}
- std::is_lteq; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_lteq' is a}}
- std::is_lvalue_reference; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_lvalue_reference' is a}}
- std::is_lvalue_reference_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_lvalue_reference_v' is a}}
- std::is_member_function_pointer; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_member_function_pointer' is a}}
- std::is_member_function_pointer_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_member_function_pointer_v' is a}}
- std::is_member_object_pointer; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_member_object_pointer' is a}}
- std::is_member_object_pointer_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_member_object_pointer_v' is a}}
- std::is_member_pointer; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_member_pointer' is a}}
- std::is_member_pointer_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_member_pointer_v' is a}}
- std::is_move_assignable; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_move_assignable' is a}}
- std::is_move_assignable_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_move_assignable_v' is a}}
- std::is_move_constructible; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_move_constructible' is a}}
- std::is_move_constructible_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_move_constructible_v' is a}}
- std::is_neq; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_neq' is a}}
- std::is_nothrow_assignable; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_nothrow_assignable' is a}}
- std::is_nothrow_assignable_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_nothrow_assignable_v' is a}}
- std::is_nothrow_constructible; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_nothrow_constructible' is a}}
- std::is_nothrow_constructible_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_nothrow_constructible_v' is a}}
- std::is_nothrow_convertible; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_nothrow_convertible' is a}}
- std::is_nothrow_convertible_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_nothrow_convertible_v' is a}}
- std::is_nothrow_copy_assignable; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_nothrow_copy_assignable' is a}}
- std::is_nothrow_copy_assignable_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_nothrow_copy_assignable_v' is a}}
- std::is_nothrow_copy_constructible; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_nothrow_copy_constructible' is a}}
- std::is_nothrow_copy_constructible_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_nothrow_copy_constructible_v' is a}}
- std::is_nothrow_default_constructible; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_nothrow_default_constructible' is a}}
- std::is_nothrow_default_constructible_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_nothrow_default_constructible_v' is a}}
- std::is_nothrow_destructible; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_nothrow_destructible' is a}}
- std::is_nothrow_destructible_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_nothrow_destructible_v' is a}}
- std::is_nothrow_invocable; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_nothrow_invocable' is a}}
- std::is_nothrow_invocable_r; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_nothrow_invocable_r' is a}}
- std::is_nothrow_invocable_r_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_nothrow_invocable_r_v' is a}}
- std::is_nothrow_invocable_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_nothrow_invocable_v' is a}}
- std::is_nothrow_move_assignable; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_nothrow_move_assignable' is a}}
- std::is_nothrow_move_assignable_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_nothrow_move_assignable_v' is a}}
- std::is_nothrow_move_constructible; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_nothrow_move_constructible' is a}}
- std::is_nothrow_move_constructible_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_nothrow_move_constructible_v' is a}}
- std::is_nothrow_swappable; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_nothrow_swappable' is a}}
- std::is_nothrow_swappable_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_nothrow_swappable_v' is a}}
- std::is_nothrow_swappable_with; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_nothrow_swappable_with' is a}}
- std::is_nothrow_swappable_with_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_nothrow_swappable_with_v' is a}}
- std::is_null_pointer; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_null_pointer' is a}}
- std::is_null_pointer_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_null_pointer_v' is a}}
- std::is_object; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_object' is a}}
- std::is_object_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_object_v' is a}}
- std::is_partitioned; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_partitioned' is a}}
- std::is_permutation; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_permutation' is a}}
- std::is_placeholder; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_placeholder' is a}}
- std::is_placeholder_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_placeholder_v' is a}}
- std::is_pod; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_pod' is a}}
- std::is_pod_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_pod_v' is a}}
- std::is_pointer; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_pointer' is a}}
- std::is_pointer_interconvertible_base_of; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_pointer_interconvertible_base_of' is a}}
- std::is_pointer_interconvertible_base_of_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_pointer_interconvertible_base_of_v' is a}}
- std::is_pointer_interconvertible_with_class; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_pointer_interconvertible_with_class' is a}}
- std::is_pointer_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_pointer_v' is a}}
- std::is_polymorphic; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_polymorphic' is a}}
- std::is_polymorphic_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_polymorphic_v' is a}}
- std::is_reference; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_reference' is a}}
- std::is_reference_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_reference_v' is a}}
- std::is_rvalue_reference; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_rvalue_reference' is a}}
- std::is_rvalue_reference_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_rvalue_reference_v' is a}}
- std::is_same; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_same' is a}}
- std::is_same_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_same_v' is a}}
- std::is_scalar; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_scalar' is a}}
- std::is_scalar_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_scalar_v' is a}}
- std::is_scoped_enum; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_scoped_enum' is a}}
- std::is_scoped_enum_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_scoped_enum_v' is a}}
- std::is_signed; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_signed' is a}}
- std::is_signed_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_signed_v' is a}}
- std::is_sorted; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_sorted' is a}}
- std::is_sorted_until; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_sorted_until' is a}}
- std::is_standard_layout; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_standard_layout' is a}}
- std::is_standard_layout_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_standard_layout_v' is a}}
- std::is_swappable; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_swappable' is a}}
- std::is_swappable_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_swappable_v' is a}}
- std::is_swappable_with; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_swappable_with' is a}}
- std::is_swappable_with_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_swappable_with_v' is a}}
- std::is_trivial; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_trivial' is a}}
- std::is_trivial_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_trivial_v' is a}}
- std::is_trivially_assignable; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_trivially_assignable' is a}}
- std::is_trivially_assignable_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_trivially_assignable_v' is a}}
- std::is_trivially_constructible; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_trivially_constructible' is a}}
- std::is_trivially_constructible_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_trivially_constructible_v' is a}}
- std::is_trivially_copy_assignable; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_trivially_copy_assignable' is a}}
- std::is_trivially_copy_assignable_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_trivially_copy_assignable_v' is a}}
- std::is_trivially_copy_constructible; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_trivially_copy_constructible' is a}}
- std::is_trivially_copy_constructible_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_trivially_copy_constructible_v' is a}}
- std::is_trivially_copyable; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_trivially_copyable' is a}}
- std::is_trivially_copyable_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_trivially_copyable_v' is a}}
- std::is_trivially_default_constructible; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_trivially_default_constructible' is a}}
- std::is_trivially_default_constructible_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_trivially_default_constructible_v' is a}}
- std::is_trivially_destructible; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_trivially_destructible' is a}}
- std::is_trivially_destructible_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_trivially_destructible_v' is a}}
- std::is_trivially_move_assignable; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_trivially_move_assignable' is a}}
- std::is_trivially_move_assignable_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_trivially_move_assignable_v' is a}}
- std::is_trivially_move_constructible; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_trivially_move_constructible' is a}}
- std::is_trivially_move_constructible_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_trivially_move_constructible_v' is a}}
- std::is_unbounded_array; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_unbounded_array' is a}}
- std::is_unbounded_array_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_unbounded_array_v' is a}}
- std::is_union; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_union' is a}}
- std::is_union_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_union_v' is a}}
- std::is_unsigned; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_unsigned' is a}}
- std::is_unsigned_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_unsigned_v' is a}}
- std::is_virtual_base_of; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_virtual_base_of' is a}}
- std::is_virtual_base_of_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_virtual_base_of_v' is a}}
- std::is_void; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_void' is a}}
- std::is_void_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_void_v' is a}}
- std::is_volatile; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_volatile' is a}}
- std::is_volatile_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_volatile_v' is a}}
- std::is_within_lifetime; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::is_within_lifetime' is a}}
- std::isalnum; // expected-error {{no member}} expected-note {{maybe try}}
- std::isalpha; // expected-error {{no member}} expected-note {{maybe try}}
- std::isblank; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::isblank' is a}}
- std::iscntrl; // expected-error {{no member}} expected-note {{maybe try}}
- std::isdigit; // expected-error {{no member}} expected-note {{maybe try}}
- std::isgraph; // expected-error {{no member}} expected-note {{maybe try}}
- std::isgreater; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::isgreater' is a}}
- std::isgreaterequal; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::isgreaterequal' is a}}
- std::isless; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::isless' is a}}
- std::islessequal; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::islessequal' is a}}
- std::islessgreater; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::islessgreater' is a}}
- std::islower; // expected-error {{no member}} expected-note {{maybe try}}
- std::ispanstream; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ispanstream' is a}}
- std::ispanstream; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ispanstream' is a}}
- std::isprint; // expected-error {{no member}} expected-note {{maybe try}}
- std::ispunct; // expected-error {{no member}} expected-note {{maybe try}}
- std::isspace; // expected-error {{no member}} expected-note {{maybe try}}
- std::istream; // expected-error {{no member}} expected-note {{maybe try}}
- std::istream; // expected-error {{no member}} expected-note {{maybe try}}
- std::istream; // expected-error {{no member}} expected-note {{maybe try}}
- std::istream_iterator; // expected-error {{no member}} expected-note {{maybe try}}
- std::istreambuf_iterator; // expected-error {{no member}} expected-note {{maybe try}}
- std::istreambuf_iterator; // expected-error {{no member}} expected-note {{maybe try}}
- std::istringstream; // expected-error {{no member}} expected-note {{maybe try}}
- std::istringstream; // expected-error {{no member}} expected-note {{maybe try}}
- std::istrstream; // expected-error {{no member}} expected-note {{maybe try}}
- std::isunordered; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::isunordered' is a}}
- std::isupper; // expected-error {{no member}} expected-note {{maybe try}}
- std::iswalnum; // expected-error {{no member}} expected-note {{maybe try}}
- std::iswalpha; // expected-error {{no member}} expected-note {{maybe try}}
- std::iswblank; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::iswblank' is a}}
- std::iswcntrl; // expected-error {{no member}} expected-note {{maybe try}}
- std::iswctype; // expected-error {{no member}} expected-note {{maybe try}}
- std::iswdigit; // expected-error {{no member}} expected-note {{maybe try}}
- std::iswgraph; // expected-error {{no member}} expected-note {{maybe try}}
- std::iswlower; // expected-error {{no member}} expected-note {{maybe try}}
- std::iswprint; // expected-error {{no member}} expected-note {{maybe try}}
- std::iswpunct; // expected-error {{no member}} expected-note {{maybe try}}
- std::iswspace; // expected-error {{no member}} expected-note {{maybe try}}
- std::iswupper; // expected-error {{no member}} expected-note {{maybe try}}
- std::iswxdigit; // expected-error {{no member}} expected-note {{maybe try}}
- std::isxdigit; // expected-error {{no member}} expected-note {{maybe try}}
- std::iter_common_reference_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::iter_common_reference_t' is a}}
- std::iter_const_reference_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::iter_const_reference_t' is a}}
- std::iter_difference_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::iter_difference_t' is a}}
- std::iter_reference_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::iter_reference_t' is a}}
- std::iter_rvalue_reference_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::iter_rvalue_reference_t' is a}}
- std::iter_swap; // expected-error {{no member}} expected-note {{maybe try}}
- std::iter_value_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::iter_value_t' is a}}
- std::iterator; // expected-error {{no member}} expected-note {{maybe try}}
- std::iterator_traits; // expected-error {{no member}} expected-note {{maybe try}}
- std::jmp_buf; // expected-error {{no member}} expected-note {{maybe try}}
- std::jthread; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::jthread' is a}}
- std::kill_dependency; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::kill_dependency' is a}}
- std::kilo; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::kilo' is a}}
- std::knuth_b; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::knuth_b' is a}}
- std::labs; // expected-error {{no member}} expected-note {{maybe try}}
- std::laguerre; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::laguerre' is a}}
- std::laguerref; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::laguerref' is a}}
- std::laguerrel; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::laguerrel' is a}}
- std::latch; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::latch' is a}}
- std::launch; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::launch' is a}}
- std::launder; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::launder' is a}}
- std::layout_left; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::layout_left' is a}}
- std::layout_left_padded; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::layout_left_padded' is a}}
- std::layout_right; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::layout_right' is a}}
- std::layout_right_padded; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::layout_right_padded' is a}}
- std::layout_stride; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::layout_stride' is a}}
- std::lcm; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::lcm' is a}}
- std::lconv; // expected-error {{no member}} expected-note {{maybe try}}
- std::ldexp; // expected-error {{no member}} expected-note {{maybe try}}
- std::ldexpf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ldexpf' is a}}
- std::ldexpl; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ldexpl' is a}}
- std::ldiv; // expected-error {{no member}} expected-note {{maybe try}}
- std::ldiv_t; // expected-error {{no member}} expected-note {{maybe try}}
- std::left; // expected-error {{no member}} expected-note {{maybe try}}
- std::left; // expected-error {{no member}} expected-note {{maybe try}}
- std::legendre; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::legendre' is a}}
- std::legendref; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::legendref' is a}}
- std::legendrel; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::legendrel' is a}}
- std::length_error; // expected-error {{no member}} expected-note {{maybe try}}
- std::lerp; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::lerp' is a}}
- std::less; // expected-error {{no member}} expected-note {{maybe try}}
- std::less_equal; // expected-error {{no member}} expected-note {{maybe try}}
- std::lexicographical_compare; // expected-error {{no member}} expected-note {{maybe try}}
- std::lexicographical_compare_three_way; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::lexicographical_compare_three_way' is a}}
- std::lgammaf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::lgammaf' is a}}
- std::lgammal; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::lgammal' is a}}
- std::linear_congruential_engine; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::linear_congruential_engine' is a}}
- std::list; // expected-error {{no member}} expected-note {{maybe try}}
- std::llabs; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::llabs' is a}}
- std::lldiv; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::lldiv' is a}}
- std::lldiv_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::lldiv_t' is a}}
- std::llrint; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::llrint' is a}}
- std::llrintf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::llrintf' is a}}
- std::llrintl; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::llrintl' is a}}
- std::llround; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::llround' is a}}
- std::llroundf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::llroundf' is a}}
- std::llroundl; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::llroundl' is a}}
- std::locale; // expected-error {{no member}} expected-note {{maybe try}}
- std::localeconv; // expected-error {{no member}} expected-note {{maybe try}}
- std::localtime; // expected-error {{no member}} expected-note {{maybe try}}
- std::lock; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::lock' is a}}
- std::lock_guard; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::lock_guard' is a}}
- std::log10f; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::log10f' is a}}
- std::log10l; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::log10l' is a}}
- std::log1pf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::log1pf' is a}}
- std::log1pl; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::log1pl' is a}}
- std::log2f; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::log2f' is a}}
- std::log2l; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::log2l' is a}}
- std::logbf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::logbf' is a}}
- std::logbl; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::logbl' is a}}
- std::logf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::logf' is a}}
- std::logic_error; // expected-error {{no member}} expected-note {{maybe try}}
- std::logical_and; // expected-error {{no member}} expected-note {{maybe try}}
- std::logical_not; // expected-error {{no member}} expected-note {{maybe try}}
- std::logical_or; // expected-error {{no member}} expected-note {{maybe try}}
- std::logl; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::logl' is a}}
- std::lognormal_distribution; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::lognormal_distribution' is a}}
- std::longjmp; // expected-error {{no member}} expected-note {{maybe try}}
- std::lower_bound; // expected-error {{no member}} expected-note {{maybe try}}
- std::lrint; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::lrint' is a}}
- std::lrintf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::lrintf' is a}}
- std::lrintl; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::lrintl' is a}}
- std::lround; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::lround' is a}}
- std::lroundf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::lroundf' is a}}
- std::lroundl; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::lroundl' is a}}
- std::make_any; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::make_any' is a}}
- std::make_const_iterator; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::make_const_iterator' is a}}
- std::make_const_sentinel; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::make_const_sentinel' is a}}
- std::make_exception_ptr; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::make_exception_ptr' is a}}
- std::make_format_args; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::make_format_args' is a}}
- std::make_from_tuple; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::make_from_tuple' is a}}
- std::make_heap; // expected-error {{no member}} expected-note {{maybe try}}
- std::make_index_sequence; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::make_index_sequence' is a}}
- std::make_integer_sequence; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::make_integer_sequence' is a}}
- std::make_move_iterator; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::make_move_iterator' is a}}
- std::make_obj_using_allocator; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::make_obj_using_allocator' is a}}
- std::make_optional; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::make_optional' is a}}
- std::make_pair; // expected-error {{no member}} expected-note {{maybe try}}
- std::make_reverse_iterator; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::make_reverse_iterator' is a}}
- std::make_shared; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::make_shared' is a}}
- std::make_shared_for_overwrite; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::make_shared_for_overwrite' is a}}
- std::make_signed; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::make_signed' is a}}
- std::make_signed_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::make_signed_t' is a}}
- std::make_tuple; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::make_tuple' is a}}
- std::make_unique; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::make_unique' is a}}
- std::make_unique_for_overwrite; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::make_unique_for_overwrite' is a}}
- std::make_unsigned; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::make_unsigned' is a}}
- std::make_unsigned_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::make_unsigned_t' is a}}
- std::make_wformat_args; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::make_wformat_args' is a}}
- std::malloc; // expected-error {{no member}} expected-note {{maybe try}}
- std::map; // expected-error {{no member}} expected-note {{maybe try}}
- std::mask_array; // expected-error {{no member}} expected-note {{maybe try}}
- std::match_results; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::match_results' is a}}
- std::max; // expected-error {{no member}} expected-note {{maybe try}}
- std::max_align_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::max_align_t' is a}}
- std::max_element; // expected-error {{no member}} expected-note {{maybe try}}
- std::mblen; // expected-error {{no member}} expected-note {{maybe try}}
- std::mbrlen; // expected-error {{no member}} expected-note {{maybe try}}
- std::mbrtoc16; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::mbrtoc16' is a}}
- std::mbrtoc32; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::mbrtoc32' is a}}
- std::mbrtoc8; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::mbrtoc8' is a}}
- std::mbrtowc; // expected-error {{no member}} expected-note {{maybe try}}
- std::mbsinit; // expected-error {{no member}} expected-note {{maybe try}}
- std::mbsrtowcs; // expected-error {{no member}} expected-note {{maybe try}}
- std::mbstowcs; // expected-error {{no member}} expected-note {{maybe try}}
- std::mbtowc; // expected-error {{no member}} expected-note {{maybe try}}
- std::mdspan; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::mdspan' is a}}
- std::mega; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::mega' is a}}
- std::mem_fn; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::mem_fn' is a}}
- std::mem_fun; // expected-error {{no member}} expected-note {{maybe try}}
- std::mem_fun1_ref_t; // expected-error {{no member}} expected-note {{maybe try}}
- std::mem_fun1_t; // expected-error {{no member}} expected-note {{maybe try}}
- std::mem_fun_ref; // expected-error {{no member}} expected-note {{maybe try}}
- std::mem_fun_ref_t; // expected-error {{no member}} expected-note {{maybe try}}
- std::mem_fun_t; // expected-error {{no member}} expected-note {{maybe try}}
- std::memchr; // expected-error {{no member}} expected-note {{maybe try}}
- std::memcmp; // expected-error {{no member}} expected-note {{maybe try}}
- std::memcpy; // expected-error {{no member}} expected-note {{maybe try}}
- std::memmove; // expected-error {{no member}} expected-note {{maybe try}}
- std::memory_order; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::memory_order' is a}}
- std::memory_order_acq_rel; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::memory_order_acq_rel' is a}}
- std::memory_order_acquire; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::memory_order_acquire' is a}}
- std::memory_order_consume; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::memory_order_consume' is a}}
- std::memory_order_relaxed; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::memory_order_relaxed' is a}}
- std::memory_order_release; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::memory_order_release' is a}}
- std::memory_order_seq_cst; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::memory_order_seq_cst' is a}}
- std::memset; // expected-error {{no member}} expected-note {{maybe try}}
- std::merge; // expected-error {{no member}} expected-note {{maybe try}}
- std::mergeable; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::mergeable' is a}}
- std::mersenne_twister_engine; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::mersenne_twister_engine' is a}}
- std::messages; // expected-error {{no member}} expected-note {{maybe try}}
- std::messages_base; // expected-error {{no member}} expected-note {{maybe try}}
- std::messages_byname; // expected-error {{no member}} expected-note {{maybe try}}
- std::micro; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::micro' is a}}
- std::midpoint; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::midpoint' is a}}
- std::milli; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::milli' is a}}
- std::min; // expected-error {{no member}} expected-note {{maybe try}}
- std::min_element; // expected-error {{no member}} expected-note {{maybe try}}
- std::minmax; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::minmax' is a}}
- std::minmax_element; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::minmax_element' is a}}
- std::minstd_rand; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::minstd_rand' is a}}
- std::minstd_rand0; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::minstd_rand0' is a}}
- std::minus; // expected-error {{no member}} expected-note {{maybe try}}
- std::mismatch; // expected-error {{no member}} expected-note {{maybe try}}
- std::mktime; // expected-error {{no member}} expected-note {{maybe try}}
- std::modf; // expected-error {{no member}} expected-note {{maybe try}}
- std::modff; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::modff' is a}}
- std::modfl; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::modfl' is a}}
- std::modulus; // expected-error {{no member}} expected-note {{maybe try}}
- std::money_base; // expected-error {{no member}} expected-note {{maybe try}}
- std::money_get; // expected-error {{no member}} expected-note {{maybe try}}
- std::money_put; // expected-error {{no member}} expected-note {{maybe try}}
- std::moneypunct; // expected-error {{no member}} expected-note {{maybe try}}
- std::moneypunct_byname; // expected-error {{no member}} expected-note {{maybe try}}
- std::movable; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::movable' is a}}
- std::move_backward; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::move_backward' is a}}
- std::move_constructible; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::move_constructible' is a}}
- std::move_if_noexcept; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::move_if_noexcept' is a}}
- std::move_iterator; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::move_iterator' is a}}
- std::move_only_function; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::move_only_function' is a}}
- std::move_sentinel; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::move_sentinel' is a}}
- std::mt19937; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::mt19937' is a}}
- std::mt19937_64; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::mt19937_64' is a}}
- std::mul_sat; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::mul_sat' is a}}
- std::multimap; // expected-error {{no member}} expected-note {{maybe try}}
- std::multiplies; // expected-error {{no member}} expected-note {{maybe try}}
- std::multiset; // expected-error {{no member}} expected-note {{maybe try}}
- std::mutex; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::mutex' is a}}
- std::nan; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::nan' is a}}
- std::nanf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::nanf' is a}}
- std::nanl; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::nanl' is a}}
- std::nano; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::nano' is a}}
- std::nearbyintf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::nearbyintf' is a}}
- std::nearbyintl; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::nearbyintl' is a}}
- std::negate; // expected-error {{no member}} expected-note {{maybe try}}
- std::negation; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::negation' is a}}
- std::negation_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::negation_v' is a}}
- std::negative_binomial_distribution; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::negative_binomial_distribution' is a}}
- std::nested_exception; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::nested_exception' is a}}
- std::new_handler; // expected-error {{no member}} expected-note {{maybe try}}
- std::next; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::next' is a}}
- std::next_permutation; // expected-error {{no member}} expected-note {{maybe try}}
- std::nextafter; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::nextafter' is a}}
- std::nextafterf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::nextafterf' is a}}
- std::nextafterl; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::nextafterl' is a}}
- std::nexttoward; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::nexttoward' is a}}
- std::nexttowardf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::nexttowardf' is a}}
- std::nexttowardl; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::nexttowardl' is a}}
- std::noboolalpha; // expected-error {{no member}} expected-note {{maybe try}}
- std::noboolalpha; // expected-error {{no member}} expected-note {{maybe try}}
- std::noemit_on_flush; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::noemit_on_flush' is a}}
- std::noemit_on_flush; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::noemit_on_flush' is a}}
- std::none_of; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::none_of' is a}}
- std::nontype; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::nontype' is a}}
- std::nontype_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::nontype_t' is a}}
- std::noop_coroutine; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::noop_coroutine' is a}}
- std::noop_coroutine_handle; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::noop_coroutine_handle' is a}}
- std::noop_coroutine_promise; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::noop_coroutine_promise' is a}}
- std::norm; // expected-error {{no member}} expected-note {{maybe try}}
- std::normal_distribution; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::normal_distribution' is a}}
- std::noshowbase; // expected-error {{no member}} expected-note {{maybe try}}
- std::noshowbase; // expected-error {{no member}} expected-note {{maybe try}}
- std::noshowpoint; // expected-error {{no member}} expected-note {{maybe try}}
- std::noshowpoint; // expected-error {{no member}} expected-note {{maybe try}}
- std::noshowpos; // expected-error {{no member}} expected-note {{maybe try}}
- std::noshowpos; // expected-error {{no member}} expected-note {{maybe try}}
- std::noskipws; // expected-error {{no member}} expected-note {{maybe try}}
- std::noskipws; // expected-error {{no member}} expected-note {{maybe try}}
- std::nostopstate; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::nostopstate' is a}}
- std::nostopstate_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::nostopstate_t' is a}}
- std::not1; // expected-error {{no member}} expected-note {{maybe try}}
- std::not2; // expected-error {{no member}} expected-note {{maybe try}}
- std::not_equal_to; // expected-error {{no member}} expected-note {{maybe try}}
- std::not_fn; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::not_fn' is a}}
- std::nothrow; // expected-error {{no member}} expected-note {{maybe try}}
- std::nothrow_t; // expected-error {{no member}} expected-note {{maybe try}}
- std::notify_all_at_thread_exit; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::notify_all_at_thread_exit' is a}}
- std::nounitbuf; // expected-error {{no member}} expected-note {{maybe try}}
- std::nounitbuf; // expected-error {{no member}} expected-note {{maybe try}}
- std::nouppercase; // expected-error {{no member}} expected-note {{maybe try}}
- std::nouppercase; // expected-error {{no member}} expected-note {{maybe try}}
- std::nth_element; // expected-error {{no member}} expected-note {{maybe try}}
- std::nullopt; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::nullopt' is a}}
- std::nullopt_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::nullopt_t' is a}}
- std::nullptr_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::nullptr_t' is a}}
- std::num_get; // expected-error {{no member}} expected-note {{maybe try}}
- std::num_put; // expected-error {{no member}} expected-note {{maybe try}}
- std::numeric_limits; // expected-error {{no member}} expected-note {{maybe try}}
- std::numpunct; // expected-error {{no member}} expected-note {{maybe try}}
- std::numpunct_byname; // expected-error {{no member}} expected-note {{maybe try}}
- std::oct; // expected-error {{no member}} expected-note {{maybe try}}
- std::oct; // expected-error {{no member}} expected-note {{maybe try}}
- std::ofstream; // expected-error {{no member}} expected-note {{maybe try}}
- std::ofstream; // expected-error {{no member}} expected-note {{maybe try}}
- std::once_flag; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::once_flag' is a}}
- std::op; // expected-error {{no member}} expected-note {{maybe try}}
- std::open_mode; // expected-error {{no member}} expected-note {{maybe try}}
- std::open_mode; // expected-error {{no member}} expected-note {{maybe try}}
- std::optional; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::optional' is a}}
- std::ospanstream; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ospanstream' is a}}
- std::ospanstream; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ospanstream' is a}}
- std::ostream; // expected-error {{no member}} expected-note {{maybe try}}
- std::ostream; // expected-error {{no member}} expected-note {{maybe try}}
- std::ostream; // expected-error {{no member}} expected-note {{maybe try}}
- std::ostream_iterator; // expected-error {{no member}} expected-note {{maybe try}}
- std::ostreambuf_iterator; // expected-error {{no member}} expected-note {{maybe try}}
- std::ostreambuf_iterator; // expected-error {{no member}} expected-note {{maybe try}}
- std::ostringstream; // expected-error {{no member}} expected-note {{maybe try}}
- std::ostringstream; // expected-error {{no member}} expected-note {{maybe try}}
- std::ostrstream; // expected-error {{no member}} expected-note {{maybe try}}
- std::osyncstream; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::osyncstream' is a}}
- std::osyncstream; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::osyncstream' is a}}
- std::out_of_range; // expected-error {{no member}} expected-note {{maybe try}}
- std::out_ptr; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::out_ptr' is a}}
- std::out_ptr_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::out_ptr_t' is a}}
- std::output_iterator; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::output_iterator' is a}}
- std::output_iterator_tag; // expected-error {{no member}} expected-note {{maybe try}}
- std::overflow_error; // expected-error {{no member}} expected-note {{maybe try}}
- std::owner_less; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::owner_less' is a}}
- std::packaged_task; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::packaged_task' is a}}
- std::pair; // expected-error {{no member}} expected-note {{maybe try}}
- std::partial_order; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::partial_order' is a}}
- std::partial_ordering; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::partial_ordering' is a}}
- std::partial_sort; // expected-error {{no member}} expected-note {{maybe try}}
- std::partial_sort_copy; // expected-error {{no member}} expected-note {{maybe try}}
- std::partial_sum; // expected-error {{no member}} expected-note {{maybe try}}
- std::partition; // expected-error {{no member}} expected-note {{maybe try}}
- std::partition_copy; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::partition_copy' is a}}
- std::partition_point; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::partition_point' is a}}
- std::permutable; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::permutable' is a}}
- std::perror; // expected-error {{no member}} expected-note {{maybe try}}
- std::peta; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::peta' is a}}
- std::pico; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::pico' is a}}
- std::piecewise_constant_distribution; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::piecewise_constant_distribution' is a}}
- std::piecewise_construct; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::piecewise_construct' is a}}
- std::piecewise_construct_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::piecewise_construct_t' is a}}
- std::piecewise_linear_distribution; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::piecewise_linear_distribution' is a}}
- std::plus; // expected-error {{no member}} expected-note {{maybe try}}
- std::pointer_safety; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::pointer_safety' is a}}
- std::pointer_traits; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::pointer_traits' is a}}
- std::poisson_distribution; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::poisson_distribution' is a}}
- std::polar; // expected-error {{no member}} expected-note {{maybe try}}
- std::pop_heap; // expected-error {{no member}} expected-note {{maybe try}}
- std::popcount; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::popcount' is a}}
- std::pow; // expected-error {{no member}} expected-note {{maybe try}}
- std::powf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::powf' is a}}
- std::powl; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::powl' is a}}
- std::predicate; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::predicate' is a}}
- std::preferred; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::preferred' is a}}
- std::prev; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::prev' is a}}
- std::prev_permutation; // expected-error {{no member}} expected-note {{maybe try}}
- std::print; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::print' is a}}
- std::printf; // expected-error {{no member}} expected-note {{maybe try}}
- std::println; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::println' is a}}
- std::priority_queue; // expected-error {{no member}} expected-note {{maybe try}}
- std::proj; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::proj' is a}}
- std::projected; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::projected' is a}}
- std::promise; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::promise' is a}}
- std::ptr_fun; // expected-error {{no member}} expected-note {{maybe try}}
- std::ptrdiff_t; // expected-error {{no member}} expected-note {{maybe try}}
- std::push_heap; // expected-error {{no member}} expected-note {{maybe try}}
- std::put_money; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::put_money' is a}}
- std::put_time; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::put_time' is a}}
- std::putc; // expected-error {{no member}} expected-note {{maybe try}}
- std::putchar; // expected-error {{no member}} expected-note {{maybe try}}
- std::puts; // expected-error {{no member}} expected-note {{maybe try}}
- std::putwc; // expected-error {{no member}} expected-note {{maybe try}}
- std::putwchar; // expected-error {{no member}} expected-note {{maybe try}}
- std::qsort; // expected-error {{no member}} expected-note {{maybe try}}
- std::quecto; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::quecto' is a}}
- std::quetta; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::quetta' is a}}
- std::queue; // expected-error {{no member}} expected-note {{maybe try}}
- std::quick_exit; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::quick_exit' is a}}
- std::quoted; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::quoted' is a}}
- std::raise; // expected-error {{no member}} expected-note {{maybe try}}
- std::rand; // expected-error {{no member}} expected-note {{maybe try}}
- std::random_access_iterator; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::random_access_iterator' is a}}
- std::random_access_iterator_tag; // expected-error {{no member}} expected-note {{maybe try}}
- std::random_device; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::random_device' is a}}
- std::random_shuffle; // expected-error {{no member}} expected-note {{maybe try}}
- std::range_error; // expected-error {{no member}} expected-note {{maybe try}}
- std::range_format; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::range_format' is a}}
- std::range_formatter; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::range_formatter' is a}}
- std::rank; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::rank' is a}}
- std::rank_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::rank_v' is a}}
- std::ranlux24; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranlux24' is a}}
- std::ranlux24_base; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranlux24_base' is a}}
- std::ranlux48; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranlux48' is a}}
- std::ranlux48_base; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranlux48_base' is a}}
- std::ratio; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ratio' is a}}
- std::ratio_add; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ratio_add' is a}}
- std::ratio_divide; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ratio_divide' is a}}
- std::ratio_equal; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ratio_equal' is a}}
- std::ratio_equal_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ratio_equal_v' is a}}
- std::ratio_greater; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ratio_greater' is a}}
- std::ratio_greater_equal; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ratio_greater_equal' is a}}
- std::ratio_greater_equal_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ratio_greater_equal_v' is a}}
- std::ratio_greater_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ratio_greater_v' is a}}
- std::ratio_less; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ratio_less' is a}}
- std::ratio_less_equal; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ratio_less_equal' is a}}
- std::ratio_less_equal_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ratio_less_equal_v' is a}}
- std::ratio_less_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ratio_less_v' is a}}
- std::ratio_multiply; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ratio_multiply' is a}}
- std::ratio_not_equal; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ratio_not_equal' is a}}
- std::ratio_not_equal_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ratio_not_equal_v' is a}}
- std::ratio_subtract; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ratio_subtract' is a}}
- std::raw_storage_iterator; // expected-error {{no member}} expected-note {{maybe try}}
- std::real; // expected-error {{no member}} expected-note {{maybe try}}
- std::realloc; // expected-error {{no member}} expected-note {{maybe try}}
- std::recursive_mutex; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::recursive_mutex' is a}}
- std::recursive_timed_mutex; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::recursive_timed_mutex' is a}}
- std::reduce; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::reduce' is a}}
- std::ref; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ref' is a}}
- std::reference_constructs_from_temporary; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::reference_constructs_from_temporary' is a}}
- std::reference_converts_from_temporary; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::reference_converts_from_temporary' is a}}
- std::reference_wrapper; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::reference_wrapper' is a}}
- std::regex; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::regex' is a}}
- std::regex_error; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::regex_error' is a}}
- std::regex_iterator; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::regex_iterator' is a}}
- std::regex_match; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::regex_match' is a}}
- std::regex_replace; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::regex_replace' is a}}
- std::regex_search; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::regex_search' is a}}
- std::regex_token_iterator; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::regex_token_iterator' is a}}
- std::regex_traits; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::regex_traits' is a}}
- std::regular; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::regular' is a}}
- std::regular_invocable; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::regular_invocable' is a}}
- std::reinterpret_pointer_cast; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::reinterpret_pointer_cast' is a}}
- std::relation; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::relation' is a}}
- std::relaxed; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::relaxed' is a}}
- std::remainderf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::remainderf' is a}}
- std::remainderl; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::remainderl' is a}}
- std::remove_all_extents; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::remove_all_extents' is a}}
- std::remove_all_extents_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::remove_all_extents_t' is a}}
- std::remove_const; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::remove_const' is a}}
- std::remove_const_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::remove_const_t' is a}}
- std::remove_copy; // expected-error {{no member}} expected-note {{maybe try}}
- std::remove_copy_if; // expected-error {{no member}} expected-note {{maybe try}}
- std::remove_cv; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::remove_cv' is a}}
- std::remove_cv_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::remove_cv_t' is a}}
- std::remove_cvref; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::remove_cvref' is a}}
- std::remove_cvref_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::remove_cvref_t' is a}}
- std::remove_extent; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::remove_extent' is a}}
- std::remove_extent_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::remove_extent_t' is a}}
- std::remove_if; // expected-error {{no member}} expected-note {{maybe try}}
- std::remove_pointer; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::remove_pointer' is a}}
- std::remove_pointer_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::remove_pointer_t' is a}}
- std::remove_reference; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::remove_reference' is a}}
- std::remove_reference_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::remove_reference_t' is a}}
- std::remove_volatile; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::remove_volatile' is a}}
- std::remove_volatile_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::remove_volatile_t' is a}}
- std::remquo; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::remquo' is a}}
- std::remquof; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::remquof' is a}}
- std::remquol; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::remquol' is a}}
- std::rename; // expected-error {{no member}} expected-note {{maybe try}}
- std::replace; // expected-error {{no member}} expected-note {{maybe try}}
- std::replace_copy; // expected-error {{no member}} expected-note {{maybe try}}
- std::replace_copy_if; // expected-error {{no member}} expected-note {{maybe try}}
- std::replace_if; // expected-error {{no member}} expected-note {{maybe try}}
- std::resetiosflags; // expected-error {{no member}} expected-note {{maybe try}}
- std::result_of; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::result_of' is a}}
- std::result_of_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::result_of_t' is a}}
- std::rethrow_exception; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::rethrow_exception' is a}}
- std::rethrow_if_nested; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::rethrow_if_nested' is a}}
- std::return_temporary_buffer; // expected-error {{no member}} expected-note {{maybe try}}
- std::reverse; // expected-error {{no member}} expected-note {{maybe try}}
- std::reverse_copy; // expected-error {{no member}} expected-note {{maybe try}}
- std::reverse_iterator; // expected-error {{no member}} expected-note {{maybe try}}
- std::rewind; // expected-error {{no member}} expected-note {{maybe try}}
- std::riemann_zeta; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::riemann_zeta' is a}}
- std::riemann_zetaf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::riemann_zetaf' is a}}
- std::riemann_zetal; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::riemann_zetal' is a}}
- std::right; // expected-error {{no member}} expected-note {{maybe try}}
- std::right; // expected-error {{no member}} expected-note {{maybe try}}
- std::rint; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::rint' is a}}
- std::rintf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::rintf' is a}}
- std::rintl; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::rintl' is a}}
- std::ronna; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ronna' is a}}
- std::ronto; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ronto' is a}}
- std::rotate; // expected-error {{no member}} expected-note {{maybe try}}
- std::rotate_copy; // expected-error {{no member}} expected-note {{maybe try}}
- std::rotl; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::rotl' is a}}
- std::rotr; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::rotr' is a}}
- std::round; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::round' is a}}
- std::round_indeterminate; // expected-error {{no member}} expected-note {{maybe try}}
- std::round_to_nearest; // expected-error {{no member}} expected-note {{maybe try}}
- std::round_toward_infinity; // expected-error {{no member}} expected-note {{maybe try}}
- std::round_toward_neg_infinity; // expected-error {{no member}} expected-note {{maybe try}}
- std::round_toward_zero; // expected-error {{no member}} expected-note {{maybe try}}
- std::roundf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::roundf' is a}}
- std::roundl; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::roundl' is a}}
- std::runtime_error; // expected-error {{no member}} expected-note {{maybe try}}
- std::runtime_format; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::runtime_format' is a}}
- std::same_as; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::same_as' is a}}
- std::sample; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::sample' is a}}
- std::saturate_cast; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::saturate_cast' is a}}
- std::scalbln; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::scalbln' is a}}
- std::scalblnf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::scalblnf' is a}}
- std::scalblnl; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::scalblnl' is a}}
- std::scalbn; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::scalbn' is a}}
- std::scalbnf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::scalbnf' is a}}
- std::scalbnl; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::scalbnl' is a}}
- std::scanf; // expected-error {{no member}} expected-note {{maybe try}}
- std::scientific; // expected-error {{no member}} expected-note {{maybe try}}
- std::scientific; // expected-error {{no member}} expected-note {{maybe try}}
- std::scoped_allocator_adaptor; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::scoped_allocator_adaptor' is a}}
- std::scoped_lock; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::scoped_lock' is a}}
- std::search; // expected-error {{no member}} expected-note {{maybe try}}
- std::search_n; // expected-error {{no member}} expected-note {{maybe try}}
- std::seed_seq; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::seed_seq' is a}}
- std::seek_dir; // expected-error {{no member}} expected-note {{maybe try}}
- std::seek_dir; // expected-error {{no member}} expected-note {{maybe try}}
- std::semiregular; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::semiregular' is a}}
- std::sentinel_for; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::sentinel_for' is a}}
- std::set; // expected-error {{no member}} expected-note {{maybe try}}
- std::set_difference; // expected-error {{no member}} expected-note {{maybe try}}
- std::set_intersection; // expected-error {{no member}} expected-note {{maybe try}}
- std::set_new_handler; // expected-error {{no member}} expected-note {{maybe try}}
- std::set_symmetric_difference; // expected-error {{no member}} expected-note {{maybe try}}
- std::set_terminate; // expected-error {{no member}} expected-note {{maybe try}}
- std::set_unexpected; // expected-error {{no member}} expected-note {{maybe try}}
- std::set_union; // expected-error {{no member}} expected-note {{maybe try}}
- std::setbase; // expected-error {{no member}} expected-note {{maybe try}}
- std::setbuf; // expected-error {{no member}} expected-note {{maybe try}}
- std::setfill; // expected-error {{no member}} expected-note {{maybe try}}
- std::setiosflags; // expected-error {{no member}} expected-note {{maybe try}}
- std::setlocale; // expected-error {{no member}} expected-note {{maybe try}}
- std::setprecision; // expected-error {{no member}} expected-note {{maybe try}}
- std::setvbuf; // expected-error {{no member}} expected-note {{maybe try}}
- std::setw; // expected-error {{no member}} expected-note {{maybe try}}
- std::shared_future; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::shared_future' is a}}
- std::shared_lock; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::shared_lock' is a}}
- std::shared_mutex; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::shared_mutex' is a}}
- std::shared_ptr; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::shared_ptr' is a}}
- std::shared_timed_mutex; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::shared_timed_mutex' is a}}
- std::shift_left; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::shift_left' is a}}
- std::shift_right; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::shift_right' is a}}
- std::showbase; // expected-error {{no member}} expected-note {{maybe try}}
- std::showbase; // expected-error {{no member}} expected-note {{maybe try}}
- std::showpoint; // expected-error {{no member}} expected-note {{maybe try}}
- std::showpoint; // expected-error {{no member}} expected-note {{maybe try}}
- std::showpos; // expected-error {{no member}} expected-note {{maybe try}}
- std::showpos; // expected-error {{no member}} expected-note {{maybe try}}
- std::shuffle; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::shuffle' is a}}
- std::shuffle_order_engine; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::shuffle_order_engine' is a}}
- std::sig_atomic_t; // expected-error {{no member}} expected-note {{maybe try}}
- std::signal; // expected-error {{no member}} expected-note {{maybe try}}
- std::signed_integral; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::signed_integral' is a}}
- std::sinf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::sinf' is a}}
- std::sinhf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::sinhf' is a}}
- std::sinhl; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::sinhl' is a}}
- std::sinl; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::sinl' is a}}
- std::sized_sentinel_for; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::sized_sentinel_for' is a}}
- std::skipws; // expected-error {{no member}} expected-note {{maybe try}}
- std::skipws; // expected-error {{no member}} expected-note {{maybe try}}
- std::slice; // expected-error {{no member}} expected-note {{maybe try}}
- std::slice_array; // expected-error {{no member}} expected-note {{maybe try}}
- std::smatch; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::smatch' is a}}
- std::snprintf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::snprintf' is a}}
- std::sort; // expected-error {{no member}} expected-note {{maybe try}}
- std::sort_heap; // expected-error {{no member}} expected-note {{maybe try}}
- std::sortable; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::sortable' is a}}
- std::source_location; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::source_location' is a}}
- std::span; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::span' is a}}
- std::spanbuf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::spanbuf' is a}}
- std::spanbuf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::spanbuf' is a}}
- std::spanstream; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::spanstream' is a}}
- std::spanstream; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::spanstream' is a}}
- std::sph_bessel; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::sph_bessel' is a}}
- std::sph_besself; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::sph_besself' is a}}
- std::sph_bessell; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::sph_bessell' is a}}
- std::sph_legendre; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::sph_legendre' is a}}
- std::sph_legendref; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::sph_legendref' is a}}
- std::sph_legendrel; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::sph_legendrel' is a}}
- std::sph_neumann; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::sph_neumann' is a}}
- std::sph_neumannf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::sph_neumannf' is a}}
- std::sph_neumannl; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::sph_neumannl' is a}}
- std::sprintf; // expected-error {{no member}} expected-note {{maybe try}}
- std::sqrtf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::sqrtf' is a}}
- std::sqrtl; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::sqrtl' is a}}
- std::srand; // expected-error {{no member}} expected-note {{maybe try}}
- std::sregex_iterator; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::sregex_iterator' is a}}
- std::sregex_token_iterator; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::sregex_token_iterator' is a}}
- std::sscanf; // expected-error {{no member}} expected-note {{maybe try}}
- std::ssub_match; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ssub_match' is a}}
- std::stable_partition; // expected-error {{no member}} expected-note {{maybe try}}
- std::stable_sort; // expected-error {{no member}} expected-note {{maybe try}}
- std::stack; // expected-error {{no member}} expected-note {{maybe try}}
- std::stacktrace; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::stacktrace' is a}}
- std::stacktrace_entry; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::stacktrace_entry' is a}}
- std::start_lifetime_as; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::start_lifetime_as' is a}}
- std::static_pointer_cast; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::static_pointer_cast' is a}}
- std::stod; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::stod' is a}}
- std::stof; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::stof' is a}}
- std::stoi; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::stoi' is a}}
- std::stol; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::stol' is a}}
- std::stold; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::stold' is a}}
- std::stoll; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::stoll' is a}}
- std::stop_callback; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::stop_callback' is a}}
- std::stop_source; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::stop_source' is a}}
- std::stop_token; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::stop_token' is a}}
- std::stoul; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::stoul' is a}}
- std::stoull; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::stoull' is a}}
- std::strcat; // expected-error {{no member}} expected-note {{maybe try}}
- std::strchr; // expected-error {{no member}} expected-note {{maybe try}}
- std::strcmp; // expected-error {{no member}} expected-note {{maybe try}}
- std::strcoll; // expected-error {{no member}} expected-note {{maybe try}}
- std::strcpy; // expected-error {{no member}} expected-note {{maybe try}}
- std::strcspn; // expected-error {{no member}} expected-note {{maybe try}}
- std::streambuf; // expected-error {{no member}} expected-note {{maybe try}}
- std::streambuf; // expected-error {{no member}} expected-note {{maybe try}}
- std::streambuf; // expected-error {{no member}} expected-note {{maybe try}}
- std::streamoff; // expected-error {{no member}} expected-note {{maybe try}}
- std::streamoff; // expected-error {{no member}} expected-note {{maybe try}}
- std::streampos; // expected-error {{no member}} expected-note {{maybe try}}
- std::streampos; // expected-error {{no member}} expected-note {{maybe try}}
- std::streamsize; // expected-error {{no member}} expected-note {{maybe try}}
- std::streamsize; // expected-error {{no member}} expected-note {{maybe try}}
- std::strerror; // expected-error {{no member}} expected-note {{maybe try}}
- std::strftime; // expected-error {{no member}} expected-note {{maybe try}}
- std::strict; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::strict' is a}}
- std::strict_weak_order; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::strict_weak_order' is a}}
- std::strided_slice; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::strided_slice' is a}}
- std::string; // expected-error {{no member}} expected-note {{maybe try}}
- std::string_view; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::string_view' is a}}
- std::stringbuf; // expected-error {{no member}} expected-note {{maybe try}}
- std::stringbuf; // expected-error {{no member}} expected-note {{maybe try}}
- std::stringstream; // expected-error {{no member}} expected-note {{maybe try}}
- std::stringstream; // expected-error {{no member}} expected-note {{maybe try}}
- std::strlen; // expected-error {{no member}} expected-note {{maybe try}}
- std::strncat; // expected-error {{no member}} expected-note {{maybe try}}
- std::strncmp; // expected-error {{no member}} expected-note {{maybe try}}
- std::strncpy; // expected-error {{no member}} expected-note {{maybe try}}
- std::strong_order; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::strong_order' is a}}
- std::strong_ordering; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::strong_ordering' is a}}
- std::strpbrk; // expected-error {{no member}} expected-note {{maybe try}}
- std::strrchr; // expected-error {{no member}} expected-note {{maybe try}}
- std::strspn; // expected-error {{no member}} expected-note {{maybe try}}
- std::strstr; // expected-error {{no member}} expected-note {{maybe try}}
- std::strstream; // expected-error {{no member}} expected-note {{maybe try}}
- std::strstreambuf; // expected-error {{no member}} expected-note {{maybe try}}
- std::strtod; // expected-error {{no member}} expected-note {{maybe try}}
- std::strtof; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::strtof' is a}}
- std::strtoimax; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::strtoimax' is a}}
- std::strtok; // expected-error {{no member}} expected-note {{maybe try}}
- std::strtol; // expected-error {{no member}} expected-note {{maybe try}}
- std::strtold; // expected-error {{no member}} expected-note {{maybe try}}
- std::strtoll; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::strtoll' is a}}
- std::strtoul; // expected-error {{no member}} expected-note {{maybe try}}
- std::strtoull; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::strtoull' is a}}
- std::strtoumax; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::strtoumax' is a}}
- std::strxfrm; // expected-error {{no member}} expected-note {{maybe try}}
- std::student_t_distribution; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::student_t_distribution' is a}}
- std::sub_match; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::sub_match' is a}}
- std::sub_sat; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::sub_sat' is a}}
- std::submdspan_mapping_result; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::submdspan_mapping_result' is a}}
- std::subtract_with_carry_engine; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::subtract_with_carry_engine' is a}}
- std::suspend_always; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::suspend_always' is a}}
- std::suspend_never; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::suspend_never' is a}}
- std::swap_ranges; // expected-error {{no member}} expected-note {{maybe try}}
- std::swappable; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::swappable' is a}}
- std::swappable_with; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::swappable_with' is a}}
- std::swprintf; // expected-error {{no member}} expected-note {{maybe try}}
- std::swscanf; // expected-error {{no member}} expected-note {{maybe try}}
- std::syncbuf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::syncbuf' is a}}
- std::syncbuf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::syncbuf' is a}}
- std::system; // expected-error {{no member}} expected-note {{maybe try}}
- std::system_category; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::system_category' is a}}
- std::system_error; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::system_error' is a}}
- std::tanf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::tanf' is a}}
- std::tanhf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::tanhf' is a}}
- std::tanhl; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::tanhl' is a}}
- std::tanl; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::tanl' is a}}
- std::tera; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::tera' is a}}
- std::terminate; // expected-error {{no member}} expected-note {{maybe try}}
- std::terminate_handler; // expected-error {{no member}} expected-note {{maybe try}}
- std::text_encoding; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::text_encoding' is a}}
- std::tgammaf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::tgammaf' is a}}
- std::tgammal; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::tgammal' is a}}
- std::thread; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::thread' is a}}
- std::three_way_comparable; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::three_way_comparable' is a}}
- std::three_way_comparable_with; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::three_way_comparable_with' is a}}
- std::throw_with_nested; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::throw_with_nested' is a}}
- std::tie; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::tie' is a}}
- std::time; // expected-error {{no member}} expected-note {{maybe try}}
- std::time_base; // expected-error {{no member}} expected-note {{maybe try}}
- std::time_get; // expected-error {{no member}} expected-note {{maybe try}}
- std::time_get_byname; // expected-error {{no member}} expected-note {{maybe try}}
- std::time_put; // expected-error {{no member}} expected-note {{maybe try}}
- std::time_put_byname; // expected-error {{no member}} expected-note {{maybe try}}
- std::time_t; // expected-error {{no member}} expected-note {{maybe try}}
- std::timed_mutex; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::timed_mutex' is a}}
- std::timespec; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::timespec' is a}}
- std::timespec_get; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::timespec_get' is a}}
- std::tm; // expected-error {{no member}} expected-note {{maybe try}}
- std::tmpfile; // expected-error {{no member}} expected-note {{maybe try}}
- std::tmpnam; // expected-error {{no member}} expected-note {{maybe try}}
- std::to_address; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::to_address' is a}}
- std::to_array; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::to_array' is a}}
- std::to_chars; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::to_chars' is a}}
- std::to_chars_result; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::to_chars_result' is a}}
- std::to_integer; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::to_integer' is a}}
- std::to_string; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::to_string' is a}}
- std::to_underlying; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::to_underlying' is a}}
- std::to_wstring; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::to_wstring' is a}}
- std::tolower; // expected-error {{no member}} expected-note {{maybe try}}
- std::totally_ordered; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::totally_ordered' is a}}
- std::totally_ordered_with; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::totally_ordered_with' is a}}
- std::toupper; // expected-error {{no member}} expected-note {{maybe try}}
- std::towctrans; // expected-error {{no member}} expected-note {{maybe try}}
- std::towlower; // expected-error {{no member}} expected-note {{maybe try}}
- std::towupper; // expected-error {{no member}} expected-note {{maybe try}}
- std::transform; // expected-error {{no member}} expected-note {{maybe try}}
- std::transform_exclusive_scan; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::transform_exclusive_scan' is a}}
- std::transform_inclusive_scan; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::transform_inclusive_scan' is a}}
- std::transform_reduce; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::transform_reduce' is a}}
- std::true_type; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::true_type' is a}}
- std::truncf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::truncf' is a}}
- std::truncl; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::truncl' is a}}
- std::try_lock; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::try_lock' is a}}
- std::try_to_lock; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::try_to_lock' is a}}
- std::try_to_lock_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::try_to_lock_t' is a}}
- std::tuple; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::tuple' is a}}
- std::tuple_cat; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::tuple_cat' is a}}
- std::tuple_element_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::tuple_element_t' is a}}
- std::tuple_size_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::tuple_size_v' is a}}
- std::type_identity; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::type_identity' is a}}
- std::type_identity_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::type_identity_t' is a}}
- std::type_index; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::type_index' is a}}
- std::type_info; // expected-error {{no member}} expected-note {{maybe try}}
- std::u16streampos; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::u16streampos' is a}}
- std::u16streampos; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::u16streampos' is a}}
- std::u16string; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::u16string' is a}}
- std::u16string_view; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::u16string_view' is a}}
- std::u32streampos; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::u32streampos' is a}}
- std::u32streampos; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::u32streampos' is a}}
- std::u32string; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::u32string' is a}}
- std::u32string_view; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::u32string_view' is a}}
- std::u8streampos; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::u8streampos' is a}}
- std::u8streampos; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::u8streampos' is a}}
- std::u8string; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::u8string' is a}}
- std::u8string_view; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::u8string_view' is a}}
- std::uint16_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::uint16_t' is a}}
- std::uint32_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::uint32_t' is a}}
- std::uint64_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::uint64_t' is a}}
- std::uint8_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::uint8_t' is a}}
- std::uint_fast16_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::uint_fast16_t' is a}}
- std::uint_fast32_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::uint_fast32_t' is a}}
- std::uint_fast64_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::uint_fast64_t' is a}}
- std::uint_fast8_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::uint_fast8_t' is a}}
- std::uint_least16_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::uint_least16_t' is a}}
- std::uint_least32_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::uint_least32_t' is a}}
- std::uint_least64_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::uint_least64_t' is a}}
- std::uint_least8_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::uint_least8_t' is a}}
- std::uintmax_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::uintmax_t' is a}}
- std::uintptr_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::uintptr_t' is a}}
- std::unary_function; // expected-error {{no member}} expected-note {{maybe try}}
- std::unary_negate; // expected-error {{no member}} expected-note {{maybe try}}
- std::uncaught_exception; // expected-error {{no member}} expected-note {{maybe try}}
- std::uncaught_exceptions; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::uncaught_exceptions' is a}}
- std::undeclare_no_pointers; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::undeclare_no_pointers' is a}}
- std::undeclare_reachable; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::undeclare_reachable' is a}}
- std::underflow_error; // expected-error {{no member}} expected-note {{maybe try}}
- std::underlying_type; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::underlying_type' is a}}
- std::underlying_type_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::underlying_type_t' is a}}
- std::unexpect; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::unexpect' is a}}
- std::unexpect_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::unexpect_t' is a}}
- std::unexpected; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::unexpected' is a}}
- std::unexpected_handler; // expected-error {{no member}} expected-note {{maybe try}}
- std::ungetc; // expected-error {{no member}} expected-note {{maybe try}}
- std::ungetwc; // expected-error {{no member}} expected-note {{maybe try}}
- std::uniform_int_distribution; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::uniform_int_distribution' is a}}
- std::uniform_random_bit_generator; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::uniform_random_bit_generator' is a}}
- std::uniform_real_distribution; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::uniform_real_distribution' is a}}
- std::uninitialized_construct_using_allocator; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::uninitialized_construct_using_allocator' is a}}
- std::uninitialized_copy; // expected-error {{no member}} expected-note {{maybe try}}
- std::uninitialized_copy_n; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::uninitialized_copy_n' is a}}
- std::uninitialized_default_construct; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::uninitialized_default_construct' is a}}
- std::uninitialized_default_construct_n; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::uninitialized_default_construct_n' is a}}
- std::uninitialized_fill; // expected-error {{no member}} expected-note {{maybe try}}
- std::uninitialized_fill_n; // expected-error {{no member}} expected-note {{maybe try}}
- std::uninitialized_move; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::uninitialized_move' is a}}
- std::uninitialized_move_n; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::uninitialized_move_n' is a}}
- std::uninitialized_value_construct; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::uninitialized_value_construct' is a}}
- std::uninitialized_value_construct_n; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::uninitialized_value_construct_n' is a}}
- std::unique; // expected-error {{no member}} expected-note {{maybe try}}
- std::unique_copy; // expected-error {{no member}} expected-note {{maybe try}}
- std::unique_lock; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::unique_lock' is a}}
- std::unique_ptr; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::unique_ptr' is a}}
- std::unitbuf; // expected-error {{no member}} expected-note {{maybe try}}
- std::unitbuf; // expected-error {{no member}} expected-note {{maybe try}}
- std::unordered_map; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::unordered_map' is a}}
- std::unordered_multimap; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::unordered_multimap' is a}}
- std::unordered_multiset; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::unordered_multiset' is a}}
- std::unordered_set; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::unordered_set' is a}}
- std::unreachable; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::unreachable' is a}}
- std::unreachable_sentinel; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::unreachable_sentinel' is a}}
- std::unreachable_sentinel_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::unreachable_sentinel_t' is a}}
- std::unsigned_integral; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::unsigned_integral' is a}}
- std::upper_bound; // expected-error {{no member}} expected-note {{maybe try}}
- std::uppercase; // expected-error {{no member}} expected-note {{maybe try}}
- std::uppercase; // expected-error {{no member}} expected-note {{maybe try}}
- std::use_facet; // expected-error {{no member}} expected-note {{maybe try}}
- std::uses_allocator; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::uses_allocator' is a}}
- std::uses_allocator_construction_args; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::uses_allocator_construction_args' is a}}
- std::uses_allocator_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::uses_allocator_v' is a}}
- std::va_list; // expected-error {{no member}} expected-note {{maybe try}}
- std::valarray; // expected-error {{no member}} expected-note {{maybe try}}
- std::variant; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::variant' is a}}
- std::variant_alternative; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::variant_alternative' is a}}
- std::variant_alternative_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::variant_alternative_t' is a}}
- std::variant_npos; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::variant_npos' is a}}
- std::variant_size; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::variant_size' is a}}
- std::variant_size_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::variant_size_v' is a}}
- std::vector; // expected-error {{no member}} expected-note {{maybe try}}
- std::vformat; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::vformat' is a}}
- std::vformat_to; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::vformat_to' is a}}
- std::vfprintf; // expected-error {{no member}} expected-note {{maybe try}}
- std::vfscanf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::vfscanf' is a}}
- std::vfwprintf; // expected-error {{no member}} expected-note {{maybe try}}
- std::vfwscanf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::vfwscanf' is a}}
- std::visit; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::visit' is a}}
- std::visit_format_arg; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::visit_format_arg' is a}}
- std::void_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::void_t' is a}}
- std::vprint_nonunicode; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::vprint_nonunicode' is a}}
- std::vprint_nonunicode_buffered; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::vprint_nonunicode_buffered' is a}}
- std::vprint_unicode; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::vprint_unicode' is a}}
- std::vprint_unicode_buffered; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::vprint_unicode_buffered' is a}}
- std::vprintf; // expected-error {{no member}} expected-note {{maybe try}}
- std::vscanf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::vscanf' is a}}
- std::vsnprintf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::vsnprintf' is a}}
- std::vsprintf; // expected-error {{no member}} expected-note {{maybe try}}
- std::vsscanf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::vsscanf' is a}}
- std::vswprintf; // expected-error {{no member}} expected-note {{maybe try}}
- std::vswscanf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::vswscanf' is a}}
- std::vwprintf; // expected-error {{no member}} expected-note {{maybe try}}
- std::vwscanf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::vwscanf' is a}}
- std::wbuffer_convert; // expected-error {{no member}} expected-note {{maybe try}}
- std::wbuffer_convert; // expected-error {{no member}} expected-note {{maybe try}}
- std::wcerr; // expected-error {{no member}} expected-note {{maybe try}}
- std::wcin; // expected-error {{no member}} expected-note {{maybe try}}
- std::wclog; // expected-error {{no member}} expected-note {{maybe try}}
- std::wcmatch; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::wcmatch' is a}}
- std::wcout; // expected-error {{no member}} expected-note {{maybe try}}
- std::wcregex_iterator; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::wcregex_iterator' is a}}
- std::wcregex_token_iterator; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::wcregex_token_iterator' is a}}
- std::wcrtomb; // expected-error {{no member}} expected-note {{maybe try}}
- std::wcscat; // expected-error {{no member}} expected-note {{maybe try}}
- std::wcschr; // expected-error {{no member}} expected-note {{maybe try}}
- std::wcscmp; // expected-error {{no member}} expected-note {{maybe try}}
- std::wcscoll; // expected-error {{no member}} expected-note {{maybe try}}
- std::wcscpy; // expected-error {{no member}} expected-note {{maybe try}}
- std::wcscspn; // expected-error {{no member}} expected-note {{maybe try}}
- std::wcsftime; // expected-error {{no member}} expected-note {{maybe try}}
- std::wcslen; // expected-error {{no member}} expected-note {{maybe try}}
- std::wcsncat; // expected-error {{no member}} expected-note {{maybe try}}
- std::wcsncmp; // expected-error {{no member}} expected-note {{maybe try}}
- std::wcsncpy; // expected-error {{no member}} expected-note {{maybe try}}
- std::wcspbrk; // expected-error {{no member}} expected-note {{maybe try}}
- std::wcsrchr; // expected-error {{no member}} expected-note {{maybe try}}
- std::wcsrtombs; // expected-error {{no member}} expected-note {{maybe try}}
- std::wcsspn; // expected-error {{no member}} expected-note {{maybe try}}
- std::wcsstr; // expected-error {{no member}} expected-note {{maybe try}}
- std::wcstod; // expected-error {{no member}} expected-note {{maybe try}}
- std::wcstof; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::wcstof' is a}}
- std::wcstoimax; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::wcstoimax' is a}}
- std::wcstok; // expected-error {{no member}} expected-note {{maybe try}}
- std::wcstol; // expected-error {{no member}} expected-note {{maybe try}}
- std::wcstold; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::wcstold' is a}}
- std::wcstoll; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::wcstoll' is a}}
- std::wcstombs; // expected-error {{no member}} expected-note {{maybe try}}
- std::wcstoul; // expected-error {{no member}} expected-note {{maybe try}}
- std::wcstoull; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::wcstoull' is a}}
- std::wcstoumax; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::wcstoumax' is a}}
- std::wcsub_match; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::wcsub_match' is a}}
- std::wcsxfrm; // expected-error {{no member}} expected-note {{maybe try}}
- std::wctob; // expected-error {{no member}} expected-note {{maybe try}}
- std::wctomb; // expected-error {{no member}} expected-note {{maybe try}}
- std::wctrans; // expected-error {{no member}} expected-note {{maybe try}}
- std::wctrans_t; // expected-error {{no member}} expected-note {{maybe try}}
- std::wctype; // expected-error {{no member}} expected-note {{maybe try}}
- std::wctype_t; // expected-error {{no member}} expected-note {{maybe try}}
- std::weak_order; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::weak_order' is a}}
- std::weak_ordering; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::weak_ordering' is a}}
- std::weak_ptr; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::weak_ptr' is a}}
- std::weakly_incrementable; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::weakly_incrementable' is a}}
- std::weibull_distribution; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::weibull_distribution' is a}}
- std::wfilebuf; // expected-error {{no member}} expected-note {{maybe try}}
- std::wfilebuf; // expected-error {{no member}} expected-note {{maybe try}}
- std::wformat_args; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::wformat_args' is a}}
- std::wformat_context; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::wformat_context' is a}}
- std::wformat_parse_context; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::wformat_parse_context' is a}}
- std::wformat_string; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::wformat_string' is a}}
- std::wfstream; // expected-error {{no member}} expected-note {{maybe try}}
- std::wfstream; // expected-error {{no member}} expected-note {{maybe try}}
- std::wifstream; // expected-error {{no member}} expected-note {{maybe try}}
- std::wifstream; // expected-error {{no member}} expected-note {{maybe try}}
- std::wios; // expected-error {{no member}} expected-note {{maybe try}}
- std::wios; // expected-error {{no member}} expected-note {{maybe try}}
- std::wios; // expected-error {{no member}} expected-note {{maybe try}}
- std::wiostream; // expected-error {{no member}} expected-note {{maybe try}}
- std::wiostream; // expected-error {{no member}} expected-note {{maybe try}}
- std::wiostream; // expected-error {{no member}} expected-note {{maybe try}}
- std::wispanstream; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::wispanstream' is a}}
- std::wispanstream; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::wispanstream' is a}}
- std::wistream; // expected-error {{no member}} expected-note {{maybe try}}
- std::wistream; // expected-error {{no member}} expected-note {{maybe try}}
- std::wistream; // expected-error {{no member}} expected-note {{maybe try}}
- std::wistringstream; // expected-error {{no member}} expected-note {{maybe try}}
- std::wistringstream; // expected-error {{no member}} expected-note {{maybe try}}
- std::wmemchr; // expected-error {{no member}} expected-note {{maybe try}}
- std::wmemcmp; // expected-error {{no member}} expected-note {{maybe try}}
- std::wmemcpy; // expected-error {{no member}} expected-note {{maybe try}}
- std::wmemmove; // expected-error {{no member}} expected-note {{maybe try}}
- std::wmemset; // expected-error {{no member}} expected-note {{maybe try}}
- std::wofstream; // expected-error {{no member}} expected-note {{maybe try}}
- std::wofstream; // expected-error {{no member}} expected-note {{maybe try}}
- std::wospanstream; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::wospanstream' is a}}
- std::wospanstream; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::wospanstream' is a}}
- std::wostream; // expected-error {{no member}} expected-note {{maybe try}}
- std::wostream; // expected-error {{no member}} expected-note {{maybe try}}
- std::wostream; // expected-error {{no member}} expected-note {{maybe try}}
- std::wostringstream; // expected-error {{no member}} expected-note {{maybe try}}
- std::wostringstream; // expected-error {{no member}} expected-note {{maybe try}}
- std::wosyncstream; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::wosyncstream' is a}}
- std::wosyncstream; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::wosyncstream' is a}}
- std::wprintf; // expected-error {{no member}} expected-note {{maybe try}}
- std::wregex; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::wregex' is a}}
- std::ws; // expected-error {{no member}} expected-note {{maybe try}}
- std::ws; // expected-error {{no member}} expected-note {{maybe try}}
- std::wscanf; // expected-error {{no member}} expected-note {{maybe try}}
- std::wsmatch; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::wsmatch' is a}}
- std::wspanbuf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::wspanbuf' is a}}
- std::wspanbuf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::wspanbuf' is a}}
- std::wspanstream; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::wspanstream' is a}}
- std::wspanstream; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::wspanstream' is a}}
- std::wsregex_iterator; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::wsregex_iterator' is a}}
- std::wsregex_token_iterator; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::wsregex_token_iterator' is a}}
- std::wssub_match; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::wssub_match' is a}}
- std::wstreambuf; // expected-error {{no member}} expected-note {{maybe try}}
- std::wstreambuf; // expected-error {{no member}} expected-note {{maybe try}}
- std::wstreambuf; // expected-error {{no member}} expected-note {{maybe try}}
- std::wstreampos; // expected-error {{no member}} expected-note {{maybe try}}
- std::wstreampos; // expected-error {{no member}} expected-note {{maybe try}}
- std::wstring; // expected-error {{no member}} expected-note {{maybe try}}
- std::wstring_convert; // expected-error {{no member}} expected-note {{maybe try}}
- std::wstring_convert; // expected-error {{no member}} expected-note {{maybe try}}
- std::wstring_view; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::wstring_view' is a}}
- std::wstringbuf; // expected-error {{no member}} expected-note {{maybe try}}
- std::wstringbuf; // expected-error {{no member}} expected-note {{maybe try}}
- std::wstringstream; // expected-error {{no member}} expected-note {{maybe try}}
- std::wstringstream; // expected-error {{no member}} expected-note {{maybe try}}
- std::wsyncbuf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::wsyncbuf' is a}}
- std::wsyncbuf; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::wsyncbuf' is a}}
- std::yocto; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::yocto' is a}}
- std::yotta; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::yotta' is a}}
- std::zepto; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::zepto' is a}}
- std::zetta; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::zetta' is a}}
- std::chrono::April; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::April' is a}}
- std::chrono::August; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::August' is a}}
- std::chrono::December; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::December' is a}}
- std::chrono::February; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::February' is a}}
- std::chrono::Friday; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::Friday' is a}}
- std::chrono::January; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::January' is a}}
- std::chrono::July; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::July' is a}}
- std::chrono::June; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::June' is a}}
- std::chrono::March; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::March' is a}}
- std::chrono::May; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::May' is a}}
- std::chrono::Monday; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::Monday' is a}}
- std::chrono::November; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::November' is a}}
- std::chrono::October; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::October' is a}}
- std::chrono::Saturday; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::Saturday' is a}}
- std::chrono::September; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::September' is a}}
- std::chrono::Sunday; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::Sunday' is a}}
- std::chrono::Thursday; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::Thursday' is a}}
- std::chrono::Tuesday; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::Tuesday' is a}}
- std::chrono::Wednesday; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::Wednesday' is a}}
- std::chrono::abs; // expected-error {{no member}} expected-note {{maybe try}}
- std::chrono::ambiguous_local_time; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::ambiguous_local_time' is a}}
- std::chrono::ceil; // expected-error {{no member}} expected-note {{maybe try}}
- std::chrono::choose; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::choose' is a}}
- std::chrono::clock_cast; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::clock_cast' is a}}
- std::chrono::clock_time_conversion; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::clock_time_conversion' is a}}
- std::chrono::current_zone; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::current_zone' is a}}
- std::chrono::day; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::day' is a}}
- std::chrono::duration; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::duration' is a}}
- std::chrono::duration_cast; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::duration_cast' is a}}
- std::chrono::duration_values; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::duration_values' is a}}
- std::chrono::file_clock; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::file_clock' is a}}
- std::chrono::file_seconds; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::file_seconds' is a}}
- std::chrono::file_time; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::file_time' is a}}
- std::chrono::floor; // expected-error {{no member}} expected-note {{maybe try}}
- std::chrono::from_stream; // expected-error {{no member}} expected-note {{maybe try}}
- std::chrono::get_leap_second_info; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::get_leap_second_info' is a}}
- std::chrono::gps_clock; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::gps_clock' is a}}
- std::chrono::gps_seconds; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::gps_seconds' is a}}
- std::chrono::gps_time; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::gps_time' is a}}
- std::chrono::hh_mm_ss; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::hh_mm_ss' is a}}
- std::chrono::high_resolution_clock; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::high_resolution_clock' is a}}
- std::chrono::hours; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::hours' is a}}
- std::chrono::is_am; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::is_am' is a}}
- std::chrono::is_clock; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::is_clock' is a}}
- std::chrono::is_clock_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::is_clock_v' is a}}
- std::chrono::is_pm; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::is_pm' is a}}
- std::chrono::last; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::last' is a}}
- std::chrono::last_spec; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::last_spec' is a}}
- std::chrono::leap_second; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::leap_second' is a}}
- std::chrono::leap_second_info; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::leap_second_info' is a}}
- std::chrono::local_info; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::local_info' is a}}
- std::chrono::local_seconds; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::local_seconds' is a}}
- std::chrono::local_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::local_t' is a}}
- std::chrono::local_time; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::local_time' is a}}
- std::chrono::local_time_format; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::local_time_format' is a}}
- std::chrono::locate_zone; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::locate_zone' is a}}
- std::chrono::make12; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::make12' is a}}
- std::chrono::make24; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::make24' is a}}
- std::chrono::microseconds; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::microseconds' is a}}
- std::chrono::milliseconds; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::milliseconds' is a}}
- std::chrono::minutes; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::minutes' is a}}
- std::chrono::month; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::month' is a}}
- std::chrono::month_day; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::month_day' is a}}
- std::chrono::month_day_last; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::month_day_last' is a}}
- std::chrono::month_weekday; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::month_weekday' is a}}
- std::chrono::month_weekday_last; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::month_weekday_last' is a}}
- std::chrono::nanoseconds; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::nanoseconds' is a}}
- std::chrono::nonexistent_local_time; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::nonexistent_local_time' is a}}
- std::chrono::parse; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::parse' is a}}
- std::chrono::round; // expected-error {{no member}} expected-note {{maybe try}}
- std::chrono::seconds; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::seconds' is a}}
- std::chrono::steady_clock; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::steady_clock' is a}}
- std::chrono::sys_days; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::sys_days' is a}}
- std::chrono::sys_info; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::sys_info' is a}}
- std::chrono::sys_seconds; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::sys_seconds' is a}}
- std::chrono::sys_time; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::sys_time' is a}}
- std::chrono::system_clock; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::system_clock' is a}}
- std::chrono::tai_clock; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::tai_clock' is a}}
- std::chrono::tai_seconds; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::tai_seconds' is a}}
- std::chrono::tai_time; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::tai_time' is a}}
- std::chrono::time_point; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::time_point' is a}}
- std::chrono::time_point_cast; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::time_point_cast' is a}}
- std::chrono::time_zone; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::time_zone' is a}}
- std::chrono::time_zone_link; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::time_zone_link' is a}}
- std::chrono::treat_as_floating_point; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::treat_as_floating_point' is a}}
- std::chrono::treat_as_floating_point_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::treat_as_floating_point_v' is a}}
- std::chrono::tzdb; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::tzdb' is a}}
- std::chrono::tzdb_list; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::tzdb_list' is a}}
- std::chrono::utc_clock; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::utc_clock' is a}}
- std::chrono::utc_seconds; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::utc_seconds' is a}}
- std::chrono::utc_time; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::utc_time' is a}}
- std::chrono::weekday; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::weekday' is a}}
- std::chrono::weekday_indexed; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::weekday_indexed' is a}}
- std::chrono::weekday_last; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::weekday_last' is a}}
- std::chrono::year; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::year' is a}}
- std::chrono::year_month; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::year_month' is a}}
- std::chrono::year_month_day; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::year_month_day' is a}}
- std::chrono::year_month_day_last; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::year_month_day_last' is a}}
- std::chrono::year_month_weekday; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::year_month_weekday' is a}}
- std::chrono::year_month_weekday_last; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::year_month_weekday_last' is a}}
- std::chrono::zoned_seconds; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::zoned_seconds' is a}}
- std::chrono::zoned_time; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::zoned_time' is a}}
- std::chrono::zoned_traits; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::chrono::zoned_traits' is a}}
- std::execution::par; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::execution::par' is a}}
- std::execution::par_unseq; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::execution::par_unseq' is a}}
- std::execution::parallel_policy; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::execution::parallel_policy' is a}}
- std::execution::parallel_unsequenced_policy; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::execution::parallel_unsequenced_policy' is a}}
- std::execution::seq; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::execution::seq' is a}}
- std::execution::sequenced_policy; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::execution::sequenced_policy' is a}}
- std::execution::unseq; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::execution::unseq' is a}}
- std::execution::unsequenced_policy; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::execution::unsequenced_policy' is a}}
- std::filesystem::absolute; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::filesystem::absolute' is a}}
- std::filesystem::begin; // expected-error {{no member}} expected-note {{maybe try}}
- std::filesystem::canonical; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::filesystem::canonical' is a}}
- std::filesystem::copy; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::filesystem::copy' is a}}
- std::filesystem::copy_file; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::filesystem::copy_file' is a}}
- std::filesystem::copy_options; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::filesystem::copy_options' is a}}
- std::filesystem::copy_symlink; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::filesystem::copy_symlink' is a}}
- std::filesystem::create_directories; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::filesystem::create_directories' is a}}
- std::filesystem::create_directory; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::filesystem::create_directory' is a}}
- std::filesystem::create_directory_symlink; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::filesystem::create_directory_symlink' is a}}
- std::filesystem::create_hard_link; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::filesystem::create_hard_link' is a}}
- std::filesystem::create_symlink; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::filesystem::create_symlink' is a}}
- std::filesystem::current_path; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::filesystem::current_path' is a}}
- std::filesystem::directory_entry; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::filesystem::directory_entry' is a}}
- std::filesystem::directory_iterator; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::filesystem::directory_iterator' is a}}
- std::filesystem::directory_options; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::filesystem::directory_options' is a}}
- std::filesystem::end; // expected-error {{no member}} expected-note {{maybe try}}
- std::filesystem::equivalent; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::filesystem::equivalent' is a}}
- std::filesystem::exists; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::filesystem::exists' is a}}
- std::filesystem::file_size; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::filesystem::file_size' is a}}
- std::filesystem::file_status; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::filesystem::file_status' is a}}
- std::filesystem::file_time_type; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::filesystem::file_time_type' is a}}
- std::filesystem::file_type; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::filesystem::file_type' is a}}
- std::filesystem::filesystem_error; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::filesystem::filesystem_error' is a}}
- std::filesystem::hard_link_count; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::filesystem::hard_link_count' is a}}
- std::filesystem::hash_value; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::filesystem::hash_value' is a}}
- std::filesystem::is_block_file; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::filesystem::is_block_file' is a}}
- std::filesystem::is_character_file; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::filesystem::is_character_file' is a}}
- std::filesystem::is_directory; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::filesystem::is_directory' is a}}
- std::filesystem::is_empty; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::filesystem::is_empty' is a}}
- std::filesystem::is_fifo; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::filesystem::is_fifo' is a}}
- std::filesystem::is_other; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::filesystem::is_other' is a}}
- std::filesystem::is_regular_file; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::filesystem::is_regular_file' is a}}
- std::filesystem::is_socket; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::filesystem::is_socket' is a}}
- std::filesystem::is_symlink; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::filesystem::is_symlink' is a}}
- std::filesystem::last_write_time; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::filesystem::last_write_time' is a}}
- std::filesystem::path; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::filesystem::path' is a}}
- std::filesystem::perm_options; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::filesystem::perm_options' is a}}
- std::filesystem::permissions; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::filesystem::permissions' is a}}
- std::filesystem::perms; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::filesystem::perms' is a}}
- std::filesystem::proximate; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::filesystem::proximate' is a}}
- std::filesystem::read_symlink; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::filesystem::read_symlink' is a}}
- std::filesystem::recursive_directory_iterator; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::filesystem::recursive_directory_iterator' is a}}
- std::filesystem::relative; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::filesystem::relative' is a}}
- std::filesystem::remove; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::filesystem::remove' is a}}
- std::filesystem::remove_all; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::filesystem::remove_all' is a}}
- std::filesystem::rename; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::filesystem::rename' is a}}
- std::filesystem::resize_file; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::filesystem::resize_file' is a}}
- std::filesystem::space; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::filesystem::space' is a}}
- std::filesystem::space_info; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::filesystem::space_info' is a}}
- std::filesystem::status; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::filesystem::status' is a}}
- std::filesystem::status_known; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::filesystem::status_known' is a}}
- std::filesystem::symlink_status; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::filesystem::symlink_status' is a}}
- std::filesystem::temp_directory_path; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::filesystem::temp_directory_path' is a}}
- std::filesystem::u8path; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::filesystem::u8path' is a}}
- std::filesystem::weakly_canonical; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::filesystem::weakly_canonical' is a}}
- std::numbers::e; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::numbers::e' is a}}
- std::numbers::e_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::numbers::e_v' is a}}
- std::numbers::egamma; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::numbers::egamma' is a}}
- std::numbers::egamma_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::numbers::egamma_v' is a}}
- std::numbers::inv_pi; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::numbers::inv_pi' is a}}
- std::numbers::inv_pi_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::numbers::inv_pi_v' is a}}
- std::numbers::inv_sqrt3; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::numbers::inv_sqrt3' is a}}
- std::numbers::inv_sqrt3_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::numbers::inv_sqrt3_v' is a}}
- std::numbers::inv_sqrtpi; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::numbers::inv_sqrtpi' is a}}
- std::numbers::inv_sqrtpi_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::numbers::inv_sqrtpi_v' is a}}
- std::numbers::ln10; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::numbers::ln10' is a}}
- std::numbers::ln10_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::numbers::ln10_v' is a}}
- std::numbers::ln2; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::numbers::ln2' is a}}
- std::numbers::ln2_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::numbers::ln2_v' is a}}
- std::numbers::log10e; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::numbers::log10e' is a}}
- std::numbers::log10e_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::numbers::log10e_v' is a}}
- std::numbers::log2e; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::numbers::log2e' is a}}
- std::numbers::log2e_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::numbers::log2e_v' is a}}
- std::numbers::phi; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::numbers::phi' is a}}
- std::numbers::phi_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::numbers::phi_v' is a}}
- std::numbers::pi; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::numbers::pi' is a}}
- std::numbers::pi_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::numbers::pi_v' is a}}
- std::numbers::sqrt2; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::numbers::sqrt2' is a}}
- std::numbers::sqrt2_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::numbers::sqrt2_v' is a}}
- std::numbers::sqrt3; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::numbers::sqrt3' is a}}
- std::numbers::sqrt3_v; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::numbers::sqrt3_v' is a}}
- std::pmr::basic_string; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::pmr::basic_string' is a}}
- std::pmr::cmatch; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::pmr::cmatch' is a}}
- std::pmr::deque; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::pmr::deque' is a}}
- std::pmr::forward_list; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::pmr::forward_list' is a}}
- std::pmr::get_default_resource; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::pmr::get_default_resource' is a}}
- std::pmr::list; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::pmr::list' is a}}
- std::pmr::map; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::pmr::map' is a}}
- std::pmr::match_results; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::pmr::match_results' is a}}
- std::pmr::memory_resource; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::pmr::memory_resource' is a}}
- std::pmr::monotonic_buffer_resource; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::pmr::monotonic_buffer_resource' is a}}
- std::pmr::multimap; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::pmr::multimap' is a}}
- std::pmr::multiset; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::pmr::multiset' is a}}
- std::pmr::new_delete_resource; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::pmr::new_delete_resource' is a}}
- std::pmr::null_memory_resource; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::pmr::null_memory_resource' is a}}
- std::pmr::polymorphic_allocator; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::pmr::polymorphic_allocator' is a}}
- std::pmr::pool_options; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::pmr::pool_options' is a}}
- std::pmr::set; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::pmr::set' is a}}
- std::pmr::set_default_resource; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::pmr::set_default_resource' is a}}
- std::pmr::smatch; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::pmr::smatch' is a}}
- std::pmr::stacktrace; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::pmr::stacktrace' is a}}
- std::pmr::string; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::pmr::string' is a}}
- std::pmr::synchronized_pool_resource; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::pmr::synchronized_pool_resource' is a}}
- std::pmr::u16string; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::pmr::u16string' is a}}
- std::pmr::u32string; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::pmr::u32string' is a}}
- std::pmr::u8string; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::pmr::u8string' is a}}
- std::pmr::unordered_map; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::pmr::unordered_map' is a}}
- std::pmr::unordered_multimap; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::pmr::unordered_multimap' is a}}
- std::pmr::unordered_multiset; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::pmr::unordered_multiset' is a}}
- std::pmr::unordered_set; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::pmr::unordered_set' is a}}
- std::pmr::unsynchronized_pool_resource; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::pmr::unsynchronized_pool_resource' is a}}
- std::pmr::vector; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::pmr::vector' is a}}
- std::pmr::wcmatch; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::pmr::wcmatch' is a}}
- std::pmr::wsmatch; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::pmr::wsmatch' is a}}
- std::pmr::wstring; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::pmr::wstring' is a}}
- std::ranges::adjacent_find; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::adjacent_find' is a}}
- std::ranges::adjacent_transform_view; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::adjacent_transform_view' is a}}
- std::ranges::adjacent_view; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::adjacent_view' is a}}
- std::ranges::advance; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::advance' is a}}
- std::ranges::all_of; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::all_of' is a}}
- std::ranges::any_of; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::any_of' is a}}
- std::ranges::as_const_view; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::as_const_view' is a}}
- std::ranges::as_rvalue_view; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::as_rvalue_view' is a}}
- std::ranges::basic_istream_view; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::basic_istream_view' is a}}
- std::ranges::bidirectional_range; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::bidirectional_range' is a}}
- std::ranges::binary_transform_result; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::binary_transform_result' is a}}
- std::ranges::borrowed_iterator_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::borrowed_iterator_t' is a}}
- std::ranges::borrowed_range; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::borrowed_range' is a}}
- std::ranges::borrowed_subrange_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::borrowed_subrange_t' is a}}
- std::ranges::cartesian_product_view; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::cartesian_product_view' is a}}
- std::ranges::chunk_by_view; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::chunk_by_view' is a}}
- std::ranges::chunk_view; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::chunk_view' is a}}
- std::ranges::clamp; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::clamp' is a}}
- std::ranges::common_range; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::common_range' is a}}
- std::ranges::common_view; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::common_view' is a}}
- std::ranges::concat_view; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::concat_view' is a}}
- std::ranges::const_iterator_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::const_iterator_t' is a}}
- std::ranges::constant_range; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::constant_range' is a}}
- std::ranges::construct_at; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::construct_at' is a}}
- std::ranges::contains; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::contains' is a}}
- std::ranges::contains_subrange; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::contains_subrange' is a}}
- std::ranges::contiguous_range; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::contiguous_range' is a}}
- std::ranges::copy; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::copy' is a}}
- std::ranges::copy_backward; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::copy_backward' is a}}
- std::ranges::copy_backward_result; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::copy_backward_result' is a}}
- std::ranges::copy_if; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::copy_if' is a}}
- std::ranges::copy_if_result; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::copy_if_result' is a}}
- std::ranges::copy_n; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::copy_n' is a}}
- std::ranges::copy_n_result; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::copy_n_result' is a}}
- std::ranges::copy_result; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::copy_result' is a}}
- std::ranges::count; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::count' is a}}
- std::ranges::count_if; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::count_if' is a}}
- std::ranges::dangling; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::dangling' is a}}
- std::ranges::destroy; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::destroy' is a}}
- std::ranges::destroy_at; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::destroy_at' is a}}
- std::ranges::destroy_n; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::destroy_n' is a}}
- std::ranges::disable_sized_range; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::disable_sized_range' is a}}
- std::ranges::distance; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::distance' is a}}
- std::ranges::drop_view; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::drop_view' is a}}
- std::ranges::drop_while_view; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::drop_while_view' is a}}
- std::ranges::elements_of; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::elements_of' is a}}
- std::ranges::elements_view; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::elements_view' is a}}
- std::ranges::empty_view; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::empty_view' is a}}
- std::ranges::enable_borrowed_range; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::enable_borrowed_range' is a}}
- std::ranges::enable_view; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::enable_view' is a}}
- std::ranges::ends_with; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::ends_with' is a}}
- std::ranges::enumerate_view; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::enumerate_view' is a}}
- std::ranges::equal; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::equal' is a}}
- std::ranges::fill; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::fill' is a}}
- std::ranges::fill_n; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::fill_n' is a}}
- std::ranges::filter_view; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::filter_view' is a}}
- std::ranges::find; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::find' is a}}
- std::ranges::find_end; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::find_end' is a}}
- std::ranges::find_first_of; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::find_first_of' is a}}
- std::ranges::find_if; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::find_if' is a}}
- std::ranges::find_if_not; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::find_if_not' is a}}
- std::ranges::find_last; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::find_last' is a}}
- std::ranges::find_last_if; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::find_last_if' is a}}
- std::ranges::find_last_if_not; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::find_last_if_not' is a}}
- std::ranges::fold_left; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::fold_left' is a}}
- std::ranges::fold_left_first; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::fold_left_first' is a}}
- std::ranges::fold_left_first_with_iter; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::fold_left_first_with_iter' is a}}
- std::ranges::fold_left_with_iter; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::fold_left_with_iter' is a}}
- std::ranges::fold_right; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::fold_right' is a}}
- std::ranges::fold_right_last; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::fold_right_last' is a}}
- std::ranges::for_each; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::for_each' is a}}
- std::ranges::for_each_n; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::for_each_n' is a}}
- std::ranges::for_each_n_result; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::for_each_n_result' is a}}
- std::ranges::for_each_result; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::for_each_result' is a}}
- std::ranges::forward_range; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::forward_range' is a}}
- std::ranges::generate; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::generate' is a}}
- std::ranges::generate_n; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::generate_n' is a}}
- std::ranges::get; // expected-error {{no member}} expected-note {{maybe try}}
- std::ranges::greater; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::greater' is a}}
- std::ranges::greater_equal; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::greater_equal' is a}}
- std::ranges::in_found_result; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::in_found_result' is a}}
- std::ranges::in_fun_result; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::in_fun_result' is a}}
- std::ranges::in_in_out_result; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::in_in_out_result' is a}}
- std::ranges::in_in_result; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::in_in_result' is a}}
- std::ranges::in_out_out_result; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::in_out_out_result' is a}}
- std::ranges::in_out_result; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::in_out_result' is a}}
- std::ranges::in_value_result; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::in_value_result' is a}}
- std::ranges::includes; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::includes' is a}}
- std::ranges::inplace_merge; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::inplace_merge' is a}}
- std::ranges::input_range; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::input_range' is a}}
- std::ranges::iota; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::iota' is a}}
- std::ranges::iota_result; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::iota_result' is a}}
- std::ranges::iota_view; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::iota_view' is a}}
- std::ranges::is_heap; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::is_heap' is a}}
- std::ranges::is_heap_until; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::is_heap_until' is a}}
- std::ranges::is_partitioned; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::is_partitioned' is a}}
- std::ranges::is_permutation; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::is_permutation' is a}}
- std::ranges::is_sorted; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::is_sorted' is a}}
- std::ranges::is_sorted_until; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::is_sorted_until' is a}}
- std::ranges::istream_view; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::istream_view' is a}}
- std::ranges::iter_move; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::iter_move' is a}}
- std::ranges::iter_swap; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::iter_swap' is a}}
- std::ranges::iterator_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::iterator_t' is a}}
- std::ranges::join_view; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::join_view' is a}}
- std::ranges::join_with_view; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::join_with_view' is a}}
- std::ranges::keys_view; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::keys_view' is a}}
- std::ranges::lazy_split_view; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::lazy_split_view' is a}}
- std::ranges::less; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::less' is a}}
- std::ranges::less_equal; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::less_equal' is a}}
- std::ranges::lexicographical_compare; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::lexicographical_compare' is a}}
- std::ranges::make_heap; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::make_heap' is a}}
- std::ranges::max_element; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::max_element' is a}}
- std::ranges::merge; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::merge' is a}}
- std::ranges::merge_result; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::merge_result' is a}}
- std::ranges::min; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::min' is a}}
- std::ranges::min_element; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::min_element' is a}}
- std::ranges::min_max_result; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::min_max_result' is a}}
- std::ranges::minmax; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::minmax' is a}}
- std::ranges::minmax_element; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::minmax_element' is a}}
- std::ranges::minmax_element_result; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::minmax_element_result' is a}}
- std::ranges::minmax_result; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::minmax_result' is a}}
- std::ranges::mismatch; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::mismatch' is a}}
- std::ranges::mismatch_result; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::mismatch_result' is a}}
- std::ranges::move; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::move' is a}}
- std::ranges::move_backward; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::move_backward' is a}}
- std::ranges::move_backward_result; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::move_backward_result' is a}}
- std::ranges::move_result; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::move_result' is a}}
- std::ranges::next; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::next' is a}}
- std::ranges::next_permutation; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::next_permutation' is a}}
- std::ranges::next_permutation_result; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::next_permutation_result' is a}}
- std::ranges::none_of; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::none_of' is a}}
- std::ranges::not_equal_to; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::not_equal_to' is a}}
- std::ranges::nth_element; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::nth_element' is a}}
- std::ranges::out_value_result; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::out_value_result' is a}}
- std::ranges::output_range; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::output_range' is a}}
- std::ranges::owning_view; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::owning_view' is a}}
- std::ranges::partial_sort; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::partial_sort' is a}}
- std::ranges::partial_sort_copy; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::partial_sort_copy' is a}}
- std::ranges::partial_sort_copy_result; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::partial_sort_copy_result' is a}}
- std::ranges::partition; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::partition' is a}}
- std::ranges::partition_copy; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::partition_copy' is a}}
- std::ranges::partition_copy_result; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::partition_copy_result' is a}}
- std::ranges::partition_point; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::partition_point' is a}}
- std::ranges::pop_heap; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::pop_heap' is a}}
- std::ranges::prev; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::prev' is a}}
- std::ranges::prev_permutation; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::prev_permutation' is a}}
- std::ranges::prev_permutation_result; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::prev_permutation_result' is a}}
- std::ranges::push_heap; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::push_heap' is a}}
- std::ranges::random_access_range; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::random_access_range' is a}}
- std::ranges::range; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::range' is a}}
- std::ranges::range_adaptor_closure; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::range_adaptor_closure' is a}}
- std::ranges::range_const_reference_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::range_const_reference_t' is a}}
- std::ranges::range_difference_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::range_difference_t' is a}}
- std::ranges::range_reference_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::range_reference_t' is a}}
- std::ranges::range_rvalue_reference_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::range_rvalue_reference_t' is a}}
- std::ranges::range_size_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::range_size_t' is a}}
- std::ranges::range_value_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::range_value_t' is a}}
- std::ranges::ref_view; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::ref_view' is a}}
- std::ranges::remove; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::remove' is a}}
- std::ranges::remove_copy; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::remove_copy' is a}}
- std::ranges::remove_copy_if; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::remove_copy_if' is a}}
- std::ranges::remove_copy_if_result; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::remove_copy_if_result' is a}}
- std::ranges::remove_copy_result; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::remove_copy_result' is a}}
- std::ranges::remove_if; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::remove_if' is a}}
- std::ranges::repeat_view; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::repeat_view' is a}}
- std::ranges::replace; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::replace' is a}}
- std::ranges::replace_copy; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::replace_copy' is a}}
- std::ranges::replace_copy_if; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::replace_copy_if' is a}}
- std::ranges::replace_copy_if_result; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::replace_copy_if_result' is a}}
- std::ranges::replace_copy_result; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::replace_copy_result' is a}}
- std::ranges::replace_if; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::replace_if' is a}}
- std::ranges::reverse; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::reverse' is a}}
- std::ranges::reverse_copy; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::reverse_copy' is a}}
- std::ranges::reverse_copy_result; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::reverse_copy_result' is a}}
- std::ranges::reverse_view; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::reverse_view' is a}}
- std::ranges::rotate; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::rotate' is a}}
- std::ranges::rotate_copy; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::rotate_copy' is a}}
- std::ranges::rotate_copy_result; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::rotate_copy_result' is a}}
- std::ranges::sample; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::sample' is a}}
- std::ranges::search; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::search' is a}}
- std::ranges::search_n; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::search_n' is a}}
- std::ranges::sentinel_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::sentinel_t' is a}}
- std::ranges::set_difference; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::set_difference' is a}}
- std::ranges::set_difference_result; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::set_difference_result' is a}}
- std::ranges::set_intersection; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::set_intersection' is a}}
- std::ranges::set_intersection_result; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::set_intersection_result' is a}}
- std::ranges::set_symmetric_difference; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::set_symmetric_difference' is a}}
- std::ranges::set_symmetric_difference_result; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::set_symmetric_difference_result' is a}}
- std::ranges::set_union; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::set_union' is a}}
- std::ranges::set_union_result; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::set_union_result' is a}}
- std::ranges::shift_left; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::shift_left' is a}}
- std::ranges::shift_right; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::shift_right' is a}}
- std::ranges::shuffle; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::shuffle' is a}}
- std::ranges::single_view; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::single_view' is a}}
- std::ranges::sized_range; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::sized_range' is a}}
- std::ranges::slide_view; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::slide_view' is a}}
- std::ranges::sort; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::sort' is a}}
- std::ranges::sort_heap; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::sort_heap' is a}}
- std::ranges::split_view; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::split_view' is a}}
- std::ranges::stable_partition; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::stable_partition' is a}}
- std::ranges::stable_sort; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::stable_sort' is a}}
- std::ranges::starts_with; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::starts_with' is a}}
- std::ranges::stride_view; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::stride_view' is a}}
- std::ranges::subrange; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::subrange' is a}}
- std::ranges::subrange_kind; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::subrange_kind' is a}}
- std::ranges::swap; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::swap' is a}}
- std::ranges::swap_ranges; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::swap_ranges' is a}}
- std::ranges::swap_ranges_result; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::swap_ranges_result' is a}}
- std::ranges::take_view; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::take_view' is a}}
- std::ranges::take_while_view; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::take_while_view' is a}}
- std::ranges::to; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::to' is a}}
- std::ranges::transform; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::transform' is a}}
- std::ranges::transform_view; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::transform_view' is a}}
- std::ranges::unary_transform_result; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::unary_transform_result' is a}}
- std::ranges::uninitialized_copy; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::uninitialized_copy' is a}}
- std::ranges::uninitialized_copy_n; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::uninitialized_copy_n' is a}}
- std::ranges::uninitialized_copy_n_result; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::uninitialized_copy_n_result' is a}}
- std::ranges::uninitialized_copy_result; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::uninitialized_copy_result' is a}}
- std::ranges::uninitialized_default_construct; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::uninitialized_default_construct' is a}}
- std::ranges::uninitialized_default_construct_n; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::uninitialized_default_construct_n' is a}}
- std::ranges::uninitialized_fill; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::uninitialized_fill' is a}}
- std::ranges::uninitialized_fill_n; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::uninitialized_fill_n' is a}}
- std::ranges::uninitialized_move; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::uninitialized_move' is a}}
- std::ranges::uninitialized_move_n; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::uninitialized_move_n' is a}}
- std::ranges::uninitialized_move_n_result; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::uninitialized_move_n_result' is a}}
- std::ranges::uninitialized_move_result; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::uninitialized_move_result' is a}}
- std::ranges::uninitialized_value_construct; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::uninitialized_value_construct' is a}}
- std::ranges::uninitialized_value_construct_n; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::uninitialized_value_construct_n' is a}}
- std::ranges::unique; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::unique' is a}}
- std::ranges::unique_copy; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::unique_copy' is a}}
- std::ranges::unique_copy_result; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::unique_copy_result' is a}}
- std::ranges::values_view; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::values_view' is a}}
- std::ranges::view; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::view' is a}}
- std::ranges::view_interface; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::view_interface' is a}}
- std::ranges::viewable_range; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::viewable_range' is a}}
- std::ranges::wistream_view; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::wistream_view' is a}}
- std::ranges::zip_transform_view; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::zip_transform_view' is a}}
- std::ranges::zip_view; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::zip_view' is a}}
- std::ranges::views::adjacent; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::views::adjacent' is a}}
- std::ranges::views::adjacent_transform; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::views::adjacent_transform' is a}}
- std::ranges::views::all; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::views::all' is a}}
- std::ranges::views::all_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::views::all_t' is a}}
- std::ranges::views::as_const; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::views::as_const' is a}}
- std::ranges::views::as_rvalue; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::views::as_rvalue' is a}}
- std::ranges::views::cartesian_product; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::views::cartesian_product' is a}}
- std::ranges::views::chunk; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::views::chunk' is a}}
- std::ranges::views::chunk_by; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::views::chunk_by' is a}}
- std::ranges::views::common; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::views::common' is a}}
- std::ranges::views::concat; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::views::concat' is a}}
- std::ranges::views::counted; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::views::counted' is a}}
- std::ranges::views::drop; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::views::drop' is a}}
- std::ranges::views::drop_while; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::views::drop_while' is a}}
- std::ranges::views::elements; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::views::elements' is a}}
- std::ranges::views::empty; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::views::empty' is a}}
- std::ranges::views::enumerate; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::views::enumerate' is a}}
- std::ranges::views::filter; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::views::filter' is a}}
- std::ranges::views::iota; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::views::iota' is a}}
- std::ranges::views::istream; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::views::istream' is a}}
- std::ranges::views::istream; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::views::istream' is a}}
- std::ranges::views::join; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::views::join' is a}}
- std::ranges::views::join_with; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::views::join_with' is a}}
- std::ranges::views::keys; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::views::keys' is a}}
- std::ranges::views::lazy_split; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::views::lazy_split' is a}}
- std::ranges::views::pairwise; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::views::pairwise' is a}}
- std::ranges::views::pairwise_transform; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::views::pairwise_transform' is a}}
- std::ranges::views::repeat; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::views::repeat' is a}}
- std::ranges::views::reverse; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::views::reverse' is a}}
- std::ranges::views::single; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::views::single' is a}}
- std::ranges::views::slide; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::views::slide' is a}}
- std::ranges::views::split; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::views::split' is a}}
- std::ranges::views::stride; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::views::stride' is a}}
- std::ranges::views::take; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::views::take' is a}}
- std::ranges::views::take_while; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::views::take_while' is a}}
- std::ranges::views::transform; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::views::transform' is a}}
- std::ranges::views::values; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::views::values' is a}}
- std::ranges::views::zip; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::views::zip' is a}}
- std::ranges::views::zip_transform; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::ranges::views::zip_transform' is a}}
- std::regex_constants::ECMAScript; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::regex_constants::ECMAScript' is a}}
- std::regex_constants::awk; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::regex_constants::awk' is a}}
- std::regex_constants::basic; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::regex_constants::basic' is a}}
- std::regex_constants::collate; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::regex_constants::collate' is a}}
- std::regex_constants::egrep; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::regex_constants::egrep' is a}}
- std::regex_constants::error_backref; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::regex_constants::error_backref' is a}}
- std::regex_constants::error_badbrace; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::regex_constants::error_badbrace' is a}}
- std::regex_constants::error_badrepeat; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::regex_constants::error_badrepeat' is a}}
- std::regex_constants::error_brace; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::regex_constants::error_brace' is a}}
- std::regex_constants::error_brack; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::regex_constants::error_brack' is a}}
- std::regex_constants::error_collate; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::regex_constants::error_collate' is a}}
- std::regex_constants::error_complexity; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::regex_constants::error_complexity' is a}}
- std::regex_constants::error_ctype; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::regex_constants::error_ctype' is a}}
- std::regex_constants::error_escape; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::regex_constants::error_escape' is a}}
- std::regex_constants::error_paren; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::regex_constants::error_paren' is a}}
- std::regex_constants::error_range; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::regex_constants::error_range' is a}}
- std::regex_constants::error_space; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::regex_constants::error_space' is a}}
- std::regex_constants::error_stack; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::regex_constants::error_stack' is a}}
- std::regex_constants::error_type; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::regex_constants::error_type' is a}}
- std::regex_constants::extended; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::regex_constants::extended' is a}}
- std::regex_constants::format_default; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::regex_constants::format_default' is a}}
- std::regex_constants::format_first_only; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::regex_constants::format_first_only' is a}}
- std::regex_constants::format_no_copy; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::regex_constants::format_no_copy' is a}}
- std::regex_constants::format_sed; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::regex_constants::format_sed' is a}}
- std::regex_constants::grep; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::regex_constants::grep' is a}}
- std::regex_constants::icase; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::regex_constants::icase' is a}}
- std::regex_constants::match_any; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::regex_constants::match_any' is a}}
- std::regex_constants::match_continuous; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::regex_constants::match_continuous' is a}}
- std::regex_constants::match_default; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::regex_constants::match_default' is a}}
- std::regex_constants::match_flag_type; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::regex_constants::match_flag_type' is a}}
- std::regex_constants::match_not_bol; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::regex_constants::match_not_bol' is a}}
- std::regex_constants::match_not_bow; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::regex_constants::match_not_bow' is a}}
- std::regex_constants::match_not_eol; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::regex_constants::match_not_eol' is a}}
- std::regex_constants::match_not_eow; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::regex_constants::match_not_eow' is a}}
- std::regex_constants::match_not_null; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::regex_constants::match_not_null' is a}}
- std::regex_constants::match_prev_avail; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::regex_constants::match_prev_avail' is a}}
- std::regex_constants::multiline; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::regex_constants::multiline' is a}}
- std::regex_constants::nosubs; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::regex_constants::nosubs' is a}}
- std::regex_constants::optimize; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::regex_constants::optimize' is a}}
- std::regex_constants::syntax_option_type; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::regex_constants::syntax_option_type' is a}}
- std::this_thread::get_id; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::this_thread::get_id' is a}}
- std::this_thread::sleep_for; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::this_thread::sleep_for' is a}}
- std::this_thread::sleep_until; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::this_thread::sleep_until' is a}}
- std::this_thread::yield; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::this_thread::yield' is a}}
- std::views::adjacent; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::views::adjacent' is a}}
- std::views::adjacent_transform; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::views::adjacent_transform' is a}}
- std::views::all; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::views::all' is a}}
- std::views::all_t; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::views::all_t' is a}}
- std::views::as_const; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::views::as_const' is a}}
- std::views::as_rvalue; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::views::as_rvalue' is a}}
- std::views::cartesian_product; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::views::cartesian_product' is a}}
- std::views::chunk; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::views::chunk' is a}}
- std::views::chunk_by; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::views::chunk_by' is a}}
- std::views::common; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::views::common' is a}}
- std::views::concat; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::views::concat' is a}}
- std::views::counted; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::views::counted' is a}}
- std::views::drop; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::views::drop' is a}}
- std::views::drop_while; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::views::drop_while' is a}}
- std::views::elements; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::views::elements' is a}}
- std::views::empty; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::views::empty' is a}}
- std::views::enumerate; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::views::enumerate' is a}}
- std::views::filter; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::views::filter' is a}}
- std::views::iota; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::views::iota' is a}}
- std::views::istream; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::views::istream' is a}}
- std::views::istream; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::views::istream' is a}}
- std::views::join; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::views::join' is a}}
- std::views::join_with; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::views::join_with' is a}}
- std::views::keys; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::views::keys' is a}}
- std::views::lazy_split; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::views::lazy_split' is a}}
- std::views::pairwise; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::views::pairwise' is a}}
- std::views::pairwise_transform; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::views::pairwise_transform' is a}}
- std::views::repeat; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::views::repeat' is a}}
- std::views::reverse; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::views::reverse' is a}}
- std::views::single; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::views::single' is a}}
- std::views::slide; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::views::slide' is a}}
- std::views::split; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::views::split' is a}}
- std::views::stride; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::views::stride' is a}}
- std::views::take; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::views::take' is a}}
- std::views::take_while; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::views::take_while' is a}}
- std::views::transform; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::views::transform' is a}}
- std::views::values; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::views::values' is a}}
- std::views::zip; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::views::zip' is a}}
- std::views::zip_transform; // expected-error {{no member}} expected-note {{maybe try}} expected-note {{'std::views::zip_transform' is a}}
+ std::FILE; // expected-error {{no member}} expected-note {{'std::FILE' is defined in}}
+ std::_Exit; // expected-error {{no member}} expected-note {{'std::_Exit' is defined in}} expected-note {{'std::_Exit' is a}}
+ std::accumulate; // expected-error {{no member}} expected-note {{'std::accumulate' is defined in}}
+ std::acosf; // expected-error {{no member}} expected-note {{'std::acosf' is defined in}} expected-note {{'std::acosf' is a}}
+ std::acoshf; // expected-error {{no member}} expected-note {{'std::acoshf' is defined in}} expected-note {{'std::acoshf' is a}}
+ std::acoshl; // expected-error {{no member}} expected-note {{'std::acoshl' is defined in}} expected-note {{'std::acoshl' is a}}
+ std::acosl; // expected-error {{no member}} expected-note {{'std::acosl' is defined in}} expected-note {{'std::acosl' is a}}
+ std::add_const; // expected-error {{no member}} expected-note {{'std::add_const' is defined in}} expected-note {{'std::add_const' is a}}
+ std::add_const_t; // expected-error {{no member}} expected-note {{'std::add_const_t' is defined in}} expected-note {{'std::add_const_t' is a}}
+ std::add_cv; // expected-error {{no member}} expected-note {{'std::add_cv' is defined in}} expected-note {{'std::add_cv' is a}}
+ std::add_cv_t; // expected-error {{no member}} expected-note {{'std::add_cv_t' is defined in}} expected-note {{'std::add_cv_t' is a}}
+ std::add_lvalue_reference; // expected-error {{no member}} expected-note {{'std::add_lvalue_reference' is defined in}} expected-note {{'std::add_lvalue_reference' is a}}
+ std::add_lvalue_reference_t; // expected-error {{no member}} expected-note {{'std::add_lvalue_reference_t' is defined in}} expected-note {{'std::add_lvalue_reference_t' is a}}
+ std::add_pointer; // expected-error {{no member}} expected-note {{'std::add_pointer' is defined in}} expected-note {{'std::add_pointer' is a}}
+ std::add_pointer_t; // expected-error {{no member}} expected-note {{'std::add_pointer_t' is defined in}} expected-note {{'std::add_pointer_t' is a}}
+ std::add_rvalue_reference; // expected-error {{no member}} expected-note {{'std::add_rvalue_reference' is defined in}} expected-note {{'std::add_rvalue_reference' is a}}
+ std::add_rvalue_reference_t; // expected-error {{no member}} expected-note {{'std::add_rvalue_reference_t' is defined in}} expected-note {{'std::add_rvalue_reference_t' is a}}
+ std::add_sat; // expected-error {{no member}} expected-note {{'std::add_sat' is defined in}} expected-note {{'std::add_sat' is a}}
+ std::add_volatile; // expected-error {{no member}} expected-note {{'std::add_volatile' is defined in}} expected-note {{'std::add_volatile' is a}}
+ std::add_volatile_t; // expected-error {{no member}} expected-note {{'std::add_volatile_t' is defined in}} expected-note {{'std::add_volatile_t' is a}}
+ std::addressof; // expected-error {{no member}} expected-note {{'std::addressof' is defined in}} expected-note {{'std::addressof' is a}}
+ std::adjacent_difference; // expected-error {{no member}} expected-note {{'std::adjacent_difference' is defined in}}
+ std::adjacent_find; // expected-error {{no member}} expected-note {{'std::adjacent_find' is defined in}}
+ std::adopt_lock; // expected-error {{no member}} expected-note {{'std::adopt_lock' is defined in}} expected-note {{'std::adopt_lock' is a}}
+ std::adopt_lock_t; // expected-error {{no member}} expected-note {{'std::adopt_lock_t' is defined in}} expected-note {{'std::adopt_lock_t' is a}}
+ std::advance; // expected-error {{no member}} expected-note {{'std::advance' is defined in}}
+ std::align; // expected-error {{no member}} expected-note {{'std::align' is defined in}} expected-note {{'std::align' is a}}
+ std::align_val_t; // expected-error {{no member}} expected-note {{'std::align_val_t' is defined in}} expected-note {{'std::align_val_t' is a}}
+ std::aligned_alloc; // expected-error {{no member}} expected-note {{'std::aligned_alloc' is defined in}} expected-note {{'std::aligned_alloc' is a}}
+ std::aligned_storage; // expected-error {{no member}} expected-note {{'std::aligned_storage' is defined in}} expected-note {{'std::aligned_storage' is a}}
+ std::aligned_storage_t; // expected-error {{no member}} expected-note {{'std::aligned_storage_t' is defined in}} expected-note {{'std::aligned_storage_t' is a}}
+ std::aligned_union; // expected-error {{no member}} expected-note {{'std::aligned_union' is defined in}} expected-note {{'std::aligned_union' is a}}
+ std::aligned_union_t; // expected-error {{no member}} expected-note {{'std::aligned_union_t' is defined in}} expected-note {{'std::aligned_union_t' is a}}
+ std::alignment_of; // expected-error {{no member}} expected-note {{'std::alignment_of' is defined in}} expected-note {{'std::alignment_of' is a}}
+ std::alignment_of_v; // expected-error {{no member}} expected-note {{'std::alignment_of_v' is defined in}} expected-note {{'std::alignment_of_v' is a}}
+ std::all_of; // expected-error {{no member}} expected-note {{'std::all_of' is defined in}} expected-note {{'std::all_of' is a}}
+ std::allocate_shared; // expected-error {{no member}} expected-note {{'std::allocate_shared' is defined in}} expected-note {{'std::allocate_shared' is a}}
+ std::allocate_shared_for_overwrite; // expected-error {{no member}} expected-note {{'std::allocate_shared_for_overwrite' is defined in}} expected-note {{'std::allocate_shared_for_overwrite' is a}}
+ std::allocation_result; // expected-error {{no member}} expected-note {{'std::allocation_result' is defined in}} expected-note {{'std::allocation_result' is a}}
+ std::allocator; // expected-error {{no member}} expected-note {{'std::allocator' is defined in}}
+ std::allocator_arg; // expected-error {{no member}} expected-note {{'std::allocator_arg' is defined in}} expected-note {{'std::allocator_arg' is a}}
+ std::allocator_arg_t; // expected-error {{no member}} expected-note {{'std::allocator_arg_t' is defined in}} expected-note {{'std::allocator_arg_t' is a}}
+ std::allocator_traits; // expected-error {{no member}} expected-note {{'std::allocator_traits' is defined in}} expected-note {{'std::allocator_traits' is a}}
+ std::any; // expected-error {{no member}} expected-note {{'std::any' is defined in}} expected-note {{'std::any' is a}}
+ std::any_cast; // expected-error {{no member}} expected-note {{'std::any_cast' is defined in}} expected-note {{'std::any_cast' is a}}
+ std::any_of; // expected-error {{no member}} expected-note {{'std::any_of' is defined in}} expected-note {{'std::any_of' is a}}
+ std::apply; // expected-error {{no member}} expected-note {{'std::apply' is defined in}} expected-note {{'std::apply' is a}}
+ std::arg; // expected-error {{no member}} expected-note {{'std::arg' is defined in}}
+ std::array; // expected-error {{no member}} expected-note {{'std::array' is defined in}} expected-note {{'std::array' is a}}
+ std::as_bytes; // expected-error {{no member}} expected-note {{'std::as_bytes' is defined in}} expected-note {{'std::as_bytes' is a}}
+ std::as_const; // expected-error {{no member}} expected-note {{'std::as_const' is defined in}} expected-note {{'std::as_const' is a}}
+ std::as_writable_bytes; // expected-error {{no member}} expected-note {{'std::as_writable_bytes' is defined in}} expected-note {{'std::as_writable_bytes' is a}}
+ std::asctime; // expected-error {{no member}} expected-note {{'std::asctime' is defined in}}
+ std::asinf; // expected-error {{no member}} expected-note {{'std::asinf' is defined in}} expected-note {{'std::asinf' is a}}
+ std::asinhf; // expected-error {{no member}} expected-note {{'std::asinhf' is defined in}} expected-note {{'std::asinhf' is a}}
+ std::asinhl; // expected-error {{no member}} expected-note {{'std::asinhl' is defined in}} expected-note {{'std::asinhl' is a}}
+ std::asinl; // expected-error {{no member}} expected-note {{'std::asinl' is defined in}} expected-note {{'std::asinl' is a}}
+ std::assignable_from; // expected-error {{no member}} expected-note {{'std::assignable_from' is defined in}} expected-note {{'std::assignable_from' is a}}
+ std::assoc_laguerre; // expected-error {{no member}} expected-note {{'std::assoc_laguerre' is defined in}} expected-note {{'std::assoc_laguerre' is a}}
+ std::assoc_laguerref; // expected-error {{no member}} expected-note {{'std::assoc_laguerref' is defined in}} expected-note {{'std::assoc_laguerref' is a}}
+ std::assoc_laguerrel; // expected-error {{no member}} expected-note {{'std::assoc_laguerrel' is defined in}} expected-note {{'std::assoc_laguerrel' is a}}
+ std::assoc_legendre; // expected-error {{no member}} expected-note {{'std::assoc_legendre' is defined in}} expected-note {{'std::assoc_legendre' is a}}
+ std::assoc_legendref; // expected-error {{no member}} expected-note {{'std::assoc_legendref' is defined in}} expected-note {{'std::assoc_legendref' is a}}
+ std::assoc_legendrel; // expected-error {{no member}} expected-note {{'std::assoc_legendrel' is defined in}} expected-note {{'std::assoc_legendrel' is a}}
+ std::assume_aligned; // expected-error {{no member}} expected-note {{'std::assume_aligned' is defined in}} expected-note {{'std::assume_aligned' is a}}
+ std::async; // expected-error {{no member}} expected-note {{'std::async' is defined in}} expected-note {{'std::async' is a}}
+ std::at_quick_exit; // expected-error {{no member}} expected-note {{'std::at_quick_exit' is defined in}} expected-note {{'std::at_quick_exit' is a}}
+ std::atan2f; // expected-error {{no member}} expected-note {{'std::atan2f' is defined in}} expected-note {{'std::atan2f' is a}}
+ std::atan2l; // expected-error {{no member}} expected-note {{'std::atan2l' is defined in}} expected-note {{'std::atan2l' is a}}
+ std::atanf; // expected-error {{no member}} expected-note {{'std::atanf' is defined in}} expected-note {{'std::atanf' is a}}
+ std::atanhf; // expected-error {{no member}} expected-note {{'std::atanhf' is defined in}} expected-note {{'std::atanhf' is a}}
+ std::atanhl; // expected-error {{no member}} expected-note {{'std::atanhl' is defined in}} expected-note {{'std::atanhl' is a}}
+ std::atanl; // expected-error {{no member}} expected-note {{'std::atanl' is defined in}} expected-note {{'std::atanl' is a}}
+ std::atexit; // expected-error {{no member}} expected-note {{'std::atexit' is defined in}}
+ std::atof; // expected-error {{no member}} expected-note {{'std::atof' is defined in}}
+ std::atoi; // expected-error {{no member}} expected-note {{'std::atoi' is defined in}}
+ std::atol; // expected-error {{no member}} expected-note {{'std::atol' is defined in}}
+ std::atoll; // expected-error {{no member}} expected-note {{'std::atoll' is defined in}} expected-note {{'std::atoll' is a}}
+ std::atomic_compare_exchange_strong; // expected-error {{no member}} expected-note {{'std::atomic_compare_exchange_strong' is defined in}} expected-note {{'std::atomic_compare_exchange_strong' is a}}
+ std::atomic_compare_exchange_strong_explicit; // expected-error {{no member}} expected-note {{'std::atomic_compare_exchange_strong_explicit' is defined in}} expected-note {{'std::atomic_compare_exchange_strong_explicit' is a}}
+ std::atomic_compare_exchange_weak; // expected-error {{no member}} expected-note {{'std::atomic_compare_exchange_weak' is defined in}} expected-note {{'std::atomic_compare_exchange_weak' is a}}
+ std::atomic_compare_exchange_weak_explicit; // expected-error {{no member}} expected-note {{'std::atomic_compare_exchange_weak_explicit' is defined in}} expected-note {{'std::atomic_compare_exchange_weak_explicit' is a}}
+ std::atomic_exchange; // expected-error {{no member}} expected-note {{'std::atomic_exchange' is defined in}} expected-note {{'std::atomic_exchange' is a}}
+ std::atomic_exchange_explicit; // expected-error {{no member}} expected-note {{'std::atomic_exchange_explicit' is defined in}} expected-note {{'std::atomic_exchange_explicit' is a}}
+ std::atomic_fetch_add; // expected-error {{no member}} expected-note {{'std::atomic_fetch_add' is defined in}} expected-note {{'std::atomic_fetch_add' is a}}
+ std::atomic_fetch_add_explicit; // expected-error {{no member}} expected-note {{'std::atomic_fetch_add_explicit' is defined in}} expected-note {{'std::atomic_fetch_add_explicit' is a}}
+ std::atomic_fetch_and; // expected-error {{no member}} expected-note {{'std::atomic_fetch_and' is defined in}} expected-note {{'std::atomic_fetch_and' is a}}
+ std::atomic_fetch_and_explicit; // expected-error {{no member}} expected-note {{'std::atomic_fetch_and_explicit' is defined in}} expected-note {{'std::atomic_fetch_and_explicit' is a}}
+ std::atomic_fetch_max; // expected-error {{no member}} expected-note {{'std::atomic_fetch_max' is defined in}} expected-note {{'std::atomic_fetch_max' is a}}
+ std::atomic_fetch_max_explicit; // expected-error {{no member}} expected-note {{'std::atomic_fetch_max_explicit' is defined in}} expected-note {{'std::atomic_fetch_max_explicit' is a}}
+ std::atomic_fetch_min; // expected-error {{no member}} expected-note {{'std::atomic_fetch_min' is defined in}} expected-note {{'std::atomic_fetch_min' is a}}
+ std::atomic_fetch_min_explicit; // expected-error {{no member}} expected-note {{'std::atomic_fetch_min_explicit' is defined in}} expected-note {{'std::atomic_fetch_min_explicit' is a}}
+ std::atomic_fetch_or; // expected-error {{no member}} expected-note {{'std::atomic_fetch_or' is defined in}} expected-note {{'std::atomic_fetch_or' is a}}
+ std::atomic_fetch_or_explicit; // expected-error {{no member}} expected-note {{'std::atomic_fetch_or_explicit' is defined in}} expected-note {{'std::atomic_fetch_or_explicit' is a}}
+ std::atomic_fetch_sub; // expected-error {{no member}} expected-note {{'std::atomic_fetch_sub' is defined in}} expected-note {{'std::atomic_fetch_sub' is a}}
+ std::atomic_fetch_sub_explicit; // expected-error {{no member}} expected-note {{'std::atomic_fetch_sub_explicit' is defined in}} expected-note {{'std::atomic_fetch_sub_explicit' is a}}
+ std::atomic_fetch_xor; // expected-error {{no member}} expected-note {{'std::atomic_fetch_xor' is defined in}} expected-note {{'std::atomic_fetch_xor' is a}}
+ std::atomic_fetch_xor_explicit; // expected-error {{no member}} expected-note {{'std::atomic_fetch_xor_explicit' is defined in}} expected-note {{'std::atomic_fetch_xor_explicit' is a}}
+ std::atomic_flag; // expected-error {{no member}} expected-note {{'std::atomic_flag' is defined in}} expected-note {{'std::atomic_flag' is a}}
+ std::atomic_flag_clear; // expected-error {{no member}} expected-note {{'std::atomic_flag_clear' is defined in}} expected-note {{'std::atomic_flag_clear' is a}}
+ std::atomic_flag_clear_explicit; // expected-error {{no member}} expected-note {{'std::atomic_flag_clear_explicit' is defined in}} expected-note {{'std::atomic_flag_clear_explicit' is a}}
+ std::atomic_flag_notify_all; // expected-error {{no member}} expected-note {{'std::atomic_flag_notify_all' is defined in}} expected-note {{'std::atomic_flag_notify_all' is a}}
+ std::atomic_flag_notify_one; // expected-error {{no member}} expected-note {{'std::atomic_flag_notify_one' is defined in}} expected-note {{'std::atomic_flag_notify_one' is a}}
+ std::atomic_flag_test; // expected-error {{no member}} expected-note {{'std::atomic_flag_test' is defined in}} expected-note {{'std::atomic_flag_test' is a}}
+ std::atomic_flag_test_and_set; // expected-error {{no member}} expected-note {{'std::atomic_flag_test_and_set' is defined in}} expected-note {{'std::atomic_flag_test_and_set' is a}}
+ std::atomic_flag_test_and_set_explicit; // expected-error {{no member}} expected-note {{'std::atomic_flag_test_and_set_explicit' is defined in}} expected-note {{'std::atomic_flag_test_and_set_explicit' is a}}
+ std::atomic_flag_test_explicit; // expected-error {{no member}} expected-note {{'std::atomic_flag_test_explicit' is defined in}} expected-note {{'std::atomic_flag_test_explicit' is a}}
+ std::atomic_flag_wait; // expected-error {{no member}} expected-note {{'std::atomic_flag_wait' is defined in}} expected-note {{'std::atomic_flag_wait' is a}}
+ std::atomic_flag_wait_explicit; // expected-error {{no member}} expected-note {{'std::atomic_flag_wait_explicit' is defined in}} expected-note {{'std::atomic_flag_wait_explicit' is a}}
+ std::atomic_init; // expected-error {{no member}} expected-note {{'std::atomic_init' is defined in}} expected-note {{'std::atomic_init' is a}}
+ std::atomic_is_lock_free; // expected-error {{no member}} expected-note {{'std::atomic_is_lock_free' is defined in}} expected-note {{'std::atomic_is_lock_free' is a}}
+ std::atomic_load; // expected-error {{no member}} expected-note {{'std::atomic_load' is defined in}} expected-note {{'std::atomic_load' is a}}
+ std::atomic_load_explicit; // expected-error {{no member}} expected-note {{'std::atomic_load_explicit' is defined in}} expected-note {{'std::atomic_load_explicit' is a}}
+ std::atomic_notify_all; // expected-error {{no member}} expected-note {{'std::atomic_notify_all' is defined in}} expected-note {{'std::atomic_notify_all' is a}}
+ std::atomic_notify_one; // expected-error {{no member}} expected-note {{'std::atomic_notify_one' is defined in}} expected-note {{'std::atomic_notify_one' is a}}
+ std::atomic_ref; // expected-error {{no member}} expected-note {{'std::atomic_ref' is defined in}} expected-note {{'std::atomic_ref' is a}}
+ std::atomic_signal_fence; // expected-error {{no member}} expected-note {{'std::atomic_signal_fence' is defined in}} expected-note {{'std::atomic_signal_fence' is a}}
+ std::atomic_store; // expected-error {{no member}} expected-note {{'std::atomic_store' is defined in}} expected-note {{'std::atomic_store' is a}}
+ std::atomic_store_explicit; // expected-error {{no member}} expected-note {{'std::atomic_store_explicit' is defined in}} expected-note {{'std::atomic_store_explicit' is a}}
+ std::atomic_thread_fence; // expected-error {{no member}} expected-note {{'std::atomic_thread_fence' is defined in}} expected-note {{'std::atomic_thread_fence' is a}}
+ std::atomic_wait; // expected-error {{no member}} expected-note {{'std::atomic_wait' is defined in}} expected-note {{'std::atomic_wait' is a}}
+ std::atomic_wait_explicit; // expected-error {{no member}} expected-note {{'std::atomic_wait_explicit' is defined in}} expected-note {{'std::atomic_wait_explicit' is a}}
+ std::atto; // expected-error {{no member}} expected-note {{'std::atto' is defined in}} expected-note {{'std::atto' is a}}
+ std::auto_ptr; // expected-error {{no member}} expected-note {{'std::auto_ptr' is defined in}}
+ std::back_insert_iterator; // expected-error {{no member}} expected-note {{'std::back_insert_iterator' is defined in}}
+ std::back_inserter; // expected-error {{no member}} expected-note {{'std::back_inserter' is defined in}}
+ std::bad_alloc; // expected-error {{no member}} expected-note {{'std::bad_alloc' is defined in}}
+ std::bad_any_cast; // expected-error {{no member}} expected-note {{'std::bad_any_cast' is defined in}} expected-note {{'std::bad_any_cast' is a}}
+ std::bad_array_new_length; // expected-error {{no member}} expected-note {{'std::bad_array_new_length' is defined in}} expected-note {{'std::bad_array_new_length' is a}}
+ std::bad_cast; // expected-error {{no member}} expected-note {{'std::bad_cast' is defined in}}
+ std::bad_exception; // expected-error {{no member}} expected-note {{'std::bad_exception' is defined in}}
+ std::bad_expected_access; // expected-error {{no member}} expected-note {{'std::bad_expected_access' is defined in}} expected-note {{'std::bad_expected_access' is a}}
+ std::bad_function_call; // expected-error {{no member}} expected-note {{'std::bad_function_call' is defined in}} expected-note {{'std::bad_function_call' is a}}
+ std::bad_optional_access; // expected-error {{no member}} expected-note {{'std::bad_optional_access' is defined in}} expected-note {{'std::bad_optional_access' is a}}
+ std::bad_typeid; // expected-error {{no member}} expected-note {{'std::bad_typeid' is defined in}}
+ std::bad_variant_access; // expected-error {{no member}} expected-note {{'std::bad_variant_access' is defined in}} expected-note {{'std::bad_variant_access' is a}}
+ std::bad_weak_ptr; // expected-error {{no member}} expected-note {{'std::bad_weak_ptr' is defined in}} expected-note {{'std::bad_weak_ptr' is a}}
+ std::barrier; // expected-error {{no member}} expected-note {{'std::barrier' is defined in}} expected-note {{'std::barrier' is a}}
+ std::basic_common_reference; // expected-error {{no member}} expected-note {{'std::basic_common_reference' is defined in}} expected-note {{'std::basic_common_reference' is a}}
+ std::basic_const_iterator; // expected-error {{no member}} expected-note {{'std::basic_const_iterator' is defined in}} expected-note {{'std::basic_const_iterator' is a}}
+ std::basic_filebuf; // expected-error {{no member}} expected-note {{'std::basic_filebuf' is defined in}}
+ std::basic_filebuf; // expected-error {{no member}} expected-note {{'std::basic_filebuf' is defined in}}
+ std::basic_format_arg; // expected-error {{no member}} expected-note {{'std::basic_format_arg' is defined in}} expected-note {{'std::basic_format_arg' is a}}
+ std::basic_format_args; // expected-error {{no member}} expected-note {{'std::basic_format_args' is defined in}} expected-note {{'std::basic_format_args' is a}}
+ std::basic_format_context; // expected-error {{no member}} expected-note {{'std::basic_format_context' is defined in}} expected-note {{'std::basic_format_context' is a}}
+ std::basic_format_parse_context; // expected-error {{no member}} expected-note {{'std::basic_format_parse_context' is defined in}} expected-note {{'std::basic_format_parse_context' is a}}
+ std::basic_format_string; // expected-error {{no member}} expected-note {{'std::basic_format_string' is defined in}} expected-note {{'std::basic_format_string' is a}}
+ std::basic_fstream; // expected-error {{no member}} expected-note {{'std::basic_fstream' is defined in}}
+ std::basic_fstream; // expected-error {{no member}} expected-note {{'std::basic_fstream' is defined in}}
+ std::basic_ifstream; // expected-error {{no member}} expected-note {{'std::basic_ifstream' is defined in}}
+ std::basic_ifstream; // expected-error {{no member}} expected-note {{'std::basic_ifstream' is defined in}}
+ std::basic_ios; // expected-error {{no member}} expected-note {{'std::basic_ios' is defined in}}
+ std::basic_ios; // expected-error {{no member}} expected-note {{'std::basic_ios' is defined in}}
+ std::basic_ios; // expected-error {{no member}} expected-note {{'std::basic_ios' is defined in}}
+ std::basic_iostream; // expected-error {{no member}} expected-note {{'std::basic_iostream' is defined in}}
+ std::basic_iostream; // expected-error {{no member}} expected-note {{'std::basic_iostream' is defined in}}
+ std::basic_iostream; // expected-error {{no member}} expected-note {{'std::basic_iostream' is defined in}}
+ std::basic_ispanstream; // expected-error {{no member}} expected-note {{'std::basic_ispanstream' is defined in}} expected-note {{'std::basic_ispanstream' is a}}
+ std::basic_ispanstream; // expected-error {{no member}} expected-note {{'std::basic_ispanstream' is defined in}} expected-note {{'std::basic_ispanstream' is a}}
+ std::basic_istream; // expected-error {{no member}} expected-note {{'std::basic_istream' is defined in}}
+ std::basic_istream; // expected-error {{no member}} expected-note {{'std::basic_istream' is defined in}}
+ std::basic_istream; // expected-error {{no member}} expected-note {{'std::basic_istream' is defined in}}
+ std::basic_istringstream; // expected-error {{no member}} expected-note {{'std::basic_istringstream' is defined in}}
+ std::basic_istringstream; // expected-error {{no member}} expected-note {{'std::basic_istringstream' is defined in}}
+ std::basic_ofstream; // expected-error {{no member}} expected-note {{'std::basic_ofstream' is defined in}}
+ std::basic_ofstream; // expected-error {{no member}} expected-note {{'std::basic_ofstream' is defined in}}
+ std::basic_ospanstream; // expected-error {{no member}} expected-note {{'std::basic_ospanstream' is defined in}} expected-note {{'std::basic_ospanstream' is a}}
+ std::basic_ospanstream; // expected-error {{no member}} expected-note {{'std::basic_ospanstream' is defined in}} expected-note {{'std::basic_ospanstream' is a}}
+ std::basic_ostream; // expected-error {{no member}} expected-note {{'std::basic_ostream' is defined in}}
+ std::basic_ostream; // expected-error {{no member}} expected-note {{'std::basic_ostream' is defined in}}
+ std::basic_ostream; // expected-error {{no member}} expected-note {{'std::basic_ostream' is defined in}}
+ std::basic_ostringstream; // expected-error {{no member}} expected-note {{'std::basic_ostringstream' is defined in}}
+ std::basic_ostringstream; // expected-error {{no member}} expected-note {{'std::basic_ostringstream' is defined in}}
+ std::basic_osyncstream; // expected-error {{no member}} expected-note {{'std::basic_osyncstream' is defined in}} expected-note {{'std::basic_osyncstream' is a}}
+ std::basic_osyncstream; // expected-error {{no member}} expected-note {{'std::basic_osyncstream' is defined in}} expected-note {{'std::basic_osyncstream' is a}}
+ std::basic_regex; // expected-error {{no member}} expected-note {{'std::basic_regex' is defined in}} expected-note {{'std::basic_regex' is a}}
+ std::basic_spanbuf; // expected-error {{no member}} expected-note {{'std::basic_spanbuf' is defined in}} expected-note {{'std::basic_spanbuf' is a}}
+ std::basic_spanbuf; // expected-error {{no member}} expected-note {{'std::basic_spanbuf' is defined in}} expected-note {{'std::basic_spanbuf' is a}}
+ std::basic_spanstream; // expected-error {{no member}} expected-note {{'std::basic_spanstream' is defined in}} expected-note {{'std::basic_spanstream' is a}}
+ std::basic_spanstream; // expected-error {{no member}} expected-note {{'std::basic_spanstream' is defined in}} expected-note {{'std::basic_spanstream' is a}}
+ std::basic_stacktrace; // expected-error {{no member}} expected-note {{'std::basic_stacktrace' is defined in}} expected-note {{'std::basic_stacktrace' is a}}
+ std::basic_streambuf; // expected-error {{no member}} expected-note {{'std::basic_streambuf' is defined in}}
+ std::basic_streambuf; // expected-error {{no member}} expected-note {{'std::basic_streambuf' is defined in}}
+ std::basic_streambuf; // expected-error {{no member}} expected-note {{'std::basic_streambuf' is defined in}}
+ std::basic_string; // expected-error {{no member}} expected-note {{'std::basic_string' is defined in}}
+ std::basic_string_view; // expected-error {{no member}} expected-note {{'std::basic_string_view' is defined in}} expected-note {{'std::basic_string_view' is a}}
+ std::basic_stringbuf; // expected-error {{no member}} expected-note {{'std::basic_stringbuf' is defined in}}
+ std::basic_stringbuf; // expected-error {{no member}} expected-note {{'std::basic_stringbuf' is defined in}}
+ std::basic_stringstream; // expected-error {{no member}} expected-note {{'std::basic_stringstream' is defined in}}
+ std::basic_stringstream; // expected-error {{no member}} expected-note {{'std::basic_stringstream' is defined in}}
+ std::basic_syncbuf; // expected-error {{no member}} expected-note {{'std::basic_syncbuf' is defined in}} expected-note {{'std::basic_syncbuf' is a}}
+ std::basic_syncbuf; // expected-error {{no member}} expected-note {{'std::basic_syncbuf' is defined in}} expected-note {{'std::basic_syncbuf' is a}}
+ std::bernoulli_distribution; // expected-error {{no member}} expected-note {{'std::bernoulli_distribution' is defined in}} expected-note {{'std::bernoulli_distribution' is a}}
+ std::beta; // expected-error {{no member}} expected-note {{'std::beta' is defined in}} expected-note {{'std::beta' is a}}
+ std::betaf; // expected-error {{no member}} expected-note {{'std::betaf' is defined in}} expected-note {{'std::betaf' is a}}
+ std::betal; // expected-error {{no member}} expected-note {{'std::betal' is defined in}} expected-note {{'std::betal' is a}}
+ std::bidirectional_iterator; // expected-error {{no member}} expected-note {{'std::bidirectional_iterator' is defined in}} expected-note {{'std::bidirectional_iterator' is a}}
+ std::bidirectional_iterator_tag; // expected-error {{no member}} expected-note {{'std::bidirectional_iterator_tag' is defined in}}
+ std::binary_function; // expected-error {{no member}} expected-note {{'std::binary_function' is defined in}}
+ std::binary_negate; // expected-error {{no member}} expected-note {{'std::binary_negate' is defined in}}
+ std::binary_search; // expected-error {{no member}} expected-note {{'std::binary_search' is defined in}}
+ std::binary_semaphore; // expected-error {{no member}} expected-note {{'std::binary_semaphore' is defined in}} expected-note {{'std::binary_semaphore' is a}}
+ std::bind; // expected-error {{no member}} expected-note {{'std::bind' is defined in}} expected-note {{'std::bind' is a}}
+ std::bind1st; // expected-error {{no member}} expected-note {{'std::bind1st' is defined in}}
+ std::bind2nd; // expected-error {{no member}} expected-note {{'std::bind2nd' is defined in}}
+ std::bind_back; // expected-error {{no member}} expected-note {{'std::bind_back' is defined in}} expected-note {{'std::bind_back' is a}}
+ std::bind_front; // expected-error {{no member}} expected-note {{'std::bind_front' is defined in}} expected-note {{'std::bind_front' is a}}
+ std::binder1st; // expected-error {{no member}} expected-note {{'std::binder1st' is defined in}}
+ std::binder2nd; // expected-error {{no member}} expected-note {{'std::binder2nd' is defined in}}
+ std::binomial_distribution; // expected-error {{no member}} expected-note {{'std::binomial_distribution' is defined in}} expected-note {{'std::binomial_distribution' is a}}
+ std::bit_and; // expected-error {{no member}} expected-note {{'std::bit_and' is defined in}}
+ std::bit_cast; // expected-error {{no member}} expected-note {{'std::bit_cast' is defined in}} expected-note {{'std::bit_cast' is a}}
+ std::bit_ceil; // expected-error {{no member}} expected-note {{'std::bit_ceil' is defined in}} expected-note {{'std::bit_ceil' is a}}
+ std::bit_floor; // expected-error {{no member}} expected-note {{'std::bit_floor' is defined in}} expected-note {{'std::bit_floor' is a}}
+ std::bit_not; // expected-error {{no member}} expected-note {{'std::bit_not' is defined in}} expected-note {{'std::bit_not' is a}}
+ std::bit_or; // expected-error {{no member}} expected-note {{'std::bit_or' is defined in}}
+ std::bit_width; // expected-error {{no member}} expected-note {{'std::bit_width' is defined in}} expected-note {{'std::bit_width' is a}}
+ std::bit_xor; // expected-error {{no member}} expected-note {{'std::bit_xor' is defined in}}
+ std::bitset; // expected-error {{no member}} expected-note {{'std::bitset' is defined in}}
+ std::bool_constant; // expected-error {{no member}} expected-note {{'std::bool_constant' is defined in}} expected-note {{'std::bool_constant' is a}}
+ std::boolalpha; // expected-error {{no member}} expected-note {{'std::boolalpha' is defined in}}
+ std::boolalpha; // expected-error {{no member}} expected-note {{'std::boolalpha' is defined in}}
+ std::boyer_moore_horspool_searcher; // expected-error {{no member}} expected-note {{'std::boyer_moore_horspool_searcher' is defined in}} expected-note {{'std::boyer_moore_horspool_searcher' is a}}
+ std::boyer_moore_searcher; // expected-error {{no member}} expected-note {{'std::boyer_moore_searcher' is defined in}} expected-note {{'std::boyer_moore_searcher' is a}}
+ std::breakpoint; // expected-error {{no member}} expected-note {{'std::breakpoint' is defined in}} expected-note {{'std::breakpoint' is a}}
+ std::breakpoint_if_debugging; // expected-error {{no member}} expected-note {{'std::breakpoint_if_debugging' is defined in}} expected-note {{'std::breakpoint_if_debugging' is a}}
+ std::bsearch; // expected-error {{no member}} expected-note {{'std::bsearch' is defined in}}
+ std::btowc; // expected-error {{no member}} expected-note {{'std::btowc' is defined in}}
+ std::byte; // expected-error {{no member}} expected-note {{'std::byte' is defined in}} expected-note {{'std::byte' is a}}
+ std::byteswap; // expected-error {{no member}} expected-note {{'std::byteswap' is defined in}} expected-note {{'std::byteswap' is a}}
+ std::c16rtomb; // expected-error {{no member}} expected-note {{'std::c16rtomb' is defined in}} expected-note {{'std::c16rtomb' is a}}
+ std::c32rtomb; // expected-error {{no member}} expected-note {{'std::c32rtomb' is defined in}} expected-note {{'std::c32rtomb' is a}}
+ std::c8rtomb; // expected-error {{no member}} expected-note {{'std::c8rtomb' is defined in}} expected-note {{'std::c8rtomb' is a}}
+ std::call_once; // expected-error {{no member}} expected-note {{'std::call_once' is defined in}} expected-note {{'std::call_once' is a}}
+ std::calloc; // expected-error {{no member}} expected-note {{'std::calloc' is defined in}}
+ std::cauchy_distribution; // expected-error {{no member}} expected-note {{'std::cauchy_distribution' is defined in}} expected-note {{'std::cauchy_distribution' is a}}
+ std::cbrtf; // expected-error {{no member}} expected-note {{'std::cbrtf' is defined in}} expected-note {{'std::cbrtf' is a}}
+ std::cbrtl; // expected-error {{no member}} expected-note {{'std::cbrtl' is defined in}} expected-note {{'std::cbrtl' is a}}
+ std::ceilf; // expected-error {{no member}} expected-note {{'std::ceilf' is defined in}} expected-note {{'std::ceilf' is a}}
+ std::ceill; // expected-error {{no member}} expected-note {{'std::ceill' is defined in}} expected-note {{'std::ceill' is a}}
+ std::centi; // expected-error {{no member}} expected-note {{'std::centi' is defined in}} expected-note {{'std::centi' is a}}
+ std::cerr; // expected-error {{no member}} expected-note {{'std::cerr' is defined in}}
+ std::char_traits; // expected-error {{no member}} expected-note {{'std::char_traits' is defined in}}
+ std::chars_format; // expected-error {{no member}} expected-note {{'std::chars_format' is defined in}} expected-note {{'std::chars_format' is a}}
+ std::chi_squared_distribution; // expected-error {{no member}} expected-note {{'std::chi_squared_distribution' is defined in}} expected-note {{'std::chi_squared_distribution' is a}}
+ std::cin; // expected-error {{no member}} expected-note {{'std::cin' is defined in}}
+ std::clamp; // expected-error {{no member}} expected-note {{'std::clamp' is defined in}} expected-note {{'std::clamp' is a}}
+ std::clearerr; // expected-error {{no member}} expected-note {{'std::clearerr' is defined in}}
+ std::clock; // expected-error {{no member}} expected-note {{'std::clock' is defined in}}
+ std::clock_t; // expected-error {{no member}} expected-note {{'std::clock_t' is defined in}}
+ std::clog; // expected-error {{no member}} expected-note {{'std::clog' is defined in}}
+ std::cmatch; // expected-error {{no member}} expected-note {{'std::cmatch' is defined in}} expected-note {{'std::cmatch' is a}}
+ std::cmp_equal; // expected-error {{no member}} expected-note {{'std::cmp_equal' is defined in}} expected-note {{'std::cmp_equal' is a}}
+ std::cmp_greater; // expected-error {{no member}} expected-note {{'std::cmp_greater' is defined in}} expected-note {{'std::cmp_greater' is a}}
+ std::cmp_greater_equal; // expected-error {{no member}} expected-note {{'std::cmp_greater_equal' is defined in}} expected-note {{'std::cmp_greater_equal' is a}}
+ std::cmp_less; // expected-error {{no member}} expected-note {{'std::cmp_less' is defined in}} expected-note {{'std::cmp_less' is a}}
+ std::cmp_less_equal; // expected-error {{no member}} expected-note {{'std::cmp_less_equal' is defined in}} expected-note {{'std::cmp_less_equal' is a}}
+ std::cmp_not_equal; // expected-error {{no member}} expected-note {{'std::cmp_not_equal' is defined in}} expected-note {{'std::cmp_not_equal' is a}}
+ std::codecvt; // expected-error {{no member}} expected-note {{'std::codecvt' is defined in}}
+ std::codecvt_base; // expected-error {{no member}} expected-note {{'std::codecvt_base' is defined in}}
+ std::codecvt_byname; // expected-error {{no member}} expected-note {{'std::codecvt_byname' is defined in}}
+ std::codecvt_mode; // expected-error {{no member}} expected-note {{'std::codecvt_mode' is defined in}} expected-note {{'std::codecvt_mode' is a}}
+ std::codecvt_utf16; // expected-error {{no member}} expected-note {{'std::codecvt_utf16' is defined in}} expected-note {{'std::codecvt_utf16' is a}}
+ std::codecvt_utf8; // expected-error {{no member}} expected-note {{'std::codecvt_utf8' is defined in}} expected-note {{'std::codecvt_utf8' is a}}
+ std::codecvt_utf8_utf16; // expected-error {{no member}} expected-note {{'std::codecvt_utf8_utf16' is defined in}} expected-note {{'std::codecvt_utf8_utf16' is a}}
+ std::collate; // expected-error {{no member}} expected-note {{'std::collate' is defined in}}
+ std::collate_byname; // expected-error {{no member}} expected-note {{'std::collate_byname' is defined in}}
+ std::common_comparison_category; // expected-error {{no member}} expected-note {{'std::common_comparison_category' is defined in}} expected-note {{'std::common_comparison_category' is a}}
+ std::common_comparison_category_t; // expected-error {{no member}} expected-note {{'std::common_comparison_category_t' is defined in}} expected-note {{'std::common_comparison_category_t' is a}}
+ std::common_iterator; // expected-error {{no member}} expected-note {{'std::common_iterator' is defined in}} expected-note {{'std::common_iterator' is a}}
+ std::common_reference; // expected-error {{no member}} expected-note {{'std::common_reference' is defined in}} expected-note {{'std::common_reference' is a}}
+ std::common_reference_t; // expected-error {{no member}} expected-note {{'std::common_reference_t' is defined in}} expected-note {{'std::common_reference_t' is a}}
+ std::common_reference_with; // expected-error {{no member}} expected-note {{'std::common_reference_with' is defined in}} expected-note {{'std::common_reference_with' is a}}
+ std::common_type; // expected-error {{no member}} expected-note {{'std::common_type' is defined in}} expected-note {{'std::common_type' is a}}
+ std::common_type_t; // expected-error {{no member}} expected-note {{'std::common_type_t' is defined in}} expected-note {{'std::common_type_t' is a}}
+ std::common_with; // expected-error {{no member}} expected-note {{'std::common_with' is defined in}} expected-note {{'std::common_with' is a}}
+ std::comp_ellint_1; // expected-error {{no member}} expected-note {{'std::comp_ellint_1' is defined in}} expected-note {{'std::comp_ellint_1' is a}}
+ std::comp_ellint_1f; // expected-error {{no member}} expected-note {{'std::comp_ellint_1f' is defined in}} expected-note {{'std::comp_ellint_1f' is a}}
+ std::comp_ellint_1l; // expected-error {{no member}} expected-note {{'std::comp_ellint_1l' is defined in}} expected-note {{'std::comp_ellint_1l' is a}}
+ std::comp_ellint_2; // expected-error {{no member}} expected-note {{'std::comp_ellint_2' is defined in}} expected-note {{'std::comp_ellint_2' is a}}
+ std::comp_ellint_2f; // expected-error {{no member}} expected-note {{'std::comp_ellint_2f' is defined in}} expected-note {{'std::comp_ellint_2f' is a}}
+ std::comp_ellint_2l; // expected-error {{no member}} expected-note {{'std::comp_ellint_2l' is defined in}} expected-note {{'std::comp_ellint_2l' is a}}
+ std::comp_ellint_3; // expected-error {{no member}} expected-note {{'std::comp_ellint_3' is defined in}} expected-note {{'std::comp_ellint_3' is a}}
+ std::comp_ellint_3f; // expected-error {{no member}} expected-note {{'std::comp_ellint_3f' is defined in}} expected-note {{'std::comp_ellint_3f' is a}}
+ std::comp_ellint_3l; // expected-error {{no member}} expected-note {{'std::comp_ellint_3l' is defined in}} expected-note {{'std::comp_ellint_3l' is a}}
+ std::compare_partial_order_fallback; // expected-error {{no member}} expected-note {{'std::compare_partial_order_fallback' is defined in}} expected-note {{'std::compare_partial_order_fallback' is a}}
+ std::compare_strong_order_fallback; // expected-error {{no member}} expected-note {{'std::compare_strong_order_fallback' is defined in}} expected-note {{'std::compare_strong_order_fallback' is a}}
+ std::compare_three_way_result; // expected-error {{no member}} expected-note {{'std::compare_three_way_result' is defined in}} expected-note {{'std::compare_three_way_result' is a}}
+ std::compare_three_way_result_t; // expected-error {{no member}} expected-note {{'std::compare_three_way_result_t' is defined in}} expected-note {{'std::compare_three_way_result_t' is a}}
+ std::compare_weak_order_fallback; // expected-error {{no member}} expected-note {{'std::compare_weak_order_fallback' is defined in}} expected-note {{'std::compare_weak_order_fallback' is a}}
+ std::complex; // expected-error {{no member}} expected-note {{'std::complex' is defined in}}
+ std::condition_variable; // expected-error {{no member}} expected-note {{'std::condition_variable' is defined in}} expected-note {{'std::condition_variable' is a}}
+ std::condition_variable_any; // expected-error {{no member}} expected-note {{'std::condition_variable_any' is defined in}} expected-note {{'std::condition_variable_any' is a}}
+ std::conditional; // expected-error {{no member}} expected-note {{'std::conditional' is defined in}} expected-note {{'std::conditional' is a}}
+ std::conditional_t; // expected-error {{no member}} expected-note {{'std::conditional_t' is defined in}} expected-note {{'std::conditional_t' is a}}
+ std::conj; // expected-error {{no member}} expected-note {{'std::conj' is defined in}}
+ std::conjunction; // expected-error {{no member}} expected-note {{'std::conjunction' is defined in}} expected-note {{'std::conjunction' is a}}
+ std::conjunction_v; // expected-error {{no member}} expected-note {{'std::conjunction_v' is defined in}} expected-note {{'std::conjunction_v' is a}}
+ std::const_iterator; // expected-error {{no member}} expected-note {{'std::const_iterator' is defined in}} expected-note {{'std::const_iterator' is a}}
+ std::const_mem_fun1_ref_t; // expected-error {{no member}} expected-note {{'std::const_mem_fun1_ref_t' is defined in}}
+ std::const_mem_fun1_t; // expected-error {{no member}} expected-note {{'std::const_mem_fun1_t' is defined in}}
+ std::const_mem_fun_ref_t; // expected-error {{no member}} expected-note {{'std::const_mem_fun_ref_t' is defined in}}
+ std::const_mem_fun_t; // expected-error {{no member}} expected-note {{'std::const_mem_fun_t' is defined in}}
+ std::const_pointer_cast; // expected-error {{no member}} expected-note {{'std::const_pointer_cast' is defined in}} expected-note {{'std::const_pointer_cast' is a}}
+ std::const_sentinel; // expected-error {{no member}} expected-note {{'std::const_sentinel' is defined in}} expected-note {{'std::const_sentinel' is a}}
+ std::construct_at; // expected-error {{no member}} expected-note {{'std::construct_at' is defined in}} expected-note {{'std::construct_at' is a}}
+ std::constructible_from; // expected-error {{no member}} expected-note {{'std::constructible_from' is defined in}} expected-note {{'std::constructible_from' is a}}
+ std::contiguous_iterator; // expected-error {{no member}} expected-note {{'std::contiguous_iterator' is defined in}} expected-note {{'std::contiguous_iterator' is a}}
+ std::contiguous_iterator_tag; // expected-error {{no member}} expected-note {{'std::contiguous_iterator_tag' is defined in}} expected-note {{'std::contiguous_iterator_tag' is a}}
+ std::convertible_to; // expected-error {{no member}} expected-note {{'std::convertible_to' is defined in}} expected-note {{'std::convertible_to' is a}}
+ std::copy; // expected-error {{no member}} expected-note {{'std::copy' is defined in}}
+ std::copy_backward; // expected-error {{no member}} expected-note {{'std::copy_backward' is defined in}}
+ std::copy_constructible; // expected-error {{no member}} expected-note {{'std::copy_constructible' is defined in}} expected-note {{'std::copy_constructible' is a}}
+ std::copy_if; // expected-error {{no member}} expected-note {{'std::copy_if' is defined in}} expected-note {{'std::copy_if' is a}}
+ std::copy_n; // expected-error {{no member}} expected-note {{'std::copy_n' is defined in}} expected-note {{'std::copy_n' is a}}
+ std::copyable; // expected-error {{no member}} expected-note {{'std::copyable' is defined in}} expected-note {{'std::copyable' is a}}
+ std::copyable_function; // expected-error {{no member}} expected-note {{'std::copyable_function' is defined in}} expected-note {{'std::copyable_function' is a}}
+ std::copysignf; // expected-error {{no member}} expected-note {{'std::copysignf' is defined in}} expected-note {{'std::copysignf' is a}}
+ std::copysignl; // expected-error {{no member}} expected-note {{'std::copysignl' is defined in}} expected-note {{'std::copysignl' is a}}
+ std::coroutine_handle; // expected-error {{no member}} expected-note {{'std::coroutine_handle' is defined in}} expected-note {{'std::coroutine_handle' is a}}
+ std::coroutine_traits; // expected-error {{no member}} expected-note {{'std::coroutine_traits' is defined in}} expected-note {{'std::coroutine_traits' is a}}
+ std::cosf; // expected-error {{no member}} expected-note {{'std::cosf' is defined in}} expected-note {{'std::cosf' is a}}
+ std::coshf; // expected-error {{no member}} expected-note {{'std::coshf' is defined in}} expected-note {{'std::coshf' is a}}
+ std::coshl; // expected-error {{no member}} expected-note {{'std::coshl' is defined in}} expected-note {{'std::coshl' is a}}
+ std::cosl; // expected-error {{no member}} expected-note {{'std::cosl' is defined in}} expected-note {{'std::cosl' is a}}
+ std::count; // expected-error {{no member}} expected-note {{'std::count' is defined in}}
+ std::count_if; // expected-error {{no member}} expected-note {{'std::count_if' is defined in}}
+ std::counted_iterator; // expected-error {{no member}} expected-note {{'std::counted_iterator' is defined in}} expected-note {{'std::counted_iterator' is a}}
+ std::counting_semaphore; // expected-error {{no member}} expected-note {{'std::counting_semaphore' is defined in}} expected-note {{'std::counting_semaphore' is a}}
+ std::countl_one; // expected-error {{no member}} expected-note {{'std::countl_one' is defined in}} expected-note {{'std::countl_one' is a}}
+ std::countl_zero; // expected-error {{no member}} expected-note {{'std::countl_zero' is defined in}} expected-note {{'std::countl_zero' is a}}
+ std::countr_one; // expected-error {{no member}} expected-note {{'std::countr_one' is defined in}} expected-note {{'std::countr_one' is a}}
+ std::countr_zero; // expected-error {{no member}} expected-note {{'std::countr_zero' is defined in}} expected-note {{'std::countr_zero' is a}}
+ std::cout; // expected-error {{no member}} expected-note {{'std::cout' is defined in}}
+ std::cref; // expected-error {{no member}} expected-note {{'std::cref' is defined in}} expected-note {{'std::cref' is a}}
+ std::cregex_iterator; // expected-error {{no member}} expected-note {{'std::cregex_iterator' is defined in}} expected-note {{'std::cregex_iterator' is a}}
+ std::cregex_token_iterator; // expected-error {{no member}} expected-note {{'std::cregex_token_iterator' is defined in}} expected-note {{'std::cregex_token_iterator' is a}}
+ std::csub_match; // expected-error {{no member}} expected-note {{'std::csub_match' is defined in}} expected-note {{'std::csub_match' is a}}
+ std::ctime; // expected-error {{no member}} expected-note {{'std::ctime' is defined in}}
+ std::ctype; // expected-error {{no member}} expected-note {{'std::ctype' is defined in}}
+ std::ctype_base; // expected-error {{no member}} expected-note {{'std::ctype_base' is defined in}}
+ std::ctype_byname; // expected-error {{no member}} expected-note {{'std::ctype_byname' is defined in}}
+ std::current_exception; // expected-error {{no member}} expected-note {{'std::current_exception' is defined in}} expected-note {{'std::current_exception' is a}}
+ std::cv_status; // expected-error {{no member}} expected-note {{'std::cv_status' is defined in}} expected-note {{'std::cv_status' is a}}
+ std::cyl_bessel_i; // expected-error {{no member}} expected-note {{'std::cyl_bessel_i' is defined in}} expected-note {{'std::cyl_bessel_i' is a}}
+ std::cyl_bessel_if; // expected-error {{no member}} expected-note {{'std::cyl_bessel_if' is defined in}} expected-note {{'std::cyl_bessel_if' is a}}
+ std::cyl_bessel_il; // expected-error {{no member}} expected-note {{'std::cyl_bessel_il' is defined in}} expected-note {{'std::cyl_bessel_il' is a}}
+ std::cyl_bessel_j; // expected-error {{no member}} expected-note {{'std::cyl_bessel_j' is defined in}} expected-note {{'std::cyl_bessel_j' is a}}
+ std::cyl_bessel_jf; // expected-error {{no member}} expected-note {{'std::cyl_bessel_jf' is defined in}} expected-note {{'std::cyl_bessel_jf' is a}}
+ std::cyl_bessel_jl; // expected-error {{no member}} expected-note {{'std::cyl_bessel_jl' is defined in}} expected-note {{'std::cyl_bessel_jl' is a}}
+ std::cyl_bessel_k; // expected-error {{no member}} expected-note {{'std::cyl_bessel_k' is defined in}} expected-note {{'std::cyl_bessel_k' is a}}
+ std::cyl_bessel_kf; // expected-error {{no member}} expected-note {{'std::cyl_bessel_kf' is defined in}} expected-note {{'std::cyl_bessel_kf' is a}}
+ std::cyl_bessel_kl; // expected-error {{no member}} expected-note {{'std::cyl_bessel_kl' is defined in}} expected-note {{'std::cyl_bessel_kl' is a}}
+ std::cyl_neumann; // expected-error {{no member}} expected-note {{'std::cyl_neumann' is defined in}} expected-note {{'std::cyl_neumann' is a}}
+ std::cyl_neumannf; // expected-error {{no member}} expected-note {{'std::cyl_neumannf' is defined in}} expected-note {{'std::cyl_neumannf' is a}}
+ std::cyl_neumannl; // expected-error {{no member}} expected-note {{'std::cyl_neumannl' is defined in}} expected-note {{'std::cyl_neumannl' is a}}
+ std::dec; // expected-error {{no member}} expected-note {{'std::dec' is defined in}}
+ std::dec; // expected-error {{no member}} expected-note {{'std::dec' is defined in}}
+ std::deca; // expected-error {{no member}} expected-note {{'std::deca' is defined in}} expected-note {{'std::deca' is a}}
+ std::decay; // expected-error {{no member}} expected-note {{'std::decay' is defined in}} expected-note {{'std::decay' is a}}
+ std::decay_t; // expected-error {{no member}} expected-note {{'std::decay_t' is defined in}} expected-note {{'std::decay_t' is a}}
+ std::deci; // expected-error {{no member}} expected-note {{'std::deci' is defined in}} expected-note {{'std::deci' is a}}
+ std::declare_no_pointers; // expected-error {{no member}} expected-note {{'std::declare_no_pointers' is defined in}} expected-note {{'std::declare_no_pointers' is a}}
+ std::declare_reachable; // expected-error {{no member}} expected-note {{'std::declare_reachable' is defined in}} expected-note {{'std::declare_reachable' is a}}
+ std::declval; // expected-error {{no member}} expected-note {{'std::declval' is defined in}} expected-note {{'std::declval' is a}}
+ std::default_accessor; // expected-error {{no member}} expected-note {{'std::default_accessor' is defined in}} expected-note {{'std::default_accessor' is a}}
+ std::default_delete; // expected-error {{no member}} expected-note {{'std::default_delete' is defined in}} expected-note {{'std::default_delete' is a}}
+ std::default_initializable; // expected-error {{no member}} expected-note {{'std::default_initializable' is defined in}} expected-note {{'std::default_initializable' is a}}
+ std::default_random_engine; // expected-error {{no member}} expected-note {{'std::default_random_engine' is defined in}} expected-note {{'std::default_random_engine' is a}}
+ std::default_searcher; // expected-error {{no member}} expected-note {{'std::default_searcher' is defined in}} expected-note {{'std::default_searcher' is a}}
+ std::default_sentinel; // expected-error {{no member}} expected-note {{'std::default_sentinel' is defined in}} expected-note {{'std::default_sentinel' is a}}
+ std::default_sentinel_t; // expected-error {{no member}} expected-note {{'std::default_sentinel_t' is defined in}} expected-note {{'std::default_sentinel_t' is a}}
+ std::defaultfloat; // expected-error {{no member}} expected-note {{'std::defaultfloat' is defined in}} expected-note {{'std::defaultfloat' is a}}
+ std::defaultfloat; // expected-error {{no member}} expected-note {{'std::defaultfloat' is defined in}} expected-note {{'std::defaultfloat' is a}}
+ std::defer_lock; // expected-error {{no member}} expected-note {{'std::defer_lock' is defined in}} expected-note {{'std::defer_lock' is a}}
+ std::defer_lock_t; // expected-error {{no member}} expected-note {{'std::defer_lock_t' is defined in}} expected-note {{'std::defer_lock_t' is a}}
+ std::denorm_absent; // expected-error {{no member}} expected-note {{'std::denorm_absent' is defined in}}
+ std::denorm_indeterminate; // expected-error {{no member}} expected-note {{'std::denorm_indeterminate' is defined in}}
+ std::denorm_present; // expected-error {{no member}} expected-note {{'std::denorm_present' is defined in}}
+ std::deque; // expected-error {{no member}} expected-note {{'std::deque' is defined in}}
+ std::derived_from; // expected-error {{no member}} expected-note {{'std::derived_from' is defined in}} expected-note {{'std::derived_from' is a}}
+ std::destroy; // expected-error {{no member}} expected-note {{'std::destroy' is defined in}} expected-note {{'std::destroy' is a}}
+ std::destroy_at; // expected-error {{no member}} expected-note {{'std::destroy_at' is defined in}} expected-note {{'std::destroy_at' is a}}
+ std::destroy_n; // expected-error {{no member}} expected-note {{'std::destroy_n' is defined in}} expected-note {{'std::destroy_n' is a}}
+ std::destroying_delete; // expected-error {{no member}} expected-note {{'std::destroying_delete' is defined in}} expected-note {{'std::destroying_delete' is a}}
+ std::destroying_delete_t; // expected-error {{no member}} expected-note {{'std::destroying_delete_t' is defined in}} expected-note {{'std::destroying_delete_t' is a}}
+ std::destructible; // expected-error {{no member}} expected-note {{'std::destructible' is defined in}} expected-note {{'std::destructible' is a}}
+ std::dextents; // expected-error {{no member}} expected-note {{'std::dextents' is defined in}} expected-note {{'std::dextents' is a}}
+ std::difftime; // expected-error {{no member}} expected-note {{'std::difftime' is defined in}}
+ std::dims; // expected-error {{no member}} expected-note {{'std::dims' is defined in}} expected-note {{'std::dims' is a}}
+ std::disable_sized_sentinel_for; // expected-error {{no member}} expected-note {{'std::disable_sized_sentinel_for' is defined in}} expected-note {{'std::disable_sized_sentinel_for' is a}}
+ std::discard_block_engine; // expected-error {{no member}} expected-note {{'std::discard_block_engine' is defined in}} expected-note {{'std::discard_block_engine' is a}}
+ std::discrete_distribution; // expected-error {{no member}} expected-note {{'std::discrete_distribution' is defined in}} expected-note {{'std::discrete_distribution' is a}}
+ std::disjunction; // expected-error {{no member}} expected-note {{'std::disjunction' is defined in}} expected-note {{'std::disjunction' is a}}
+ std::disjunction_v; // expected-error {{no member}} expected-note {{'std::disjunction_v' is defined in}} expected-note {{'std::disjunction_v' is a}}
+ std::distance; // expected-error {{no member}} expected-note {{'std::distance' is defined in}}
+ std::div_sat; // expected-error {{no member}} expected-note {{'std::div_sat' is defined in}} expected-note {{'std::div_sat' is a}}
+ std::div_t; // expected-error {{no member}} expected-note {{'std::div_t' is defined in}}
+ std::divides; // expected-error {{no member}} expected-note {{'std::divides' is defined in}}
+ std::domain_error; // expected-error {{no member}} expected-note {{'std::domain_error' is defined in}}
+ std::double_t; // expected-error {{no member}} expected-note {{'std::double_t' is defined in}} expected-note {{'std::double_t' is a}}
+ std::dynamic_extent; // expected-error {{no member}} expected-note {{'std::dynamic_extent' is defined in}} expected-note {{'std::dynamic_extent' is a}}
+ std::dynamic_pointer_cast; // expected-error {{no member}} expected-note {{'std::dynamic_pointer_cast' is defined in}} expected-note {{'std::dynamic_pointer_cast' is a}}
+ std::ellint_1; // expected-error {{no member}} expected-note {{'std::ellint_1' is defined in}} expected-note {{'std::ellint_1' is a}}
+ std::ellint_1f; // expected-error {{no member}} expected-note {{'std::ellint_1f' is defined in}} expected-note {{'std::ellint_1f' is a}}
+ std::ellint_1l; // expected-error {{no member}} expected-note {{'std::ellint_1l' is defined in}} expected-note {{'std::ellint_1l' is a}}
+ std::ellint_2; // expected-error {{no member}} expected-note {{'std::ellint_2' is defined in}} expected-note {{'std::ellint_2' is a}}
+ std::ellint_2f; // expected-error {{no member}} expected-note {{'std::ellint_2f' is defined in}} expected-note {{'std::ellint_2f' is a}}
+ std::ellint_2l; // expected-error {{no member}} expected-note {{'std::ellint_2l' is defined in}} expected-note {{'std::ellint_2l' is a}}
+ std::ellint_3; // expected-error {{no member}} expected-note {{'std::ellint_3' is defined in}} expected-note {{'std::ellint_3' is a}}
+ std::ellint_3f; // expected-error {{no member}} expected-note {{'std::ellint_3f' is defined in}} expected-note {{'std::ellint_3f' is a}}
+ std::ellint_3l; // expected-error {{no member}} expected-note {{'std::ellint_3l' is defined in}} expected-note {{'std::ellint_3l' is a}}
+ std::emit_on_flush; // expected-error {{no member}} expected-note {{'std::emit_on_flush' is defined in}} expected-note {{'std::emit_on_flush' is a}}
+ std::emit_on_flush; // expected-error {{no member}} expected-note {{'std::emit_on_flush' is defined in}} expected-note {{'std::emit_on_flush' is a}}
+ std::enable_if; // expected-error {{no member}} expected-note {{'std::enable_if' is defined in}} expected-note {{'std::enable_if' is a}}
+ std::enable_if_t; // expected-error {{no member}} expected-note {{'std::enable_if_t' is defined in}} expected-note {{'std::enable_if_t' is a}}
+ std::enable_nonlocking_formatter_optimization; // expected-error {{no member}} expected-note {{'std::enable_nonlocking_formatter_optimization' is defined in}} expected-note {{'std::enable_nonlocking_formatter_optimization' is a}}
+ std::enable_shared_from_this; // expected-error {{no member}} expected-note {{'std::enable_shared_from_this' is defined in}} expected-note {{'std::enable_shared_from_this' is a}}
+ std::endian; // expected-error {{no member}} expected-note {{'std::endian' is defined in}} expected-note {{'std::endian' is a}}
+ std::endl; // expected-error {{no member}} expected-note {{'std::endl' is defined in}}
+ std::endl; // expected-error {{no member}} expected-note {{'std::endl' is defined in}}
+ std::ends; // expected-error {{no member}} expected-note {{'std::ends' is defined in}}
+ std::ends; // expected-error {{no member}} expected-note {{'std::ends' is defined in}}
+ std::equal; // expected-error {{no member}} expected-note {{'std::equal' is defined in}}
+ std::equal_range; // expected-error {{no member}} expected-note {{'std::equal_range' is defined in}}
+ std::equal_to; // expected-error {{no member}} expected-note {{'std::equal_to' is defined in}}
+ std::equality_comparable; // expected-error {{no member}} expected-note {{'std::equality_comparable' is defined in}} expected-note {{'std::equality_comparable' is a}}
+ std::equality_comparable_with; // expected-error {{no member}} expected-note {{'std::equality_comparable_with' is defined in}} expected-note {{'std::equality_comparable_with' is a}}
+ std::equivalence_relation; // expected-error {{no member}} expected-note {{'std::equivalence_relation' is defined in}} expected-note {{'std::equivalence_relation' is a}}
+ std::erfcf; // expected-error {{no member}} expected-note {{'std::erfcf' is defined in}} expected-note {{'std::erfcf' is a}}
+ std::erfcl; // expected-error {{no member}} expected-note {{'std::erfcl' is defined in}} expected-note {{'std::erfcl' is a}}
+ std::erff; // expected-error {{no member}} expected-note {{'std::erff' is defined in}} expected-note {{'std::erff' is a}}
+ std::erfl; // expected-error {{no member}} expected-note {{'std::erfl' is defined in}} expected-note {{'std::erfl' is a}}
+ std::errc; // expected-error {{no member}} expected-note {{'std::errc' is defined in}} expected-note {{'std::errc' is a}}
+ std::error_category; // expected-error {{no member}} expected-note {{'std::error_category' is defined in}} expected-note {{'std::error_category' is a}}
+ std::error_code; // expected-error {{no member}} expected-note {{'std::error_code' is defined in}} expected-note {{'std::error_code' is a}}
+ std::error_condition; // expected-error {{no member}} expected-note {{'std::error_condition' is defined in}} expected-note {{'std::error_condition' is a}}
+ std::exa; // expected-error {{no member}} expected-note {{'std::exa' is defined in}} expected-note {{'std::exa' is a}}
+ std::exception; // expected-error {{no member}} expected-note {{'std::exception' is defined in}}
+ std::exception_ptr; // expected-error {{no member}} expected-note {{'std::exception_ptr' is defined in}} expected-note {{'std::exception_ptr' is a}}
+ std::exchange; // expected-error {{no member}} expected-note {{'std::exchange' is defined in}} expected-note {{'std::exchange' is a}}
+ std::exclusive_scan; // expected-error {{no member}} expected-note {{'std::exclusive_scan' is defined in}} expected-note {{'std::exclusive_scan' is a}}
+ std::exit; // expected-error {{no member}} expected-note {{'std::exit' is defined in}}
+ std::exp2f; // expected-error {{no member}} expected-note {{'std::exp2f' is defined in}} expected-note {{'std::exp2f' is a}}
+ std::exp2l; // expected-error {{no member}} expected-note {{'std::exp2l' is defined in}} expected-note {{'std::exp2l' is a}}
+ std::expected; // expected-error {{no member}} expected-note {{'std::expected' is defined in}} expected-note {{'std::expected' is a}}
+ std::expf; // expected-error {{no member}} expected-note {{'std::expf' is defined in}} expected-note {{'std::expf' is a}}
+ std::expint; // expected-error {{no member}} expected-note {{'std::expint' is defined in}} expected-note {{'std::expint' is a}}
+ std::expintf; // expected-error {{no member}} expected-note {{'std::expintf' is defined in}} expected-note {{'std::expintf' is a}}
+ std::expintl; // expected-error {{no member}} expected-note {{'std::expintl' is defined in}} expected-note {{'std::expintl' is a}}
+ std::expl; // expected-error {{no member}} expected-note {{'std::expl' is defined in}} expected-note {{'std::expl' is a}}
+ std::expm1f; // expected-error {{no member}} expected-note {{'std::expm1f' is defined in}} expected-note {{'std::expm1f' is a}}
+ std::expm1l; // expected-error {{no member}} expected-note {{'std::expm1l' is defined in}} expected-note {{'std::expm1l' is a}}
+ std::exponential_distribution; // expected-error {{no member}} expected-note {{'std::exponential_distribution' is defined in}} expected-note {{'std::exponential_distribution' is a}}
+ std::extent; // expected-error {{no member}} expected-note {{'std::extent' is defined in}} expected-note {{'std::extent' is a}}
+ std::extent_v; // expected-error {{no member}} expected-note {{'std::extent_v' is defined in}} expected-note {{'std::extent_v' is a}}
+ std::extents; // expected-error {{no member}} expected-note {{'std::extents' is defined in}} expected-note {{'std::extents' is a}}
+ std::extreme_value_distribution; // expected-error {{no member}} expected-note {{'std::extreme_value_distribution' is defined in}} expected-note {{'std::extreme_value_distribution' is a}}
+ std::fabs; // expected-error {{no member}} expected-note {{'std::fabs' is defined in}}
+ std::fabsf; // expected-error {{no member}} expected-note {{'std::fabsf' is defined in}} expected-note {{'std::fabsf' is a}}
+ std::fabsl; // expected-error {{no member}} expected-note {{'std::fabsl' is defined in}} expected-note {{'std::fabsl' is a}}
+ std::false_type; // expected-error {{no member}} expected-note {{'std::false_type' is defined in}} expected-note {{'std::false_type' is a}}
+ std::fclose; // expected-error {{no member}} expected-note {{'std::fclose' is defined in}}
+ std::fdimf; // expected-error {{no member}} expected-note {{'std::fdimf' is defined in}} expected-note {{'std::fdimf' is a}}
+ std::fdiml; // expected-error {{no member}} expected-note {{'std::fdiml' is defined in}} expected-note {{'std::fdiml' is a}}
+ std::feclearexcept; // expected-error {{no member}} expected-note {{'std::feclearexcept' is defined in}} expected-note {{'std::feclearexcept' is a}}
+ std::fegetenv; // expected-error {{no member}} expected-note {{'std::fegetenv' is defined in}} expected-note {{'std::fegetenv' is a}}
+ std::fegetexceptflag; // expected-error {{no member}} expected-note {{'std::fegetexceptflag' is defined in}} expected-note {{'std::fegetexceptflag' is a}}
+ std::fegetround; // expected-error {{no member}} expected-note {{'std::fegetround' is defined in}} expected-note {{'std::fegetround' is a}}
+ std::feholdexcept; // expected-error {{no member}} expected-note {{'std::feholdexcept' is defined in}} expected-note {{'std::feholdexcept' is a}}
+ std::femto; // expected-error {{no member}} expected-note {{'std::femto' is defined in}} expected-note {{'std::femto' is a}}
+ std::fenv_t; // expected-error {{no member}} expected-note {{'std::fenv_t' is defined in}} expected-note {{'std::fenv_t' is a}}
+ std::feof; // expected-error {{no member}} expected-note {{'std::feof' is defined in}}
+ std::feraiseexcept; // expected-error {{no member}} expected-note {{'std::feraiseexcept' is defined in}} expected-note {{'std::feraiseexcept' is a}}
+ std::ferror; // expected-error {{no member}} expected-note {{'std::ferror' is defined in}}
+ std::fesetenv; // expected-error {{no member}} expected-note {{'std::fesetenv' is defined in}} expected-note {{'std::fesetenv' is a}}
+ std::fesetexceptflag; // expected-error {{no member}} expected-note {{'std::fesetexceptflag' is defined in}} expected-note {{'std::fesetexceptflag' is a}}
+ std::fesetround; // expected-error {{no member}} expected-note {{'std::fesetround' is defined in}} expected-note {{'std::fesetround' is a}}
+ std::fetestexcept; // expected-error {{no member}} expected-note {{'std::fetestexcept' is defined in}} expected-note {{'std::fetestexcept' is a}}
+ std::feupdateenv; // expected-error {{no member}} expected-note {{'std::feupdateenv' is defined in}} expected-note {{'std::feupdateenv' is a}}
+ std::fexcept_t; // expected-error {{no member}} expected-note {{'std::fexcept_t' is defined in}} expected-note {{'std::fexcept_t' is a}}
+ std::fflush; // expected-error {{no member}} expected-note {{'std::fflush' is defined in}}
+ std::fgetc; // expected-error {{no member}} expected-note {{'std::fgetc' is defined in}}
+ std::fgetpos; // expected-error {{no member}} expected-note {{'std::fgetpos' is defined in}}
+ std::fgets; // expected-error {{no member}} expected-note {{'std::fgets' is defined in}}
+ std::fgetwc; // expected-error {{no member}} expected-note {{'std::fgetwc' is defined in}}
+ std::fgetws; // expected-error {{no member}} expected-note {{'std::fgetws' is defined in}}
+ std::filebuf; // expected-error {{no member}} expected-note {{'std::filebuf' is defined in}}
+ std::filebuf; // expected-error {{no member}} expected-note {{'std::filebuf' is defined in}}
+ std::fill; // expected-error {{no member}} expected-note {{'std::fill' is defined in}}
+ std::fill_n; // expected-error {{no member}} expected-note {{'std::fill_n' is defined in}}
+ std::find; // expected-error {{no member}} expected-note {{'std::find' is defined in}}
+ std::find_end; // expected-error {{no member}} expected-note {{'std::find_end' is defined in}}
+ std::find_first_of; // expected-error {{no member}} expected-note {{'std::find_first_of' is defined in}}
+ std::find_if; // expected-error {{no member}} expected-note {{'std::find_if' is defined in}}
+ std::find_if_not; // expected-error {{no member}} expected-note {{'std::find_if_not' is defined in}} expected-note {{'std::find_if_not' is a}}
+ std::fisher_f_distribution; // expected-error {{no member}} expected-note {{'std::fisher_f_distribution' is defined in}} expected-note {{'std::fisher_f_distribution' is a}}
+ std::fixed; // expected-error {{no member}} expected-note {{'std::fixed' is defined in}}
+ std::fixed; // expected-error {{no member}} expected-note {{'std::fixed' is defined in}}
+ std::flat_map; // expected-error {{no member}} expected-note {{'std::flat_map' is defined in}} expected-note {{'std::flat_map' is a}}
+ std::flat_multimap; // expected-error {{no member}} expected-note {{'std::flat_multimap' is defined in}} expected-note {{'std::flat_multimap' is a}}
+ std::flat_multiset; // expected-error {{no member}} expected-note {{'std::flat_multiset' is defined in}} expected-note {{'std::flat_multiset' is a}}
+ std::flat_set; // expected-error {{no member}} expected-note {{'std::flat_set' is defined in}} expected-note {{'std::flat_set' is a}}
+ std::float_denorm_style; // expected-error {{no member}} expected-note {{'std::float_denorm_style' is defined in}}
+ std::float_round_style; // expected-error {{no member}} expected-note {{'std::float_round_style' is defined in}}
+ std::float_t; // expected-error {{no member}} expected-note {{'std::float_t' is defined in}} expected-note {{'std::float_t' is a}}
+ std::floating_point; // expected-error {{no member}} expected-note {{'std::floating_point' is defined in}} expected-note {{'std::floating_point' is a}}
+ std::floorf; // expected-error {{no member}} expected-note {{'std::floorf' is defined in}} expected-note {{'std::floorf' is a}}
+ std::floorl; // expected-error {{no member}} expected-note {{'std::floorl' is defined in}} expected-note {{'std::floorl' is a}}
+ std::flush; // expected-error {{no member}} expected-note {{'std::flush' is defined in}}
+ std::flush; // expected-error {{no member}} expected-note {{'std::flush' is defined in}}
+ std::flush_emit; // expected-error {{no member}} expected-note {{'std::flush_emit' is defined in}} expected-note {{'std::flush_emit' is a}}
+ std::flush_emit; // expected-error {{no member}} expected-note {{'std::flush_emit' is defined in}} expected-note {{'std::flush_emit' is a}}
+ std::fma; // expected-error {{no member}} expected-note {{'std::fma' is defined in}} expected-note {{'std::fma' is a}}
+ std::fmaf; // expected-error {{no member}} expected-note {{'std::fmaf' is defined in}} expected-note {{'std::fmaf' is a}}
+ std::fmal; // expected-error {{no member}} expected-note {{'std::fmal' is defined in}} expected-note {{'std::fmal' is a}}
+ std::fmaxf; // expected-error {{no member}} expected-note {{'std::fmaxf' is defined in}} expected-note {{'std::fmaxf' is a}}
+ std::fmaxl; // expected-error {{no member}} expected-note {{'std::fmaxl' is defined in}} expected-note {{'std::fmaxl' is a}}
+ std::fminf; // expected-error {{no member}} expected-note {{'std::fminf' is defined in}} expected-note {{'std::fminf' is a}}
+ std::fminl; // expected-error {{no member}} expected-note {{'std::fminl' is defined in}} expected-note {{'std::fminl' is a}}
+ std::fmodf; // expected-error {{no member}} expected-note {{'std::fmodf' is defined in}} expected-note {{'std::fmodf' is a}}
+ std::fmodl; // expected-error {{no member}} expected-note {{'std::fmodl' is defined in}} expected-note {{'std::fmodl' is a}}
+ std::fopen; // expected-error {{no member}} expected-note {{'std::fopen' is defined in}}
+ std::for_each; // expected-error {{no member}} expected-note {{'std::for_each' is defined in}}
+ std::for_each_n; // expected-error {{no member}} expected-note {{'std::for_each_n' is defined in}} expected-note {{'std::for_each_n' is a}}
+ std::format; // expected-error {{no member}} expected-note {{'std::format' is defined in}} expected-note {{'std::format' is a}}
+ std::format_args; // expected-error {{no member}} expected-note {{'std::format_args' is defined in}} expected-note {{'std::format_args' is a}}
+ std::format_context; // expected-error {{no member}} expected-note {{'std::format_context' is defined in}} expected-note {{'std::format_context' is a}}
+ std::format_error; // expected-error {{no member}} expected-note {{'std::format_error' is defined in}} expected-note {{'std::format_error' is a}}
+ std::format_kind; // expected-error {{no member}} expected-note {{'std::format_kind' is defined in}} expected-note {{'std::format_kind' is a}}
+ std::format_parse_context; // expected-error {{no member}} expected-note {{'std::format_parse_context' is defined in}} expected-note {{'std::format_parse_context' is a}}
+ std::format_string; // expected-error {{no member}} expected-note {{'std::format_string' is defined in}} expected-note {{'std::format_string' is a}}
+ std::format_to; // expected-error {{no member}} expected-note {{'std::format_to' is defined in}} expected-note {{'std::format_to' is a}}
+ std::format_to_n; // expected-error {{no member}} expected-note {{'std::format_to_n' is defined in}} expected-note {{'std::format_to_n' is a}}
+ std::format_to_n_result; // expected-error {{no member}} expected-note {{'std::format_to_n_result' is defined in}} expected-note {{'std::format_to_n_result' is a}}
+ std::formattable; // expected-error {{no member}} expected-note {{'std::formattable' is defined in}} expected-note {{'std::formattable' is a}}
+ std::formatted_size; // expected-error {{no member}} expected-note {{'std::formatted_size' is defined in}} expected-note {{'std::formatted_size' is a}}
+ std::formatter; // expected-error {{no member}} expected-note {{'std::formatter' is defined in}} expected-note {{'std::formatter' is a}}
+ std::forward; // expected-error {{no member}} expected-note {{'std::forward' is defined in}} expected-note {{'std::forward' is a}}
+ std::forward_as_tuple; // expected-error {{no member}} expected-note {{'std::forward_as_tuple' is defined in}} expected-note {{'std::forward_as_tuple' is a}}
+ std::forward_iterator; // expected-error {{no member}} expected-note {{'std::forward_iterator' is defined in}} expected-note {{'std::forward_iterator' is a}}
+ std::forward_iterator_tag; // expected-error {{no member}} expected-note {{'std::forward_iterator_tag' is defined in}}
+ std::forward_like; // expected-error {{no member}} expected-note {{'std::forward_like' is defined in}} expected-note {{'std::forward_like' is a}}
+ std::forward_list; // expected-error {{no member}} expected-note {{'std::forward_list' is defined in}} expected-note {{'std::forward_list' is a}}
+ std::fpclassify; // expected-error {{no member}} expected-note {{'std::fpclassify' is defined in}} expected-note {{'std::fpclassify' is a}}
+ std::fpos; // expected-error {{no member}} expected-note {{'std::fpos' is defined in}}
+ std::fpos; // expected-error {{no member}} expected-note {{'std::fpos' is defined in}}
+ std::fpos; // expected-error {{no member}} expected-note {{'std::fpos' is defined in}}
+ std::fpos_t; // expected-error {{no member}} expected-note {{'std::fpos_t' is defined in}}
+ std::fprintf; // expected-error {{no member}} expected-note {{'std::fprintf' is defined in}}
+ std::fputc; // expected-error {{no member}} expected-note {{'std::fputc' is defined in}}
+ std::fputs; // expected-error {{no member}} expected-note {{'std::fputs' is defined in}}
+ std::fputwc; // expected-error {{no member}} expected-note {{'std::fputwc' is defined in}}
+ std::fputws; // expected-error {{no member}} expected-note {{'std::fputws' is defined in}}
+ std::fread; // expected-error {{no member}} expected-note {{'std::fread' is defined in}}
+ std::free; // expected-error {{no member}} expected-note {{'std::free' is defined in}}
+ std::freopen; // expected-error {{no member}} expected-note {{'std::freopen' is defined in}}
+ std::frexp; // expected-error {{no member}} expected-note {{'std::frexp' is defined in}}
+ std::frexpf; // expected-error {{no member}} expected-note {{'std::frexpf' is defined in}} expected-note {{'std::frexpf' is a}}
+ std::frexpl; // expected-error {{no member}} expected-note {{'std::frexpl' is defined in}} expected-note {{'std::frexpl' is a}}
+ std::from_chars; // expected-error {{no member}} expected-note {{'std::from_chars' is defined in}} expected-note {{'std::from_chars' is a}}
+ std::from_chars_result; // expected-error {{no member}} expected-note {{'std::from_chars_result' is defined in}} expected-note {{'std::from_chars_result' is a}}
+ std::from_range; // expected-error {{no member}} expected-note {{'std::from_range' is defined in}} expected-note {{'std::from_range' is a}}
+ std::from_range_t; // expected-error {{no member}} expected-note {{'std::from_range_t' is defined in}} expected-note {{'std::from_range_t' is a}}
+ std::front_insert_iterator; // expected-error {{no member}} expected-note {{'std::front_insert_iterator' is defined in}}
+ std::front_inserter; // expected-error {{no member}} expected-note {{'std::front_inserter' is defined in}}
+ std::fscanf; // expected-error {{no member}} expected-note {{'std::fscanf' is defined in}}
+ std::fseek; // expected-error {{no member}} expected-note {{'std::fseek' is defined in}}
+ std::fsetpos; // expected-error {{no member}} expected-note {{'std::fsetpos' is defined in}}
+ std::fstream; // expected-error {{no member}} expected-note {{'std::fstream' is defined in}}
+ std::fstream; // expected-error {{no member}} expected-note {{'std::fstream' is defined in}}
+ std::ftell; // expected-error {{no member}} expected-note {{'std::ftell' is defined in}}
+ std::function; // expected-error {{no member}} expected-note {{'std::function' is defined in}} expected-note {{'std::function' is a}}
+ std::function_ref; // expected-error {{no member}} expected-note {{'std::function_ref' is defined in}} expected-note {{'std::function_ref' is a}}
+ std::future; // expected-error {{no member}} expected-note {{'std::future' is defined in}} expected-note {{'std::future' is a}}
+ std::future_category; // expected-error {{no member}} expected-note {{'std::future_category' is defined in}} expected-note {{'std::future_category' is a}}
+ std::future_errc; // expected-error {{no member}} expected-note {{'std::future_errc' is defined in}} expected-note {{'std::future_errc' is a}}
+ std::future_error; // expected-error {{no member}} expected-note {{'std::future_error' is defined in}} expected-note {{'std::future_error' is a}}
+ std::future_status; // expected-error {{no member}} expected-note {{'std::future_status' is defined in}} expected-note {{'std::future_status' is a}}
+ std::fwide; // expected-error {{no member}} expected-note {{'std::fwide' is defined in}}
+ std::fwprintf; // expected-error {{no member}} expected-note {{'std::fwprintf' is defined in}}
+ std::fwrite; // expected-error {{no member}} expected-note {{'std::fwrite' is defined in}}
+ std::fwscanf; // expected-error {{no member}} expected-note {{'std::fwscanf' is defined in}}
+ std::gamma_distribution; // expected-error {{no member}} expected-note {{'std::gamma_distribution' is defined in}} expected-note {{'std::gamma_distribution' is a}}
+ std::gcd; // expected-error {{no member}} expected-note {{'std::gcd' is defined in}} expected-note {{'std::gcd' is a}}
+ std::generate; // expected-error {{no member}} expected-note {{'std::generate' is defined in}}
+ std::generate_canonical; // expected-error {{no member}} expected-note {{'std::generate_canonical' is defined in}} expected-note {{'std::generate_canonical' is a}}
+ std::generate_n; // expected-error {{no member}} expected-note {{'std::generate_n' is defined in}}
+ std::generator; // expected-error {{no member}} expected-note {{'std::generator' is defined in}} expected-note {{'std::generator' is a}}
+ std::generic_category; // expected-error {{no member}} expected-note {{'std::generic_category' is defined in}} expected-note {{'std::generic_category' is a}}
+ std::geometric_distribution; // expected-error {{no member}} expected-note {{'std::geometric_distribution' is defined in}} expected-note {{'std::geometric_distribution' is a}}
+ std::get_deleter; // expected-error {{no member}} expected-note {{'std::get_deleter' is defined in}} expected-note {{'std::get_deleter' is a}}
+ std::get_if; // expected-error {{no member}} expected-note {{'std::get_if' is defined in}} expected-note {{'std::get_if' is a}}
+ std::get_money; // expected-error {{no member}} expected-note {{'std::get_money' is defined in}} expected-note {{'std::get_money' is a}}
+ std::get_new_handler; // expected-error {{no member}} expected-note {{'std::get_new_handler' is defined in}} expected-note {{'std::get_new_handler' is a}}
+ std::get_pointer_safety; // expected-error {{no member}} expected-note {{'std::get_pointer_safety' is defined in}} expected-note {{'std::get_pointer_safety' is a}}
+ std::get_temporary_buffer; // expected-error {{no member}} expected-note {{'std::get_temporary_buffer' is defined in}}
+ std::get_terminate; // expected-error {{no member}} expected-note {{'std::get_terminate' is defined in}} expected-note {{'std::get_terminate' is a}}
+ std::get_time; // expected-error {{no member}} expected-note {{'std::get_time' is defined in}} expected-note {{'std::get_time' is a}}
+ std::get_unexpected; // expected-error {{no member}} expected-note {{'std::get_unexpected' is defined in}}
+ std::getc; // expected-error {{no member}} expected-note {{'std::getc' is defined in}}
+ std::getchar; // expected-error {{no member}} expected-note {{'std::getchar' is defined in}}
+ std::getenv; // expected-error {{no member}} expected-note {{'std::getenv' is defined in}}
+ std::getline; // expected-error {{no member}} expected-note {{'std::getline' is defined in}}
+ std::gets; // expected-error {{no member}} expected-note {{'std::gets' is defined in}}
+ std::getwc; // expected-error {{no member}} expected-note {{'std::getwc' is defined in}}
+ std::getwchar; // expected-error {{no member}} expected-note {{'std::getwchar' is defined in}}
+ std::giga; // expected-error {{no member}} expected-note {{'std::giga' is defined in}} expected-note {{'std::giga' is a}}
+ std::gmtime; // expected-error {{no member}} expected-note {{'std::gmtime' is defined in}}
+ std::greater; // expected-error {{no member}} expected-note {{'std::greater' is defined in}}
+ std::greater_equal; // expected-error {{no member}} expected-note {{'std::greater_equal' is defined in}}
+ std::gslice; // expected-error {{no member}} expected-note {{'std::gslice' is defined in}}
+ std::gslice_array; // expected-error {{no member}} expected-note {{'std::gslice_array' is defined in}}
+ std::hardware_constructive_interference_size; // expected-error {{no member}} expected-note {{'std::hardware_constructive_interference_size' is defined in}} expected-note {{'std::hardware_constructive_interference_size' is a}}
+ std::hardware_destructive_interference_size; // expected-error {{no member}} expected-note {{'std::hardware_destructive_interference_size' is defined in}} expected-note {{'std::hardware_destructive_interference_size' is a}}
+ std::has_facet; // expected-error {{no member}} expected-note {{'std::has_facet' is defined in}}
+ std::has_single_bit; // expected-error {{no member}} expected-note {{'std::has_single_bit' is defined in}} expected-note {{'std::has_single_bit' is a}}
+ std::has_unique_object_representations; // expected-error {{no member}} expected-note {{'std::has_unique_object_representations' is defined in}} expected-note {{'std::has_unique_object_representations' is a}}
+ std::has_unique_object_representations_v; // expected-error {{no member}} expected-note {{'std::has_unique_object_representations_v' is defined in}} expected-note {{'std::has_unique_object_representations_v' is a}}
+ std::has_virtual_destructor; // expected-error {{no member}} expected-note {{'std::has_virtual_destructor' is defined in}} expected-note {{'std::has_virtual_destructor' is a}}
+ std::has_virtual_destructor_v; // expected-error {{no member}} expected-note {{'std::has_virtual_destructor_v' is defined in}} expected-note {{'std::has_virtual_destructor_v' is a}}
+ std::hecto; // expected-error {{no member}} expected-note {{'std::hecto' is defined in}} expected-note {{'std::hecto' is a}}
+ std::hermite; // expected-error {{no member}} expected-note {{'std::hermite' is defined in}} expected-note {{'std::hermite' is a}}
+ std::hermitef; // expected-error {{no member}} expected-note {{'std::hermitef' is defined in}} expected-note {{'std::hermitef' is a}}
+ std::hermitel; // expected-error {{no member}} expected-note {{'std::hermitel' is defined in}} expected-note {{'std::hermitel' is a}}
+ std::hex; // expected-error {{no member}} expected-note {{'std::hex' is defined in}}
+ std::hex; // expected-error {{no member}} expected-note {{'std::hex' is defined in}}
+ std::hexfloat; // expected-error {{no member}} expected-note {{'std::hexfloat' is defined in}} expected-note {{'std::hexfloat' is a}}
+ std::hexfloat; // expected-error {{no member}} expected-note {{'std::hexfloat' is defined in}} expected-note {{'std::hexfloat' is a}}
+ std::holds_alternative; // expected-error {{no member}} expected-note {{'std::holds_alternative' is defined in}} expected-note {{'std::holds_alternative' is a}}
+ std::hypot; // expected-error {{no member}} expected-note {{'std::hypot' is defined in}} expected-note {{'std::hypot' is a}}
+ std::hypotf; // expected-error {{no member}} expected-note {{'std::hypotf' is defined in}} expected-note {{'std::hypotf' is a}}
+ std::hypotl; // expected-error {{no member}} expected-note {{'std::hypotl' is defined in}} expected-note {{'std::hypotl' is a}}
+ std::identity; // expected-error {{no member}} expected-note {{'std::identity' is defined in}} expected-note {{'std::identity' is a}}
+ std::ifstream; // expected-error {{no member}} expected-note {{'std::ifstream' is defined in}}
+ std::ifstream; // expected-error {{no member}} expected-note {{'std::ifstream' is defined in}}
+ std::ilogb; // expected-error {{no member}} expected-note {{'std::ilogb' is defined in}} expected-note {{'std::ilogb' is a}}
+ std::ilogbf; // expected-error {{no member}} expected-note {{'std::ilogbf' is defined in}} expected-note {{'std::ilogbf' is a}}
+ std::ilogbl; // expected-error {{no member}} expected-note {{'std::ilogbl' is defined in}} expected-note {{'std::ilogbl' is a}}
+ std::imag; // expected-error {{no member}} expected-note {{'std::imag' is defined in}}
+ std::imaxabs; // expected-error {{no member}} expected-note {{'std::imaxabs' is defined in}} expected-note {{'std::imaxabs' is a}}
+ std::imaxdiv; // expected-error {{no member}} expected-note {{'std::imaxdiv' is defined in}} expected-note {{'std::imaxdiv' is a}}
+ std::imaxdiv_t; // expected-error {{no member}} expected-note {{'std::imaxdiv_t' is defined in}} expected-note {{'std::imaxdiv_t' is a}}
+ std::in_place; // expected-error {{no member}} expected-note {{'std::in_place' is defined in}} expected-note {{'std::in_place' is a}}
+ std::in_place_index; // expected-error {{no member}} expected-note {{'std::in_place_index' is defined in}} expected-note {{'std::in_place_index' is a}}
+ std::in_place_index_t; // expected-error {{no member}} expected-note {{'std::in_place_index_t' is defined in}} expected-note {{'std::in_place_index_t' is a}}
+ std::in_place_t; // expected-error {{no member}} expected-note {{'std::in_place_t' is defined in}} expected-note {{'std::in_place_t' is a}}
+ std::in_place_type; // expected-error {{no member}} expected-note {{'std::in_place_type' is defined in}} expected-note {{'std::in_place_type' is a}}
+ std::in_place_type_t; // expected-error {{no member}} expected-note {{'std::in_place_type_t' is defined in}} expected-note {{'std::in_place_type_t' is a}}
+ std::in_range; // expected-error {{no member}} expected-note {{'std::in_range' is defined in}} expected-note {{'std::in_range' is a}}
+ std::includes; // expected-error {{no member}} expected-note {{'std::includes' is defined in}}
+ std::inclusive_scan; // expected-error {{no member}} expected-note {{'std::inclusive_scan' is defined in}} expected-note {{'std::inclusive_scan' is a}}
+ std::incrementable; // expected-error {{no member}} expected-note {{'std::incrementable' is defined in}} expected-note {{'std::incrementable' is a}}
+ std::incrementable_traits; // expected-error {{no member}} expected-note {{'std::incrementable_traits' is defined in}} expected-note {{'std::incrementable_traits' is a}}
+ std::independent_bits_engine; // expected-error {{no member}} expected-note {{'std::independent_bits_engine' is defined in}} expected-note {{'std::independent_bits_engine' is a}}
+ std::index_sequence; // expected-error {{no member}} expected-note {{'std::index_sequence' is defined in}} expected-note {{'std::index_sequence' is a}}
+ std::index_sequence_for; // expected-error {{no member}} expected-note {{'std::index_sequence_for' is defined in}} expected-note {{'std::index_sequence_for' is a}}
+ std::indirect_array; // expected-error {{no member}} expected-note {{'std::indirect_array' is defined in}}
+ std::indirect_binary_predicate; // expected-error {{no member}} expected-note {{'std::indirect_binary_predicate' is defined in}} expected-note {{'std::indirect_binary_predicate' is a}}
+ std::indirect_equivalence_relation; // expected-error {{no member}} expected-note {{'std::indirect_equivalence_relation' is defined in}} expected-note {{'std::indirect_equivalence_relation' is a}}
+ std::indirect_result_t; // expected-error {{no member}} expected-note {{'std::indirect_result_t' is defined in}} expected-note {{'std::indirect_result_t' is a}}
+ std::indirect_strict_weak_order; // expected-error {{no member}} expected-note {{'std::indirect_strict_weak_order' is defined in}} expected-note {{'std::indirect_strict_weak_order' is a}}
+ std::indirect_unary_predicate; // expected-error {{no member}} expected-note {{'std::indirect_unary_predicate' is defined in}} expected-note {{'std::indirect_unary_predicate' is a}}
+ std::indirectly_comparable; // expected-error {{no member}} expected-note {{'std::indirectly_comparable' is defined in}} expected-note {{'std::indirectly_comparable' is a}}
+ std::indirectly_copyable; // expected-error {{no member}} expected-note {{'std::indirectly_copyable' is defined in}} expected-note {{'std::indirectly_copyable' is a}}
+ std::indirectly_copyable_storable; // expected-error {{no member}} expected-note {{'std::indirectly_copyable_storable' is defined in}} expected-note {{'std::indirectly_copyable_storable' is a}}
+ std::indirectly_movable; // expected-error {{no member}} expected-note {{'std::indirectly_movable' is defined in}} expected-note {{'std::indirectly_movable' is a}}
+ std::indirectly_movable_storable; // expected-error {{no member}} expected-note {{'std::indirectly_movable_storable' is defined in}} expected-note {{'std::indirectly_movable_storable' is a}}
+ std::indirectly_readable; // expected-error {{no member}} expected-note {{'std::indirectly_readable' is defined in}} expected-note {{'std::indirectly_readable' is a}}
+ std::indirectly_readable_traits; // expected-error {{no member}} expected-note {{'std::indirectly_readable_traits' is defined in}} expected-note {{'std::indirectly_readable_traits' is a}}
+ std::indirectly_regular_unary_invocable; // expected-error {{no member}} expected-note {{'std::indirectly_regular_unary_invocable' is defined in}} expected-note {{'std::indirectly_regular_unary_invocable' is a}}
+ std::indirectly_swappable; // expected-error {{no member}} expected-note {{'std::indirectly_swappable' is defined in}} expected-note {{'std::indirectly_swappable' is a}}
+ std::indirectly_unary_invocable; // expected-error {{no member}} expected-note {{'std::indirectly_unary_invocable' is defined in}} expected-note {{'std::indirectly_unary_invocable' is a}}
+ std::indirectly_writable; // expected-error {{no member}} expected-note {{'std::indirectly_writable' is defined in}} expected-note {{'std::indirectly_writable' is a}}
+ std::initializer_list; // expected-error {{no member}} expected-note {{'std::initializer_list' is defined in}} expected-note {{'std::initializer_list' is a}}
+ std::inner_product; // expected-error {{no member}} expected-note {{'std::inner_product' is defined in}}
+ std::inout_ptr; // expected-error {{no member}} expected-note {{'std::inout_ptr' is defined in}} expected-note {{'std::inout_ptr' is a}}
+ std::inout_ptr_t; // expected-error {{no member}} expected-note {{'std::inout_ptr_t' is defined in}} expected-note {{'std::inout_ptr_t' is a}}
+ std::inplace_merge; // expected-error {{no member}} expected-note {{'std::inplace_merge' is defined in}}
+ std::inplace_vector; // expected-error {{no member}} expected-note {{'std::inplace_vector' is defined in}} expected-note {{'std::inplace_vector' is a}}
+ std::input_iterator; // expected-error {{no member}} expected-note {{'std::input_iterator' is defined in}} expected-note {{'std::input_iterator' is a}}
+ std::input_iterator_tag; // expected-error {{no member}} expected-note {{'std::input_iterator_tag' is defined in}}
+ std::input_or_output_iterator; // expected-error {{no member}} expected-note {{'std::input_or_output_iterator' is defined in}} expected-note {{'std::input_or_output_iterator' is a}}
+ std::insert_iterator; // expected-error {{no member}} expected-note {{'std::insert_iterator' is defined in}}
+ std::inserter; // expected-error {{no member}} expected-note {{'std::inserter' is defined in}}
+ std::int16_t; // expected-error {{no member}} expected-note {{'std::int16_t' is defined in}} expected-note {{'std::int16_t' is a}}
+ std::int32_t; // expected-error {{no member}} expected-note {{'std::int32_t' is defined in}} expected-note {{'std::int32_t' is a}}
+ std::int64_t; // expected-error {{no member}} expected-note {{'std::int64_t' is defined in}} expected-note {{'std::int64_t' is a}}
+ std::int8_t; // expected-error {{no member}} expected-note {{'std::int8_t' is defined in}} expected-note {{'std::int8_t' is a}}
+ std::int_fast16_t; // expected-error {{no member}} expected-note {{'std::int_fast16_t' is defined in}} expected-note {{'std::int_fast16_t' is a}}
+ std::int_fast32_t; // expected-error {{no member}} expected-note {{'std::int_fast32_t' is defined in}} expected-note {{'std::int_fast32_t' is a}}
+ std::int_fast64_t; // expected-error {{no member}} expected-note {{'std::int_fast64_t' is defined in}} expected-note {{'std::int_fast64_t' is a}}
+ std::int_fast8_t; // expected-error {{no member}} expected-note {{'std::int_fast8_t' is defined in}} expected-note {{'std::int_fast8_t' is a}}
+ std::int_least16_t; // expected-error {{no member}} expected-note {{'std::int_least16_t' is defined in}} expected-note {{'std::int_least16_t' is a}}
+ std::int_least32_t; // expected-error {{no member}} expected-note {{'std::int_least32_t' is defined in}} expected-note {{'std::int_least32_t' is a}}
+ std::int_least64_t; // expected-error {{no member}} expected-note {{'std::int_least64_t' is defined in}} expected-note {{'std::int_least64_t' is a}}
+ std::int_least8_t; // expected-error {{no member}} expected-note {{'std::int_least8_t' is defined in}} expected-note {{'std::int_least8_t' is a}}
+ std::integer_sequence; // expected-error {{no member}} expected-note {{'std::integer_sequence' is defined in}} expected-note {{'std::integer_sequence' is a}}
+ std::integral; // expected-error {{no member}} expected-note {{'std::integral' is defined in}} expected-note {{'std::integral' is a}}
+ std::integral_constant; // expected-error {{no member}} expected-note {{'std::integral_constant' is defined in}} expected-note {{'std::integral_constant' is a}}
+ std::internal; // expected-error {{no member}} expected-note {{'std::internal' is defined in}}
+ std::internal; // expected-error {{no member}} expected-note {{'std::internal' is defined in}}
+ std::intmax_t; // expected-error {{no member}} expected-note {{'std::intmax_t' is defined in}} expected-note {{'std::intmax_t' is a}}
+ std::intptr_t; // expected-error {{no member}} expected-note {{'std::intptr_t' is defined in}} expected-note {{'std::intptr_t' is a}}
+ std::invalid_argument; // expected-error {{no member}} expected-note {{'std::invalid_argument' is defined in}}
+ std::invocable; // expected-error {{no member}} expected-note {{'std::invocable' is defined in}} expected-note {{'std::invocable' is a}}
+ std::invoke; // expected-error {{no member}} expected-note {{'std::invoke' is defined in}} expected-note {{'std::invoke' is a}}
+ std::invoke_r; // expected-error {{no member}} expected-note {{'std::invoke_r' is defined in}} expected-note {{'std::invoke_r' is a}}
+ std::invoke_result; // expected-error {{no member}} expected-note {{'std::invoke_result' is defined in}} expected-note {{'std::invoke_result' is a}}
+ std::invoke_result_t; // expected-error {{no member}} expected-note {{'std::invoke_result_t' is defined in}} expected-note {{'std::invoke_result_t' is a}}
+ std::io_errc; // expected-error {{no member}} expected-note {{'std::io_errc' is defined in}} expected-note {{'std::io_errc' is a}}
+ std::io_errc; // expected-error {{no member}} expected-note {{'std::io_errc' is defined in}} expected-note {{'std::io_errc' is a}}
+ std::io_state; // expected-error {{no member}} expected-note {{'std::io_state' is defined in}}
+ std::io_state; // expected-error {{no member}} expected-note {{'std::io_state' is defined in}}
+ std::ios; // expected-error {{no member}} expected-note {{'std::ios' is defined in}}
+ std::ios; // expected-error {{no member}} expected-note {{'std::ios' is defined in}}
+ std::ios; // expected-error {{no member}} expected-note {{'std::ios' is defined in}}
+ std::ios_base; // expected-error {{no member}} expected-note {{'std::ios_base' is defined in}}
+ std::ios_base; // expected-error {{no member}} expected-note {{'std::ios_base' is defined in}}
+ std::iostream; // expected-error {{no member}} expected-note {{'std::iostream' is defined in}}
+ std::iostream; // expected-error {{no member}} expected-note {{'std::iostream' is defined in}}
+ std::iostream; // expected-error {{no member}} expected-note {{'std::iostream' is defined in}}
+ std::iostream_category; // expected-error {{no member}} expected-note {{'std::iostream_category' is defined in}} expected-note {{'std::iostream_category' is a}}
+ std::iostream_category; // expected-error {{no member}} expected-note {{'std::iostream_category' is defined in}} expected-note {{'std::iostream_category' is a}}
+ std::iota; // expected-error {{no member}} expected-note {{'std::iota' is defined in}} expected-note {{'std::iota' is a}}
+ std::is_abstract; // expected-error {{no member}} expected-note {{'std::is_abstract' is defined in}} expected-note {{'std::is_abstract' is a}}
+ std::is_abstract_v; // expected-error {{no member}} expected-note {{'std::is_abstract_v' is defined in}} expected-note {{'std::is_abstract_v' is a}}
+ std::is_aggregate; // expected-error {{no member}} expected-note {{'std::is_aggregate' is defined in}} expected-note {{'std::is_aggregate' is a}}
+ std::is_aggregate_v; // expected-error {{no member}} expected-note {{'std::is_aggregate_v' is defined in}} expected-note {{'std::is_aggregate_v' is a}}
+ std::is_arithmetic; // expected-error {{no member}} expected-note {{'std::is_arithmetic' is defined in}} expected-note {{'std::is_arithmetic' is a}}
+ std::is_arithmetic_v; // expected-error {{no member}} expected-note {{'std::is_arithmetic_v' is defined in}} expected-note {{'std::is_arithmetic_v' is a}}
+ std::is_array; // expected-error {{no member}} expected-note {{'std::is_array' is defined in}} expected-note {{'std::is_array' is a}}
+ std::is_array_v; // expected-error {{no member}} expected-note {{'std::is_array_v' is defined in}} expected-note {{'std::is_array_v' is a}}
+ std::is_assignable; // expected-error {{no member}} expected-note {{'std::is_assignable' is defined in}} expected-note {{'std::is_assignable' is a}}
+ std::is_assignable_v; // expected-error {{no member}} expected-note {{'std::is_assignable_v' is defined in}} expected-note {{'std::is_assignable_v' is a}}
+ std::is_base_of; // expected-error {{no member}} expected-note {{'std::is_base_of' is defined in}} expected-note {{'std::is_base_of' is a}}
+ std::is_base_of_v; // expected-error {{no member}} expected-note {{'std::is_base_of_v' is defined in}} expected-note {{'std::is_base_of_v' is a}}
+ std::is_bind_expression; // expected-error {{no member}} expected-note {{'std::is_bind_expression' is defined in}} expected-note {{'std::is_bind_expression' is a}}
+ std::is_bind_expression_v; // expected-error {{no member}} expected-note {{'std::is_bind_expression_v' is defined in}} expected-note {{'std::is_bind_expression_v' is a}}
+ std::is_bounded_array; // expected-error {{no member}} expected-note {{'std::is_bounded_array' is defined in}} expected-note {{'std::is_bounded_array' is a}}
+ std::is_bounded_array_v; // expected-error {{no member}} expected-note {{'std::is_bounded_array_v' is defined in}} expected-note {{'std::is_bounded_array_v' is a}}
+ std::is_class; // expected-error {{no member}} expected-note {{'std::is_class' is defined in}} expected-note {{'std::is_class' is a}}
+ std::is_class_v; // expected-error {{no member}} expected-note {{'std::is_class_v' is defined in}} expected-note {{'std::is_class_v' is a}}
+ std::is_compound; // expected-error {{no member}} expected-note {{'std::is_compound' is defined in}} expected-note {{'std::is_compound' is a}}
+ std::is_compound_v; // expected-error {{no member}} expected-note {{'std::is_compound_v' is defined in}} expected-note {{'std::is_compound_v' is a}}
+ std::is_const; // expected-error {{no member}} expected-note {{'std::is_const' is defined in}} expected-note {{'std::is_const' is a}}
+ std::is_const_v; // expected-error {{no member}} expected-note {{'std::is_const_v' is defined in}} expected-note {{'std::is_const_v' is a}}
+ std::is_constant_evaluated; // expected-error {{no member}} expected-note {{'std::is_constant_evaluated' is defined in}} expected-note {{'std::is_constant_evaluated' is a}}
+ std::is_constructible; // expected-error {{no member}} expected-note {{'std::is_constructible' is defined in}} expected-note {{'std::is_constructible' is a}}
+ std::is_constructible_v; // expected-error {{no member}} expected-note {{'std::is_constructible_v' is defined in}} expected-note {{'std::is_constructible_v' is a}}
+ std::is_convertible; // expected-error {{no member}} expected-note {{'std::is_convertible' is defined in}} expected-note {{'std::is_convertible' is a}}
+ std::is_convertible_v; // expected-error {{no member}} expected-note {{'std::is_convertible_v' is defined in}} expected-note {{'std::is_convertible_v' is a}}
+ std::is_copy_assignable; // expected-error {{no member}} expected-note {{'std::is_copy_assignable' is defined in}} expected-note {{'std::is_copy_assignable' is a}}
+ std::is_copy_assignable_v; // expected-error {{no member}} expected-note {{'std::is_copy_assignable_v' is defined in}} expected-note {{'std::is_copy_assignable_v' is a}}
+ std::is_copy_constructible; // expected-error {{no member}} expected-note {{'std::is_copy_constructible' is defined in}} expected-note {{'std::is_copy_constructible' is a}}
+ std::is_copy_constructible_v; // expected-error {{no member}} expected-note {{'std::is_copy_constructible_v' is defined in}} expected-note {{'std::is_copy_constructible_v' is a}}
+ std::is_corresponding_member; // expected-error {{no member}} expected-note {{'std::is_corresponding_member' is defined in}} expected-note {{'std::is_corresponding_member' is a}}
+ std::is_debugger_present; // expected-error {{no member}} expected-note {{'std::is_debugger_present' is defined in}} expected-note {{'std::is_debugger_present' is a}}
+ std::is_default_constructible; // expected-error {{no member}} expected-note {{'std::is_default_constructible' is defined in}} expected-note {{'std::is_default_constructible' is a}}
+ std::is_default_constructible_v; // expected-error {{no member}} expected-note {{'std::is_default_constructible_v' is defined in}} expected-note {{'std::is_default_constructible_v' is a}}
+ std::is_destructible; // expected-error {{no member}} expected-note {{'std::is_destructible' is defined in}} expected-note {{'std::is_destructible' is a}}
+ std::is_destructible_v; // expected-error {{no member}} expected-note {{'std::is_destructible_v' is defined in}} expected-note {{'std::is_destructible_v' is a}}
+ std::is_empty; // expected-error {{no member}} expected-note {{'std::is_empty' is defined in}} expected-note {{'std::is_empty' is a}}
+ std::is_empty_v; // expected-error {{no member}} expected-note {{'std::is_empty_v' is defined in}} expected-note {{'std::is_empty_v' is a}}
+ std::is_enum; // expected-error {{no member}} expected-note {{'std::is_enum' is defined in}} expected-note {{'std::is_enum' is a}}
+ std::is_enum_v; // expected-error {{no member}} expected-note {{'std::is_enum_v' is defined in}} expected-note {{'std::is_enum_v' is a}}
+ std::is_eq; // expected-error {{no member}} expected-note {{'std::is_eq' is defined in}} expected-note {{'std::is_eq' is a}}
+ std::is_error_code_enum; // expected-error {{no member}} expected-note {{'std::is_error_code_enum' is defined in}} expected-note {{'std::is_error_code_enum' is a}}
+ std::is_error_condition_enum; // expected-error {{no member}} expected-note {{'std::is_error_condition_enum' is defined in}} expected-note {{'std::is_error_condition_enum' is a}}
+ std::is_error_condition_enum_v; // expected-error {{no member}} expected-note {{'std::is_error_condition_enum_v' is defined in}} expected-note {{'std::is_error_condition_enum_v' is a}}
+ std::is_execution_policy; // expected-error {{no member}} expected-note {{'std::is_execution_policy' is defined in}} expected-note {{'std::is_execution_policy' is a}}
+ std::is_execution_policy_v; // expected-error {{no member}} expected-note {{'std::is_execution_policy_v' is defined in}} expected-note {{'std::is_execution_policy_v' is a}}
+ std::is_final; // expected-error {{no member}} expected-note {{'std::is_final' is defined in}} expected-note {{'std::is_final' is a}}
+ std::is_final_v; // expected-error {{no member}} expected-note {{'std::is_final_v' is defined in}} expected-note {{'std::is_final_v' is a}}
+ std::is_floating_point; // expected-error {{no member}} expected-note {{'std::is_floating_point' is defined in}} expected-note {{'std::is_floating_point' is a}}
+ std::is_floating_point_v; // expected-error {{no member}} expected-note {{'std::is_floating_point_v' is defined in}} expected-note {{'std::is_floating_point_v' is a}}
+ std::is_function; // expected-error {{no member}} expected-note {{'std::is_function' is defined in}} expected-note {{'std::is_function' is a}}
+ std::is_function_v; // expected-error {{no member}} expected-note {{'std::is_function_v' is defined in}} expected-note {{'std::is_function_v' is a}}
+ std::is_fundamental; // expected-error {{no member}} expected-note {{'std::is_fundamental' is defined in}} expected-note {{'std::is_fundamental' is a}}
+ std::is_fundamental_v; // expected-error {{no member}} expected-note {{'std::is_fundamental_v' is defined in}} expected-note {{'std::is_fundamental_v' is a}}
+ std::is_gt; // expected-error {{no member}} expected-note {{'std::is_gt' is defined in}} expected-note {{'std::is_gt' is a}}
+ std::is_gteq; // expected-error {{no member}} expected-note {{'std::is_gteq' is defined in}} expected-note {{'std::is_gteq' is a}}
+ std::is_heap; // expected-error {{no member}} expected-note {{'std::is_heap' is defined in}} expected-note {{'std::is_heap' is a}}
+ std::is_heap_until; // expected-error {{no member}} expected-note {{'std::is_heap_until' is defined in}} expected-note {{'std::is_heap_until' is a}}
+ std::is_implicit_lifetime; // expected-error {{no member}} expected-note {{'std::is_implicit_lifetime' is defined in}} expected-note {{'std::is_implicit_lifetime' is a}}
+ std::is_integral; // expected-error {{no member}} expected-note {{'std::is_integral' is defined in}} expected-note {{'std::is_integral' is a}}
+ std::is_integral_v; // expected-error {{no member}} expected-note {{'std::is_integral_v' is defined in}} expected-note {{'std::is_integral_v' is a}}
+ std::is_invocable; // expected-error {{no member}} expected-note {{'std::is_invocable' is defined in}} expected-note {{'std::is_invocable' is a}}
+ std::is_invocable_r; // expected-error {{no member}} expected-note {{'std::is_invocable_r' is defined in}} expected-note {{'std::is_invocable_r' is a}}
+ std::is_invocable_r_v; // expected-error {{no member}} expected-note {{'std::is_invocable_r_v' is defined in}} expected-note {{'std::is_invocable_r_v' is a}}
+ std::is_invocable_v; // expected-error {{no member}} expected-note {{'std::is_invocable_v' is defined in}} expected-note {{'std::is_invocable_v' is a}}
+ std::is_layout_compatible; // expected-error {{no member}} expected-note {{'std::is_layout_compatible' is defined in}} expected-note {{'std::is_layout_compatible' is a}}
+ std::is_layout_compatible_v; // expected-error {{no member}} expected-note {{'std::is_layout_compatible_v' is defined in}} expected-note {{'std::is_layout_compatible_v' is a}}
+ std::is_literal_type; // expected-error {{no member}} expected-note {{'std::is_literal_type' is defined in}} expected-note {{'std::is_literal_type' is a}}
+ std::is_literal_type_v; // expected-error {{no member}} expected-note {{'std::is_literal_type_v' is defined in}} expected-note {{'std::is_literal_type_v' is a}}
+ std::is_lt; // expected-error {{no member}} expected-note {{'std::is_lt' is defined in}} expected-note {{'std::is_lt' is a}}
+ std::is_lteq; // expected-error {{no member}} expected-note {{'std::is_lteq' is defined in}} expected-note {{'std::is_lteq' is a}}
+ std::is_lvalue_reference; // expected-error {{no member}} expected-note {{'std::is_lvalue_reference' is defined in}} expected-note {{'std::is_lvalue_reference' is a}}
+ std::is_lvalue_reference_v; // expected-error {{no member}} expected-note {{'std::is_lvalue_reference_v' is defined in}} expected-note {{'std::is_lvalue_reference_v' is a}}
+ std::is_member_function_pointer; // expected-error {{no member}} expected-note {{'std::is_member_function_pointer' is defined in}} expected-note {{'std::is_member_function_pointer' is a}}
+ std::is_member_function_pointer_v; // expected-error {{no member}} expected-note {{'std::is_member_function_pointer_v' is defined in}} expected-note {{'std::is_member_function_pointer_v' is a}}
+ std::is_member_object_pointer; // expected-error {{no member}} expected-note {{'std::is_member_object_pointer' is defined in}} expected-note {{'std::is_member_object_pointer' is a}}
+ std::is_member_object_pointer_v; // expected-error {{no member}} expected-note {{'std::is_member_object_pointer_v' is defined in}} expected-note {{'std::is_member_object_pointer_v' is a}}
+ std::is_member_pointer; // expected-error {{no member}} expected-note {{'std::is_member_pointer' is defined in}} expected-note {{'std::is_member_pointer' is a}}
+ std::is_member_pointer_v; // expected-error {{no member}} expected-note {{'std::is_member_pointer_v' is defined in}} expected-note {{'std::is_member_pointer_v' is a}}
+ std::is_move_assignable; // expected-error {{no member}} expected-note {{'std::is_move_assignable' is defined in}} expected-note {{'std::is_move_assignable' is a}}
+ std::is_move_assignable_v; // expected-error {{no member}} expected-note {{'std::is_move_assignable_v' is defined in}} expected-note {{'std::is_move_assignable_v' is a}}
+ std::is_move_constructible; // expected-error {{no member}} expected-note {{'std::is_move_constructible' is defined in}} expected-note {{'std::is_move_constructible' is a}}
+ std::is_move_constructible_v; // expected-error {{no member}} expected-note {{'std::is_move_constructible_v' is defined in}} expected-note {{'std::is_move_constructible_v' is a}}
+ std::is_neq; // expected-error {{no member}} expected-note {{'std::is_neq' is defined in}} expected-note {{'std::is_neq' is a}}
+ std::is_nothrow_assignable; // expected-error {{no member}} expected-note {{'std::is_nothrow_assignable' is defined in}} expected-note {{'std::is_nothrow_assignable' is a}}
+ std::is_nothrow_assignable_v; // expected-error {{no member}} expected-note {{'std::is_nothrow_assignable_v' is defined in}} expected-note {{'std::is_nothrow_assignable_v' is a}}
+ std::is_nothrow_constructible; // expected-error {{no member}} expected-note {{'std::is_nothrow_constructible' is defined in}} expected-note {{'std::is_nothrow_constructible' is a}}
+ std::is_nothrow_constructible_v; // expected-error {{no member}} expected-note {{'std::is_nothrow_constructible_v' is defined in}} expected-note {{'std::is_nothrow_constructible_v' is a}}
+ std::is_nothrow_convertible; // expected-error {{no member}} expected-note {{'std::is_nothrow_convertible' is defined in}} expected-note {{'std::is_nothrow_convertible' is a}}
+ std::is_nothrow_convertible_v; // expected-error {{no member}} expected-note {{'std::is_nothrow_convertible_v' is defined in}} expected-note {{'std::is_nothrow_convertible_v' is a}}
+ std::is_nothrow_copy_assignable; // expected-error {{no member}} expected-note {{'std::is_nothrow_copy_assignable' is defined in}} expected-note {{'std::is_nothrow_copy_assignable' is a}}
+ std::is_nothrow_copy_assignable_v; // expected-error {{no member}} expected-note {{'std::is_nothrow_copy_assignable_v' is defined in}} expected-note {{'std::is_nothrow_copy_assignable_v' is a}}
+ std::is_nothrow_copy_constructible; // expected-error {{no member}} expected-note {{'std::is_nothrow_copy_constructible' is defined in}} expected-note {{'std::is_nothrow_copy_constructible' is a}}
+ std::is_nothrow_copy_constructible_v; // expected-error {{no member}} expected-note {{'std::is_nothrow_copy_constructible_v' is defined in}} expected-note {{'std::is_nothrow_copy_constructible_v' is a}}
+ std::is_nothrow_default_constructible; // expected-error {{no member}} expected-note {{'std::is_nothrow_default_constructible' is defined in}} expected-note {{'std::is_nothrow_default_constructible' is a}}
+ std::is_nothrow_default_constructible_v; // expected-error {{no member}} expected-note {{'std::is_nothrow_default_constructible_v' is defined in}} expected-note {{'std::is_nothrow_default_constructible_v' is a}}
+ std::is_nothrow_destructible; // expected-error {{no member}} expected-note {{'std::is_nothrow_destructible' is defined in}} expected-note {{'std::is_nothrow_destructible' is a}}
+ std::is_nothrow_destructible_v; // expected-error {{no member}} expected-note {{'std::is_nothrow_destructible_v' is defined in}} expected-note {{'std::is_nothrow_destructible_v' is a}}
+ std::is_nothrow_invocable; // expected-error {{no member}} expected-note {{'std::is_nothrow_invocable' is defined in}} expected-note {{'std::is_nothrow_invocable' is a}}
+ std::is_nothrow_invocable_r; // expected-error {{no member}} expected-note {{'std::is_nothrow_invocable_r' is defined in}} expected-note {{'std::is_nothrow_invocable_r' is a}}
+ std::is_nothrow_invocable_r_v; // expected-error {{no member}} expected-note {{'std::is_nothrow_invocable_r_v' is defined in}} expected-note {{'std::is_nothrow_invocable_r_v' is a}}
+ std::is_nothrow_invocable_v; // expected-error {{no member}} expected-note {{'std::is_nothrow_invocable_v' is defined in}} expected-note {{'std::is_nothrow_invocable_v' is a}}
+ std::is_nothrow_move_assignable; // expected-error {{no member}} expected-note {{'std::is_nothrow_move_assignable' is defined in}} expected-note {{'std::is_nothrow_move_assignable' is a}}
+ std::is_nothrow_move_assignable_v; // expected-error {{no member}} expected-note {{'std::is_nothrow_move_assignable_v' is defined in}} expected-note {{'std::is_nothrow_move_assignable_v' is a}}
+ std::is_nothrow_move_constructible; // expected-error {{no member}} expected-note {{'std::is_nothrow_move_constructible' is defined in}} expected-note {{'std::is_nothrow_move_constructible' is a}}
+ std::is_nothrow_move_constructible_v; // expected-error {{no member}} expected-note {{'std::is_nothrow_move_constructible_v' is defined in}} expected-note {{'std::is_nothrow_move_constructible_v' is a}}
+ std::is_nothrow_swappable; // expected-error {{no member}} expected-note {{'std::is_nothrow_swappable' is defined in}} expected-note {{'std::is_nothrow_swappable' is a}}
+ std::is_nothrow_swappable_v; // expected-error {{no member}} expected-note {{'std::is_nothrow_swappable_v' is defined in}} expected-note {{'std::is_nothrow_swappable_v' is a}}
+ std::is_nothrow_swappable_with; // expected-error {{no member}} expected-note {{'std::is_nothrow_swappable_with' is defined in}} expected-note {{'std::is_nothrow_swappable_with' is a}}
+ std::is_nothrow_swappable_with_v; // expected-error {{no member}} expected-note {{'std::is_nothrow_swappable_with_v' is defined in}} expected-note {{'std::is_nothrow_swappable_with_v' is a}}
+ std::is_null_pointer; // expected-error {{no member}} expected-note {{'std::is_null_pointer' is defined in}} expected-note {{'std::is_null_pointer' is a}}
+ std::is_null_pointer_v; // expected-error {{no member}} expected-note {{'std::is_null_pointer_v' is defined in}} expected-note {{'std::is_null_pointer_v' is a}}
+ std::is_object; // expected-error {{no member}} expected-note {{'std::is_object' is defined in}} expected-note {{'std::is_object' is a}}
+ std::is_object_v; // expected-error {{no member}} expected-note {{'std::is_object_v' is defined in}} expected-note {{'std::is_object_v' is a}}
+ std::is_partitioned; // expected-error {{no member}} expected-note {{'std::is_partitioned' is defined in}} expected-note {{'std::is_partitioned' is a}}
+ std::is_permutation; // expected-error {{no member}} expected-note {{'std::is_permutation' is defined in}} expected-note {{'std::is_permutation' is a}}
+ std::is_placeholder; // expected-error {{no member}} expected-note {{'std::is_placeholder' is defined in}} expected-note {{'std::is_placeholder' is a}}
+ std::is_placeholder_v; // expected-error {{no member}} expected-note {{'std::is_placeholder_v' is defined in}} expected-note {{'std::is_placeholder_v' is a}}
+ std::is_pod; // expected-error {{no member}} expected-note {{'std::is_pod' is defined in}} expected-note {{'std::is_pod' is a}}
+ std::is_pod_v; // expected-error {{no member}} expected-note {{'std::is_pod_v' is defined in}} expected-note {{'std::is_pod_v' is a}}
+ std::is_pointer; // expected-error {{no member}} expected-note {{'std::is_pointer' is defined in}} expected-note {{'std::is_pointer' is a}}
+ std::is_pointer_interconvertible_base_of; // expected-error {{no member}} expected-note {{'std::is_pointer_interconvertible_base_of' is defined in}} expected-note {{'std::is_pointer_interconvertible_base_of' is a}}
+ std::is_pointer_interconvertible_base_of_v; // expected-error {{no member}} expected-note {{'std::is_pointer_interconvertible_base_of_v' is defined in}} expected-note {{'std::is_pointer_interconvertible_base_of_v' is a}}
+ std::is_pointer_interconvertible_with_class; // expected-error {{no member}} expected-note {{'std::is_pointer_interconvertible_with_class' is defined in}} expected-note {{'std::is_pointer_interconvertible_with_class' is a}}
+ std::is_pointer_v; // expected-error {{no member}} expected-note {{'std::is_pointer_v' is defined in}} expected-note {{'std::is_pointer_v' is a}}
+ std::is_polymorphic; // expected-error {{no member}} expected-note {{'std::is_polymorphic' is defined in}} expected-note {{'std::is_polymorphic' is a}}
+ std::is_polymorphic_v; // expected-error {{no member}} expected-note {{'std::is_polymorphic_v' is defined in}} expected-note {{'std::is_polymorphic_v' is a}}
+ std::is_reference; // expected-error {{no member}} expected-note {{'std::is_reference' is defined in}} expected-note {{'std::is_reference' is a}}
+ std::is_reference_v; // expected-error {{no member}} expected-note {{'std::is_reference_v' is defined in}} expected-note {{'std::is_reference_v' is a}}
+ std::is_rvalue_reference; // expected-error {{no member}} expected-note {{'std::is_rvalue_reference' is defined in}} expected-note {{'std::is_rvalue_reference' is a}}
+ std::is_rvalue_reference_v; // expected-error {{no member}} expected-note {{'std::is_rvalue_reference_v' is defined in}} expected-note {{'std::is_rvalue_reference_v' is a}}
+ std::is_same; // expected-error {{no member}} expected-note {{'std::is_same' is defined in}} expected-note {{'std::is_same' is a}}
+ std::is_same_v; // expected-error {{no member}} expected-note {{'std::is_same_v' is defined in}} expected-note {{'std::is_same_v' is a}}
+ std::is_scalar; // expected-error {{no member}} expected-note {{'std::is_scalar' is defined in}} expected-note {{'std::is_scalar' is a}}
+ std::is_scalar_v; // expected-error {{no member}} expected-note {{'std::is_scalar_v' is defined in}} expected-note {{'std::is_scalar_v' is a}}
+ std::is_scoped_enum; // expected-error {{no member}} expected-note {{'std::is_scoped_enum' is defined in}} expected-note {{'std::is_scoped_enum' is a}}
+ std::is_scoped_enum_v; // expected-error {{no member}} expected-note {{'std::is_scoped_enum_v' is defined in}} expected-note {{'std::is_scoped_enum_v' is a}}
+ std::is_signed; // expected-error {{no member}} expected-note {{'std::is_signed' is defined in}} expected-note {{'std::is_signed' is a}}
+ std::is_signed_v; // expected-error {{no member}} expected-note {{'std::is_signed_v' is defined in}} expected-note {{'std::is_signed_v' is a}}
+ std::is_sorted; // expected-error {{no member}} expected-note {{'std::is_sorted' is defined in}} expected-note {{'std::is_sorted' is a}}
+ std::is_sorted_until; // expected-error {{no member}} expected-note {{'std::is_sorted_until' is defined in}} expected-note {{'std::is_sorted_until' is a}}
+ std::is_standard_layout; // expected-error {{no member}} expected-note {{'std::is_standard_layout' is defined in}} expected-note {{'std::is_standard_layout' is a}}
+ std::is_standard_layout_v; // expected-error {{no member}} expected-note {{'std::is_standard_layout_v' is defined in}} expected-note {{'std::is_standard_layout_v' is a}}
+ std::is_swappable; // expected-error {{no member}} expected-note {{'std::is_swappable' is defined in}} expected-note {{'std::is_swappable' is a}}
+ std::is_swappable_v; // expected-error {{no member}} expected-note {{'std::is_swappable_v' is defined in}} expected-note {{'std::is_swappable_v' is a}}
+ std::is_swappable_with; // expected-error {{no member}} expected-note {{'std::is_swappable_with' is defined in}} expected-note {{'std::is_swappable_with' is a}}
+ std::is_swappable_with_v; // expected-error {{no member}} expected-note {{'std::is_swappable_with_v' is defined in}} expected-note {{'std::is_swappable_with_v' is a}}
+ std::is_trivial; // expected-error {{no member}} expected-note {{'std::is_trivial' is defined in}} expected-note {{'std::is_trivial' is a}}
+ std::is_trivial_v; // expected-error {{no member}} expected-note {{'std::is_trivial_v' is defined in}} expected-note {{'std::is_trivial_v' is a}}
+ std::is_trivially_assignable; // expected-error {{no member}} expected-note {{'std::is_trivially_assignable' is defined in}} expected-note {{'std::is_trivially_assignable' is a}}
+ std::is_trivially_assignable_v; // expected-error {{no member}} expected-note {{'std::is_trivially_assignable_v' is defined in}} expected-note {{'std::is_trivially_assignable_v' is a}}
+ std::is_trivially_constructible; // expected-error {{no member}} expected-note {{'std::is_trivially_constructible' is defined in}} expected-note {{'std::is_trivially_constructible' is a}}
+ std::is_trivially_constructible_v; // expected-error {{no member}} expected-note {{'std::is_trivially_constructible_v' is defined in}} expected-note {{'std::is_trivially_constructible_v' is a}}
+ std::is_trivially_copy_assignable; // expected-error {{no member}} expected-note {{'std::is_trivially_copy_assignable' is defined in}} expected-note {{'std::is_trivially_copy_assignable' is a}}
+ std::is_trivially_copy_assignable_v; // expected-error {{no member}} expected-note {{'std::is_trivially_copy_assignable_v' is defined in}} expected-note {{'std::is_trivially_copy_assignable_v' is a}}
+ std::is_trivially_copy_constructible; // expected-error {{no member}} expected-note {{'std::is_trivially_copy_constructible' is defined in}} expected-note {{'std::is_trivially_copy_constructible' is a}}
+ std::is_trivially_copy_constructible_v; // expected-error {{no member}} expected-note {{'std::is_trivially_copy_constructible_v' is defined in}} expected-note {{'std::is_trivially_copy_constructible_v' is a}}
+ std::is_trivially_copyable; // expected-error {{no member}} expected-note {{'std::is_trivially_copyable' is defined in}} expected-note {{'std::is_trivially_copyable' is a}}
+ std::is_trivially_copyable_v; // expected-error {{no member}} expected-note {{'std::is_trivially_copyable_v' is defined in}} expected-note {{'std::is_trivially_copyable_v' is a}}
+ std::is_trivially_default_constructible; // expected-error {{no member}} expected-note {{'std::is_trivially_default_constructible' is defined in}} expected-note {{'std::is_trivially_default_constructible' is a}}
+ std::is_trivially_default_constructible_v; // expected-error {{no member}} expected-note {{'std::is_trivially_default_constructible_v' is defined in}} expected-note {{'std::is_trivially_default_constructible_v' is a}}
+ std::is_trivially_destructible; // expected-error {{no member}} expected-note {{'std::is_trivially_destructible' is defined in}} expected-note {{'std::is_trivially_destructible' is a}}
+ std::is_trivially_destructible_v; // expected-error {{no member}} expected-note {{'std::is_trivially_destructible_v' is defined in}} expected-note {{'std::is_trivially_destructible_v' is a}}
+ std::is_trivially_move_assignable; // expected-error {{no member}} expected-note {{'std::is_trivially_move_assignable' is defined in}} expected-note {{'std::is_trivially_move_assignable' is a}}
+ std::is_trivially_move_assignable_v; // expected-error {{no member}} expected-note {{'std::is_trivially_move_assignable_v' is defined in}} expected-note {{'std::is_trivially_move_assignable_v' is a}}
+ std::is_trivially_move_constructible; // expected-error {{no member}} expected-note {{'std::is_trivially_move_constructible' is defined in}} expected-note {{'std::is_trivially_move_constructible' is a}}
+ std::is_trivially_move_constructible_v; // expected-error {{no member}} expected-note {{'std::is_trivially_move_constructible_v' is defined in}} expected-note {{'std::is_trivially_move_constructible_v' is a}}
+ std::is_unbounded_array; // expected-error {{no member}} expected-note {{'std::is_unbounded_array' is defined in}} expected-note {{'std::is_unbounded_array' is a}}
+ std::is_unbounded_array_v; // expected-error {{no member}} expected-note {{'std::is_unbounded_array_v' is defined in}} expected-note {{'std::is_unbounded_array_v' is a}}
+ std::is_union; // expected-error {{no member}} expected-note {{'std::is_union' is defined in}} expected-note {{'std::is_union' is a}}
+ std::is_union_v; // expected-error {{no member}} expected-note {{'std::is_union_v' is defined in}} expected-note {{'std::is_union_v' is a}}
+ std::is_unsigned; // expected-error {{no member}} expected-note {{'std::is_unsigned' is defined in}} expected-note {{'std::is_unsigned' is a}}
+ std::is_unsigned_v; // expected-error {{no member}} expected-note {{'std::is_unsigned_v' is defined in}} expected-note {{'std::is_unsigned_v' is a}}
+ std::is_virtual_base_of; // expected-error {{no member}} expected-note {{'std::is_virtual_base_of' is defined in}} expected-note {{'std::is_virtual_base_of' is a}}
+ std::is_virtual_base_of_v; // expected-error {{no member}} expected-note {{'std::is_virtual_base_of_v' is defined in}} expected-note {{'std::is_virtual_base_of_v' is a}}
+ std::is_void; // expected-error {{no member}} expected-note {{'std::is_void' is defined in}} expected-note {{'std::is_void' is a}}
+ std::is_void_v; // expected-error {{no member}} expected-note {{'std::is_void_v' is defined in}} expected-note {{'std::is_void_v' is a}}
+ std::is_volatile; // expected-error {{no member}} expected-note {{'std::is_volatile' is defined in}} expected-note {{'std::is_volatile' is a}}
+ std::is_volatile_v; // expected-error {{no member}} expected-note {{'std::is_volatile_v' is defined in}} expected-note {{'std::is_volatile_v' is a}}
+ std::is_within_lifetime; // expected-error {{no member}} expected-note {{'std::is_within_lifetime' is defined in}} expected-note {{'std::is_within_lifetime' is a}}
+ std::isalnum; // expected-error {{no member}} expected-note {{'std::isalnum' is defined in}}
+ std::isalpha; // expected-error {{no member}} expected-note {{'std::isalpha' is defined in}}
+ std::isblank; // expected-error {{no member}} expected-note {{'std::isblank' is defined in}} expected-note {{'std::isblank' is a}}
+ std::iscntrl; // expected-error {{no member}} expected-note {{'std::iscntrl' is defined in}}
+ std::isdigit; // expected-error {{no member}} expected-note {{'std::isdigit' is defined in}}
+ std::isgraph; // expected-error {{no member}} expected-note {{'std::isgraph' is defined in}}
+ std::isgreater; // expected-error {{no member}} expected-note {{'std::isgreater' is defined in}} expected-note {{'std::isgreater' is a}}
+ std::isgreaterequal; // expected-error {{no member}} expected-note {{'std::isgreaterequal' is defined in}} expected-note {{'std::isgreaterequal' is a}}
+ std::isless; // expected-error {{no member}} expected-note {{'std::isless' is defined in}} expected-note {{'std::isless' is a}}
+ std::islessequal; // expected-error {{no member}} expected-note {{'std::islessequal' is defined in}} expected-note {{'std::islessequal' is a}}
+ std::islessgreater; // expected-error {{no member}} expected-note {{'std::islessgreater' is defined in}} expected-note {{'std::islessgreater' is a}}
+ std::islower; // expected-error {{no member}} expected-note {{'std::islower' is defined in}}
+ std::ispanstream; // expected-error {{no member}} expected-note {{'std::ispanstream' is defined in}} expected-note {{'std::ispanstream' is a}}
+ std::ispanstream; // expected-error {{no member}} expected-note {{'std::ispanstream' is defined in}} expected-note {{'std::ispanstream' is a}}
+ std::isprint; // expected-error {{no member}} expected-note {{'std::isprint' is defined in}}
+ std::ispunct; // expected-error {{no member}} expected-note {{'std::ispunct' is defined in}}
+ std::isspace; // expected-error {{no member}} expected-note {{'std::isspace' is defined in}}
+ std::istream; // expected-error {{no member}} expected-note {{'std::istream' is defined in}}
+ std::istream; // expected-error {{no member}} expected-note {{'std::istream' is defined in}}
+ std::istream; // expected-error {{no member}} expected-note {{'std::istream' is defined in}}
+ std::istream_iterator; // expected-error {{no member}} expected-note {{'std::istream_iterator' is defined in}}
+ std::istreambuf_iterator; // expected-error {{no member}} expected-note {{'std::istreambuf_iterator' is defined in}}
+ std::istreambuf_iterator; // expected-error {{no member}} expected-note {{'std::istreambuf_iterator' is defined in}}
+ std::istringstream; // expected-error {{no member}} expected-note {{'std::istringstream' is defined in}}
+ std::istringstream; // expected-error {{no member}} expected-note {{'std::istringstream' is defined in}}
+ std::istrstream; // expected-error {{no member}} expected-note {{'std::istrstream' is defined in}}
+ std::isunordered; // expected-error {{no member}} expected-note {{'std::isunordered' is defined in}} expected-note {{'std::isunordered' is a}}
+ std::isupper; // expected-error {{no member}} expected-note {{'std::isupper' is defined in}}
+ std::iswalnum; // expected-error {{no member}} expected-note {{'std::iswalnum' is defined in}}
+ std::iswalpha; // expected-error {{no member}} expected-note {{'std::iswalpha' is defined in}}
+ std::iswblank; // expected-error {{no member}} expected-note {{'std::iswblank' is defined in}} expected-note {{'std::iswblank' is a}}
+ std::iswcntrl; // expected-error {{no member}} expected-note {{'std::iswcntrl' is defined in}}
+ std::iswctype; // expected-error {{no member}} expected-note {{'std::iswctype' is defined in}}
+ std::iswdigit; // expected-error {{no member}} expected-note {{'std::iswdigit' is defined in}}
+ std::iswgraph; // expected-error {{no member}} expected-note {{'std::iswgraph' is defined in}}
+ std::iswlower; // expected-error {{no member}} expected-note {{'std::iswlower' is defined in}}
+ std::iswprint; // expected-error {{no member}} expected-note {{'std::iswprint' is defined in}}
+ std::iswpunct; // expected-error {{no member}} expected-note {{'std::iswpunct' is defined in}}
+ std::iswspace; // expected-error {{no member}} expected-note {{'std::iswspace' is defined in}}
+ std::iswupper; // expected-error {{no member}} expected-note {{'std::iswupper' is defined in}}
+ std::iswxdigit; // expected-error {{no member}} expected-note {{'std::iswxdigit' is defined in}}
+ std::isxdigit; // expected-error {{no member}} expected-note {{'std::isxdigit' is defined in}}
+ std::iter_common_reference_t; // expected-error {{no member}} expected-note {{'std::iter_common_reference_t' is defined in}} expected-note {{'std::iter_common_reference_t' is a}}
+ std::iter_const_reference_t; // expected-error {{no member}} expected-note {{'std::iter_const_reference_t' is defined in}} expected-note {{'std::iter_const_reference_t' is a}}
+ std::iter_difference_t; // expected-error {{no member}} expected-note {{'std::iter_difference_t' is defined in}} expected-note {{'std::iter_difference_t' is a}}
+ std::iter_reference_t; // expected-error {{no member}} expected-note {{'std::iter_reference_t' is defined in}} expected-note {{'std::iter_reference_t' is a}}
+ std::iter_rvalue_reference_t; // expected-error {{no member}} expected-note {{'std::iter_rvalue_reference_t' is defined in}} expected-note {{'std::iter_rvalue_reference_t' is a}}
+ std::iter_swap; // expected-error {{no member}} expected-note {{'std::iter_swap' is defined in}}
+ std::iter_value_t; // expected-error {{no member}} expected-note {{'std::iter_value_t' is defined in}} expected-note {{'std::iter_value_t' is a}}
+ std::iterator; // expected-error {{no member}} expected-note {{'std::iterator' is defined in}}
+ std::iterator_traits; // expected-error {{no member}} expected-note {{'std::iterator_traits' is defined in}}
+ std::jmp_buf; // expected-error {{no member}} expected-note {{'std::jmp_buf' is defined in}}
+ std::jthread; // expected-error {{no member}} expected-note {{'std::jthread' is defined in}} expected-note {{'std::jthread' is a}}
+ std::kill_dependency; // expected-error {{no member}} expected-note {{'std::kill_dependency' is defined in}} expected-note {{'std::kill_dependency' is a}}
+ std::kilo; // expected-error {{no member}} expected-note {{'std::kilo' is defined in}} expected-note {{'std::kilo' is a}}
+ std::knuth_b; // expected-error {{no member}} expected-note {{'std::knuth_b' is defined in}} expected-note {{'std::knuth_b' is a}}
+ std::labs; // expected-error {{no member}} expected-note {{'std::labs' is defined in}}
+ std::laguerre; // expected-error {{no member}} expected-note {{'std::laguerre' is defined in}} expected-note {{'std::laguerre' is a}}
+ std::laguerref; // expected-error {{no member}} expected-note {{'std::laguerref' is defined in}} expected-note {{'std::laguerref' is a}}
+ std::laguerrel; // expected-error {{no member}} expected-note {{'std::laguerrel' is defined in}} expected-note {{'std::laguerrel' is a}}
+ std::latch; // expected-error {{no member}} expected-note {{'std::latch' is defined in}} expected-note {{'std::latch' is a}}
+ std::launch; // expected-error {{no member}} expected-note {{'std::launch' is defined in}} expected-note {{'std::launch' is a}}
+ std::launder; // expected-error {{no member}} expected-note {{'std::launder' is defined in}} expected-note {{'std::launder' is a}}
+ std::layout_left; // expected-error {{no member}} expected-note {{'std::layout_left' is defined in}} expected-note {{'std::layout_left' is a}}
+ std::layout_left_padded; // expected-error {{no member}} expected-note {{'std::layout_left_padded' is defined in}} expected-note {{'std::layout_left_padded' is a}}
+ std::layout_right; // expected-error {{no member}} expected-note {{'std::layout_right' is defined in}} expected-note {{'std::layout_right' is a}}
+ std::layout_right_padded; // expected-error {{no member}} expected-note {{'std::layout_right_padded' is defined in}} expected-note {{'std::layout_right_padded' is a}}
+ std::layout_stride; // expected-error {{no member}} expected-note {{'std::layout_stride' is defined in}} expected-note {{'std::layout_stride' is a}}
+ std::lcm; // expected-error {{no member}} expected-note {{'std::lcm' is defined in}} expected-note {{'std::lcm' is a}}
+ std::lconv; // expected-error {{no member}} expected-note {{'std::lconv' is defined in}}
+ std::ldexp; // expected-error {{no member}} expected-note {{'std::ldexp' is defined in}}
+ std::ldexpf; // expected-error {{no member}} expected-note {{'std::ldexpf' is defined in}} expected-note {{'std::ldexpf' is a}}
+ std::ldexpl; // expected-error {{no member}} expected-note {{'std::ldexpl' is defined in}} expected-note {{'std::ldexpl' is a}}
+ std::ldiv; // expected-error {{no member}} expected-note {{'std::ldiv' is defined in}}
+ std::ldiv_t; // expected-error {{no member}} expected-note {{'std::ldiv_t' is defined in}}
+ std::left; // expected-error {{no member}} expected-note {{'std::left' is defined in}}
+ std::left; // expected-error {{no member}} expected-note {{'std::left' is defined in}}
+ std::legendre; // expected-error {{no member}} expected-note {{'std::legendre' is defined in}} expected-note {{'std::legendre' is a}}
+ std::legendref; // expected-error {{no member}} expected-note {{'std::legendref' is defined in}} expected-note {{'std::legendref' is a}}
+ std::legendrel; // expected-error {{no member}} expected-note {{'std::legendrel' is defined in}} expected-note {{'std::legendrel' is a}}
+ std::length_error; // expected-error {{no member}} expected-note {{'std::length_error' is defined in}}
+ std::lerp; // expected-error {{no member}} expected-note {{'std::lerp' is defined in}} expected-note {{'std::lerp' is a}}
+ std::less; // expected-error {{no member}} expected-note {{'std::less' is defined in}}
+ std::less_equal; // expected-error {{no member}} expected-note {{'std::less_equal' is defined in}}
+ std::lexicographical_compare; // expected-error {{no member}} expected-note {{'std::lexicographical_compare' is defined in}}
+ std::lexicographical_compare_three_way; // expected-error {{no member}} expected-note {{'std::lexicographical_compare_three_way' is defined in}} expected-note {{'std::lexicographical_compare_three_way' is a}}
+ std::lgammaf; // expected-error {{no member}} expected-note {{'std::lgammaf' is defined in}} expected-note {{'std::lgammaf' is a}}
+ std::lgammal; // expected-error {{no member}} expected-note {{'std::lgammal' is defined in}} expected-note {{'std::lgammal' is a}}
+ std::linear_congruential_engine; // expected-error {{no member}} expected-note {{'std::linear_congruential_engine' is defined in}} expected-note {{'std::linear_congruential_engine' is a}}
+ std::list; // expected-error {{no member}} expected-note {{'std::list' is defined in}}
+ std::llabs; // expected-error {{no member}} expected-note {{'std::llabs' is defined in}} expected-note {{'std::llabs' is a}}
+ std::lldiv; // expected-error {{no member}} expected-note {{'std::lldiv' is defined in}} expected-note {{'std::lldiv' is a}}
+ std::lldiv_t; // expected-error {{no member}} expected-note {{'std::lldiv_t' is defined in}} expected-note {{'std::lldiv_t' is a}}
+ std::llrint; // expected-error {{no member}} expected-note {{'std::llrint' is defined in}} expected-note {{'std::llrint' is a}}
+ std::llrintf; // expected-error {{no member}} expected-note {{'std::llrintf' is defined in}} expected-note {{'std::llrintf' is a}}
+ std::llrintl; // expected-error {{no member}} expected-note {{'std::llrintl' is defined in}} expected-note {{'std::llrintl' is a}}
+ std::llround; // expected-error {{no member}} expected-note {{'std::llround' is defined in}} expected-note {{'std::llround' is a}}
+ std::llroundf; // expected-error {{no member}} expected-note {{'std::llroundf' is defined in}} expected-note {{'std::llroundf' is a}}
+ std::llroundl; // expected-error {{no member}} expected-note {{'std::llroundl' is defined in}} expected-note {{'std::llroundl' is a}}
+ std::locale; // expected-error {{no member}} expected-note {{'std::locale' is defined in}}
+ std::localeconv; // expected-error {{no member}} expected-note {{'std::localeconv' is defined in}}
+ std::localtime; // expected-error {{no member}} expected-note {{'std::localtime' is defined in}}
+ std::lock; // expected-error {{no member}} expected-note {{'std::lock' is defined in}} expected-note {{'std::lock' is a}}
+ std::lock_guard; // expected-error {{no member}} expected-note {{'std::lock_guard' is defined in}} expected-note {{'std::lock_guard' is a}}
+ std::log10f; // expected-error {{no member}} expected-note {{'std::log10f' is defined in}} expected-note {{'std::log10f' is a}}
+ std::log10l; // expected-error {{no member}} expected-note {{'std::log10l' is defined in}} expected-note {{'std::log10l' is a}}
+ std::log1pf; // expected-error {{no member}} expected-note {{'std::log1pf' is defined in}} expected-note {{'std::log1pf' is a}}
+ std::log1pl; // expected-error {{no member}} expected-note {{'std::log1pl' is defined in}} expected-note {{'std::log1pl' is a}}
+ std::log2f; // expected-error {{no member}} expected-note {{'std::log2f' is defined in}} expected-note {{'std::log2f' is a}}
+ std::log2l; // expected-error {{no member}} expected-note {{'std::log2l' is defined in}} expected-note {{'std::log2l' is a}}
+ std::logbf; // expected-error {{no member}} expected-note {{'std::logbf' is defined in}} expected-note {{'std::logbf' is a}}
+ std::logbl; // expected-error {{no member}} expected-note {{'std::logbl' is defined in}} expected-note {{'std::logbl' is a}}
+ std::logf; // expected-error {{no member}} expected-note {{'std::logf' is defined in}} expected-note {{'std::logf' is a}}
+ std::logic_error; // expected-error {{no member}} expected-note {{'std::logic_error' is defined in}}
+ std::logical_and; // expected-error {{no member}} expected-note {{'std::logical_and' is defined in}}
+ std::logical_not; // expected-error {{no member}} expected-note {{'std::logical_not' is defined in}}
+ std::logical_or; // expected-error {{no member}} expected-note {{'std::logical_or' is defined in}}
+ std::logl; // expected-error {{no member}} expected-note {{'std::logl' is defined in}} expected-note {{'std::logl' is a}}
+ std::lognormal_distribution; // expected-error {{no member}} expected-note {{'std::lognormal_distribution' is defined in}} expected-note {{'std::lognormal_distribution' is a}}
+ std::longjmp; // expected-error {{no member}} expected-note {{'std::longjmp' is defined in}}
+ std::lower_bound; // expected-error {{no member}} expected-note {{'std::lower_bound' is defined in}}
+ std::lrint; // expected-error {{no member}} expected-note {{'std::lrint' is defined in}} expected-note {{'std::lrint' is a}}
+ std::lrintf; // expected-error {{no member}} expected-note {{'std::lrintf' is defined in}} expected-note {{'std::lrintf' is a}}
+ std::lrintl; // expected-error {{no member}} expected-note {{'std::lrintl' is defined in}} expected-note {{'std::lrintl' is a}}
+ std::lround; // expected-error {{no member}} expected-note {{'std::lround' is defined in}} expected-note {{'std::lround' is a}}
+ std::lroundf; // expected-error {{no member}} expected-note {{'std::lroundf' is defined in}} expected-note {{'std::lroundf' is a}}
+ std::lroundl; // expected-error {{no member}} expected-note {{'std::lroundl' is defined in}} expected-note {{'std::lroundl' is a}}
+ std::make_any; // expected-error {{no member}} expected-note {{'std::make_any' is defined in}} expected-note {{'std::make_any' is a}}
+ std::make_const_iterator; // expected-error {{no member}} expected-note {{'std::make_const_iterator' is defined in}} expected-note {{'std::make_const_iterator' is a}}
+ std::make_const_sentinel; // expected-error {{no member}} expected-note {{'std::make_const_sentinel' is defined in}} expected-note {{'std::make_const_sentinel' is a}}
+ std::make_exception_ptr; // expected-error {{no member}} expected-note {{'std::make_exception_ptr' is defined in}} expected-note {{'std::make_exception_ptr' is a}}
+ std::make_format_args; // expected-error {{no member}} expected-note {{'std::make_format_args' is defined in}} expected-note {{'std::make_format_args' is a}}
+ std::make_from_tuple; // expected-error {{no member}} expected-note {{'std::make_from_tuple' is defined in}} expected-note {{'std::make_from_tuple' is a}}
+ std::make_heap; // expected-error {{no member}} expected-note {{'std::make_heap' is defined in}}
+ std::make_index_sequence; // expected-error {{no member}} expected-note {{'std::make_index_sequence' is defined in}} expected-note {{'std::make_index_sequence' is a}}
+ std::make_integer_sequence; // expected-error {{no member}} expected-note {{'std::make_integer_sequence' is defined in}} expected-note {{'std::make_integer_sequence' is a}}
+ std::make_move_iterator; // expected-error {{no member}} expected-note {{'std::make_move_iterator' is defined in}} expected-note {{'std::make_move_iterator' is a}}
+ std::make_obj_using_allocator; // expected-error {{no member}} expected-note {{'std::make_obj_using_allocator' is defined in}} expected-note {{'std::make_obj_using_allocator' is a}}
+ std::make_optional; // expected-error {{no member}} expected-note {{'std::make_optional' is defined in}} expected-note {{'std::make_optional' is a}}
+ std::make_pair; // expected-error {{no member}} expected-note {{'std::make_pair' is defined in}}
+ std::make_reverse_iterator; // expected-error {{no member}} expected-note {{'std::make_reverse_iterator' is defined in}} expected-note {{'std::make_reverse_iterator' is a}}
+ std::make_shared; // expected-error {{no member}} expected-note {{'std::make_shared' is defined in}} expected-note {{'std::make_shared' is a}}
+ std::make_shared_for_overwrite; // expected-error {{no member}} expected-note {{'std::make_shared_for_overwrite' is defined in}} expected-note {{'std::make_shared_for_overwrite' is a}}
+ std::make_signed; // expected-error {{no member}} expected-note {{'std::make_signed' is defined in}} expected-note {{'std::make_signed' is a}}
+ std::make_signed_t; // expected-error {{no member}} expected-note {{'std::make_signed_t' is defined in}} expected-note {{'std::make_signed_t' is a}}
+ std::make_tuple; // expected-error {{no member}} expected-note {{'std::make_tuple' is defined in}} expected-note {{'std::make_tuple' is a}}
+ std::make_unique; // expected-error {{no member}} expected-note {{'std::make_unique' is defined in}} expected-note {{'std::make_unique' is a}}
+ std::make_unique_for_overwrite; // expected-error {{no member}} expected-note {{'std::make_unique_for_overwrite' is defined in}} expected-note {{'std::make_unique_for_overwrite' is a}}
+ std::make_unsigned; // expected-error {{no member}} expected-note {{'std::make_unsigned' is defined in}} expected-note {{'std::make_unsigned' is a}}
+ std::make_unsigned_t; // expected-error {{no member}} expected-note {{'std::make_unsigned_t' is defined in}} expected-note {{'std::make_unsigned_t' is a}}
+ std::make_wformat_args; // expected-error {{no member}} expected-note {{'std::make_wformat_args' is defined in}} expected-note {{'std::make_wformat_args' is a}}
+ std::malloc; // expected-error {{no member}} expected-note {{'std::malloc' is defined in}}
+ std::map; // expected-error {{no member}} expected-note {{'std::map' is defined in}}
+ std::mask_array; // expected-error {{no member}} expected-note {{'std::mask_array' is defined in}}
+ std::match_results; // expected-error {{no member}} expected-note {{'std::match_results' is defined in}} expected-note {{'std::match_results' is a}}
+ std::max; // expected-error {{no member}} expected-note {{'std::max' is defined in}}
+ std::max_align_t; // expected-error {{no member}} expected-note {{'std::max_align_t' is defined in}} expected-note {{'std::max_align_t' is a}}
+ std::max_element; // expected-error {{no member}} expected-note {{'std::max_element' is defined in}}
+ std::mblen; // expected-error {{no member}} expected-note {{'std::mblen' is defined in}}
+ std::mbrlen; // expected-error {{no member}} expected-note {{'std::mbrlen' is defined in}}
+ std::mbrtoc16; // expected-error {{no member}} expected-note {{'std::mbrtoc16' is defined in}} expected-note {{'std::mbrtoc16' is a}}
+ std::mbrtoc32; // expected-error {{no member}} expected-note {{'std::mbrtoc32' is defined in}} expected-note {{'std::mbrtoc32' is a}}
+ std::mbrtoc8; // expected-error {{no member}} expected-note {{'std::mbrtoc8' is defined in}} expected-note {{'std::mbrtoc8' is a}}
+ std::mbrtowc; // expected-error {{no member}} expected-note {{'std::mbrtowc' is defined in}}
+ std::mbsinit; // expected-error {{no member}} expected-note {{'std::mbsinit' is defined in}}
+ std::mbsrtowcs; // expected-error {{no member}} expected-note {{'std::mbsrtowcs' is defined in}}
+ std::mbstowcs; // expected-error {{no member}} expected-note {{'std::mbstowcs' is defined in}}
+ std::mbtowc; // expected-error {{no member}} expected-note {{'std::mbtowc' is defined in}}
+ std::mdspan; // expected-error {{no member}} expected-note {{'std::mdspan' is defined in}} expected-note {{'std::mdspan' is a}}
+ std::mega; // expected-error {{no member}} expected-note {{'std::mega' is defined in}} expected-note {{'std::mega' is a}}
+ std::mem_fn; // expected-error {{no member}} expected-note {{'std::mem_fn' is defined in}} expected-note {{'std::mem_fn' is a}}
+ std::mem_fun; // expected-error {{no member}} expected-note {{'std::mem_fun' is defined in}}
+ std::mem_fun1_ref_t; // expected-error {{no member}} expected-note {{'std::mem_fun1_ref_t' is defined in}}
+ std::mem_fun1_t; // expected-error {{no member}} expected-note {{'std::mem_fun1_t' is defined in}}
+ std::mem_fun_ref; // expected-error {{no member}} expected-note {{'std::mem_fun_ref' is defined in}}
+ std::mem_fun_ref_t; // expected-error {{no member}} expected-note {{'std::mem_fun_ref_t' is defined in}}
+ std::mem_fun_t; // expected-error {{no member}} expected-note {{'std::mem_fun_t' is defined in}}
+ std::memchr; // expected-error {{no member}} expected-note {{'std::memchr' is defined in}}
+ std::memcmp; // expected-error {{no member}} expected-note {{'std::memcmp' is defined in}}
+ std::memcpy; // expected-error {{no member}} expected-note {{'std::memcpy' is defined in}}
+ std::memmove; // expected-error {{no member}} expected-note {{'std::memmove' is defined in}}
+ std::memory_order; // expected-error {{no member}} expected-note {{'std::memory_order' is defined in}} expected-note {{'std::memory_order' is a}}
+ std::memory_order_acq_rel; // expected-error {{no member}} expected-note {{'std::memory_order_acq_rel' is defined in}} expected-note {{'std::memory_order_acq_rel' is a}}
+ std::memory_order_acquire; // expected-error {{no member}} expected-note {{'std::memory_order_acquire' is defined in}} expected-note {{'std::memory_order_acquire' is a}}
+ std::memory_order_consume; // expected-error {{no member}} expected-note {{'std::memory_order_consume' is defined in}} expected-note {{'std::memory_order_consume' is a}}
+ std::memory_order_relaxed; // expected-error {{no member}} expected-note {{'std::memory_order_relaxed' is defined in}} expected-note {{'std::memory_order_relaxed' is a}}
+ std::memory_order_release; // expected-error {{no member}} expected-note {{'std::memory_order_release' is defined in}} expected-note {{'std::memory_order_release' is a}}
+ std::memory_order_seq_cst; // expected-error {{no member}} expected-note {{'std::memory_order_seq_cst' is defined in}} expected-note {{'std::memory_order_seq_cst' is a}}
+ std::memset; // expected-error {{no member}} expected-note {{'std::memset' is defined in}}
+ std::merge; // expected-error {{no member}} expected-note {{'std::merge' is defined in}}
+ std::mergeable; // expected-error {{no member}} expected-note {{'std::mergeable' is defined in}} expected-note {{'std::mergeable' is a}}
+ std::mersenne_twister_engine; // expected-error {{no member}} expected-note {{'std::mersenne_twister_engine' is defined in}} expected-note {{'std::mersenne_twister_engine' is a}}
+ std::messages; // expected-error {{no member}} expected-note {{'std::messages' is defined in}}
+ std::messages_base; // expected-error {{no member}} expected-note {{'std::messages_base' is defined in}}
+ std::messages_byname; // expected-error {{no member}} expected-note {{'std::messages_byname' is defined in}}
+ std::micro; // expected-error {{no member}} expected-note {{'std::micro' is defined in}} expected-note {{'std::micro' is a}}
+ std::midpoint; // expected-error {{no member}} expected-note {{'std::midpoint' is defined in}} expected-note {{'std::midpoint' is a}}
+ std::milli; // expected-error {{no member}} expected-note {{'std::milli' is defined in}} expected-note {{'std::milli' is a}}
+ std::min; // expected-error {{no member}} expected-note {{'std::min' is defined in}}
+ std::min_element; // expected-error {{no member}} expected-note {{'std::min_element' is defined in}}
+ std::minmax; // expected-error {{no member}} expected-note {{'std::minmax' is defined in}} expected-note {{'std::minmax' is a}}
+ std::minmax_element; // expected-error {{no member}} expected-note {{'std::minmax_element' is defined in}} expected-note {{'std::minmax_element' is a}}
+ std::minstd_rand; // expected-error {{no member}} expected-note {{'std::minstd_rand' is defined in}} expected-note {{'std::minstd_rand' is a}}
+ std::minstd_rand0; // expected-error {{no member}} expected-note {{'std::minstd_rand0' is defined in}} expected-note {{'std::minstd_rand0' is a}}
+ std::minus; // expected-error {{no member}} expected-note {{'std::minus' is defined in}}
+ std::mismatch; // expected-error {{no member}} expected-note {{'std::mismatch' is defined in}}
+ std::mktime; // expected-error {{no member}} expected-note {{'std::mktime' is defined in}}
+ std::modf; // expected-error {{no member}} expected-note {{'std::modf' is defined in}}
+ std::modff; // expected-error {{no member}} expected-note {{'std::modff' is defined in}} expected-note {{'std::modff' is a}}
+ std::modfl; // expected-error {{no member}} expected-note {{'std::modfl' is defined in}} expected-note {{'std::modfl' is a}}
+ std::modulus; // expected-error {{no member}} expected-note {{'std::modulus' is defined in}}
+ std::money_base; // expected-error {{no member}} expected-note {{'std::money_base' is defined in}}
+ std::money_get; // expected-error {{no member}} expected-note {{'std::money_get' is defined in}}
+ std::money_put; // expected-error {{no member}} expected-note {{'std::money_put' is defined in}}
+ std::moneypunct; // expected-error {{no member}} expected-note {{'std::moneypunct' is defined in}}
+ std::moneypunct_byname; // expected-error {{no member}} expected-note {{'std::moneypunct_byname' is defined in}}
+ std::movable; // expected-error {{no member}} expected-note {{'std::movable' is defined in}} expected-note {{'std::movable' is a}}
+ std::move_backward; // expected-error {{no member}} expected-note {{'std::move_backward' is defined in}} expected-note {{'std::move_backward' is a}}
+ std::move_constructible; // expected-error {{no member}} expected-note {{'std::move_constructible' is defined in}} expected-note {{'std::move_constructible' is a}}
+ std::move_if_noexcept; // expected-error {{no member}} expected-note {{'std::move_if_noexcept' is defined in}} expected-note {{'std::move_if_noexcept' is a}}
+ std::move_iterator; // expected-error {{no member}} expected-note {{'std::move_iterator' is defined in}} expected-note {{'std::move_iterator' is a}}
+ std::move_only_function; // expected-error {{no member}} expected-note {{'std::move_only_function' is defined in}} expected-note {{'std::move_only_function' is a}}
+ std::move_sentinel; // expected-error {{no member}} expected-note {{'std::move_sentinel' is defined in}} expected-note {{'std::move_sentinel' is a}}
+ std::mt19937; // expected-error {{no member}} expected-note {{'std::mt19937' is defined in}} expected-note {{'std::mt19937' is a}}
+ std::mt19937_64; // expected-error {{no member}} expected-note {{'std::mt19937_64' is defined in}} expected-note {{'std::mt19937_64' is a}}
+ std::mul_sat; // expected-error {{no member}} expected-note {{'std::mul_sat' is defined in}} expected-note {{'std::mul_sat' is a}}
+ std::multimap; // expected-error {{no member}} expected-note {{'std::multimap' is defined in}}
+ std::multiplies; // expected-error {{no member}} expected-note {{'std::multiplies' is defined in}}
+ std::multiset; // expected-error {{no member}} expected-note {{'std::multiset' is defined in}}
+ std::mutex; // expected-error {{no member}} expected-note {{'std::mutex' is defined in}} expected-note {{'std::mutex' is a}}
+ std::nan; // expected-error {{no member}} expected-note {{'std::nan' is defined in}} expected-note {{'std::nan' is a}}
+ std::nanf; // expected-error {{no member}} expected-note {{'std::nanf' is defined in}} expected-note {{'std::nanf' is a}}
+ std::nanl; // expected-error {{no member}} expected-note {{'std::nanl' is defined in}} expected-note {{'std::nanl' is a}}
+ std::nano; // expected-error {{no member}} expected-note {{'std::nano' is defined in}} expected-note {{'std::nano' is a}}
+ std::nearbyintf; // expected-error {{no member}} expected-note {{'std::nearbyintf' is defined in}} expected-note {{'std::nearbyintf' is a}}
+ std::nearbyintl; // expected-error {{no member}} expected-note {{'std::nearbyintl' is defined in}} expected-note {{'std::nearbyintl' is a}}
+ std::negate; // expected-error {{no member}} expected-note {{'std::negate' is defined in}}
+ std::negation; // expected-error {{no member}} expected-note {{'std::negation' is defined in}} expected-note {{'std::negation' is a}}
+ std::negation_v; // expected-error {{no member}} expected-note {{'std::negation_v' is defined in}} expected-note {{'std::negation_v' is a}}
+ std::negative_binomial_distribution; // expected-error {{no member}} expected-note {{'std::negative_binomial_distribution' is defined in}} expected-note {{'std::negative_binomial_distribution' is a}}
+ std::nested_exception; // expected-error {{no member}} expected-note {{'std::nested_exception' is defined in}} expected-note {{'std::nested_exception' is a}}
+ std::new_handler; // expected-error {{no member}} expected-note {{'std::new_handler' is defined in}}
+ std::next; // expected-error {{no member}} expected-note {{'std::next' is defined in}} expected-note {{'std::next' is a}}
+ std::next_permutation; // expected-error {{no member}} expected-note {{'std::next_permutation' is defined in}}
+ std::nextafter; // expected-error {{no member}} expected-note {{'std::nextafter' is defined in}} expected-note {{'std::nextafter' is a}}
+ std::nextafterf; // expected-error {{no member}} expected-note {{'std::nextafterf' is defined in}} expected-note {{'std::nextafterf' is a}}
+ std::nextafterl; // expected-error {{no member}} expected-note {{'std::nextafterl' is defined in}} expected-note {{'std::nextafterl' is a}}
+ std::nexttoward; // expected-error {{no member}} expected-note {{'std::nexttoward' is defined in}} expected-note {{'std::nexttoward' is a}}
+ std::nexttowardf; // expected-error {{no member}} expected-note {{'std::nexttowardf' is defined in}} expected-note {{'std::nexttowardf' is a}}
+ std::nexttowardl; // expected-error {{no member}} expected-note {{'std::nexttowardl' is defined in}} expected-note {{'std::nexttowardl' is a}}
+ std::noboolalpha; // expected-error {{no member}} expected-note {{'std::noboolalpha' is defined in}}
+ std::noboolalpha; // expected-error {{no member}} expected-note {{'std::noboolalpha' is defined in}}
+ std::noemit_on_flush; // expected-error {{no member}} expected-note {{'std::noemit_on_flush' is defined in}} expected-note {{'std::noemit_on_flush' is a}}
+ std::noemit_on_flush; // expected-error {{no member}} expected-note {{'std::noemit_on_flush' is defined in}} expected-note {{'std::noemit_on_flush' is a}}
+ std::none_of; // expected-error {{no member}} expected-note {{'std::none_of' is defined in}} expected-note {{'std::none_of' is a}}
+ std::nontype; // expected-error {{no member}} expected-note {{'std::nontype' is defined in}} expected-note {{'std::nontype' is a}}
+ std::nontype_t; // expected-error {{no member}} expected-note {{'std::nontype_t' is defined in}} expected-note {{'std::nontype_t' is a}}
+ std::noop_coroutine; // expected-error {{no member}} expected-note {{'std::noop_coroutine' is defined in}} expected-note {{'std::noop_coroutine' is a}}
+ std::noop_coroutine_handle; // expected-error {{no member}} expected-note {{'std::noop_coroutine_handle' is defined in}} expected-note {{'std::noop_coroutine_handle' is a}}
+ std::noop_coroutine_promise; // expected-error {{no member}} expected-note {{'std::noop_coroutine_promise' is defined in}} expected-note {{'std::noop_coroutine_promise' is a}}
+ std::norm; // expected-error {{no member}} expected-note {{'std::norm' is defined in}}
+ std::normal_distribution; // expected-error {{no member}} expected-note {{'std::normal_distribution' is defined in}} expected-note {{'std::normal_distribution' is a}}
+ std::noshowbase; // expected-error {{no member}} expected-note {{'std::noshowbase' is defined in}}
+ std::noshowbase; // expected-error {{no member}} expected-note {{'std::noshowbase' is defined in}}
+ std::noshowpoint; // expected-error {{no member}} expected-note {{'std::noshowpoint' is defined in}}
+ std::noshowpoint; // expected-error {{no member}} expected-note {{'std::noshowpoint' is defined in}}
+ std::noshowpos; // expected-error {{no member}} expected-note {{'std::noshowpos' is defined in}}
+ std::noshowpos; // expected-error {{no member}} expected-note {{'std::noshowpos' is defined in}}
+ std::noskipws; // expected-error {{no member}} expected-note {{'std::noskipws' is defined in}}
+ std::noskipws; // expected-error {{no member}} expected-note {{'std::noskipws' is defined in}}
+ std::nostopstate; // expected-error {{no member}} expected-note {{'std::nostopstate' is defined in}} expected-note {{'std::nostopstate' is a}}
+ std::nostopstate_t; // expected-error {{no member}} expected-note {{'std::nostopstate_t' is defined in}} expected-note {{'std::nostopstate_t' is a}}
+ std::not1; // expected-error {{no member}} expected-note {{'std::not1' is defined in}}
+ std::not2; // expected-error {{no member}} expected-note {{'std::not2' is defined in}}
+ std::not_equal_to; // expected-error {{no member}} expected-note {{'std::not_equal_to' is defined in}}
+ std::not_fn; // expected-error {{no member}} expected-note {{'std::not_fn' is defined in}} expected-note {{'std::not_fn' is a}}
+ std::nothrow; // expected-error {{no member}} expected-note {{'std::nothrow' is defined in}}
+ std::nothrow_t; // expected-error {{no member}} expected-note {{'std::nothrow_t' is defined in}}
+ std::notify_all_at_thread_exit; // expected-error {{no member}} expected-note {{'std::notify_all_at_thread_exit' is defined in}} expected-note {{'std::notify_all_at_thread_exit' is a}}
+ std::nounitbuf; // expected-error {{no member}} expected-note {{'std::nounitbuf' is defined in}}
+ std::nounitbuf; // expected-error {{no member}} expected-note {{'std::nounitbuf' is defined in}}
+ std::nouppercase; // expected-error {{no member}} expected-note {{'std::nouppercase' is defined in}}
+ std::nouppercase; // expected-error {{no member}} expected-note {{'std::nouppercase' is defined in}}
+ std::nth_element; // expected-error {{no member}} expected-note {{'std::nth_element' is defined in}}
+ std::nullopt; // expected-error {{no member}} expected-note {{'std::nullopt' is defined in}} expected-note {{'std::nullopt' is a}}
+ std::nullopt_t; // expected-error {{no member}} expected-note {{'std::nullopt_t' is defined in}} expected-note {{'std::nullopt_t' is a}}
+ std::nullptr_t; // expected-error {{no member}} expected-note {{'std::nullptr_t' is defined in}} expected-note {{'std::nullptr_t' is a}}
+ std::num_get; // expected-error {{no member}} expected-note {{'std::num_get' is defined in}}
+ std::num_put; // expected-error {{no member}} expected-note {{'std::num_put' is defined in}}
+ std::numeric_limits; // expected-error {{no member}} expected-note {{'std::numeric_limits' is defined in}}
+ std::numpunct; // expected-error {{no member}} expected-note {{'std::numpunct' is defined in}}
+ std::numpunct_byname; // expected-error {{no member}} expected-note {{'std::numpunct_byname' is defined in}}
+ std::oct; // expected-error {{no member}} expected-note {{'std::oct' is defined in}}
+ std::oct; // expected-error {{no member}} expected-note {{'std::oct' is defined in}}
+ std::ofstream; // expected-error {{no member}} expected-note {{'std::ofstream' is defined in}}
+ std::ofstream; // expected-error {{no member}} expected-note {{'std::ofstream' is defined in}}
+ std::once_flag; // expected-error {{no member}} expected-note {{'std::once_flag' is defined in}} expected-note {{'std::once_flag' is a}}
+ std::op; // expected-error {{no member}} expected-note {{'std::op' is defined in}}
+ std::open_mode; // expected-error {{no member}} expected-note {{'std::open_mode' is defined in}}
+ std::open_mode; // expected-error {{no member}} expected-note {{'std::open_mode' is defined in}}
+ std::optional; // expected-error {{no member}} expected-note {{'std::optional' is defined in}} expected-note {{'std::optional' is a}}
+ std::ospanstream; // expected-error {{no member}} expected-note {{'std::ospanstream' is defined in}} expected-note {{'std::ospanstream' is a}}
+ std::ospanstream; // expected-error {{no member}} expected-note {{'std::ospanstream' is defined in}} expected-note {{'std::ospanstream' is a}}
+ std::ostream; // expected-error {{no member}} expected-note {{'std::ostream' is defined in}}
+ std::ostream; // expected-error {{no member}} expected-note {{'std::ostream' is defined in}}
+ std::ostream; // expected-error {{no member}} expected-note {{'std::ostream' is defined in}}
+ std::ostream_iterator; // expected-error {{no member}} expected-note {{'std::ostream_iterator' is defined in}}
+ std::ostreambuf_iterator; // expected-error {{no member}} expected-note {{'std::ostreambuf_iterator' is defined in}}
+ std::ostreambuf_iterator; // expected-error {{no member}} expected-note {{'std::ostreambuf_iterator' is defined in}}
+ std::ostringstream; // expected-error {{no member}} expected-note {{'std::ostringstream' is defined in}}
+ std::ostringstream; // expected-error {{no member}} expected-note {{'std::ostringstream' is defined in}}
+ std::ostrstream; // expected-error {{no member}} expected-note {{'std::ostrstream' is defined in}}
+ std::osyncstream; // expected-error {{no member}} expected-note {{'std::osyncstream' is defined in}} expected-note {{'std::osyncstream' is a}}
+ std::osyncstream; // expected-error {{no member}} expected-note {{'std::osyncstream' is defined in}} expected-note {{'std::osyncstream' is a}}
+ std::out_of_range; // expected-error {{no member}} expected-note {{'std::out_of_range' is defined in}}
+ std::out_ptr; // expected-error {{no member}} expected-note {{'std::out_ptr' is defined in}} expected-note {{'std::out_ptr' is a}}
+ std::out_ptr_t; // expected-error {{no member}} expected-note {{'std::out_ptr_t' is defined in}} expected-note {{'std::out_ptr_t' is a}}
+ std::output_iterator; // expected-error {{no member}} expected-note {{'std::output_iterator' is defined in}} expected-note {{'std::output_iterator' is a}}
+ std::output_iterator_tag; // expected-error {{no member}} expected-note {{'std::output_iterator_tag' is defined in}}
+ std::overflow_error; // expected-error {{no member}} expected-note {{'std::overflow_error' is defined in}}
+ std::owner_less; // expected-error {{no member}} expected-note {{'std::owner_less' is defined in}} expected-note {{'std::owner_less' is a}}
+ std::packaged_task; // expected-error {{no member}} expected-note {{'std::packaged_task' is defined in}} expected-note {{'std::packaged_task' is a}}
+ std::pair; // expected-error {{no member}} expected-note {{'std::pair' is defined in}}
+ std::partial_order; // expected-error {{no member}} expected-note {{'std::partial_order' is defined in}} expected-note {{'std::partial_order' is a}}
+ std::partial_ordering; // expected-error {{no member}} expected-note {{'std::partial_ordering' is defined in}} expected-note {{'std::partial_ordering' is a}}
+ std::partial_sort; // expected-error {{no member}} expected-note {{'std::partial_sort' is defined in}}
+ std::partial_sort_copy; // expected-error {{no member}} expected-note {{'std::partial_sort_copy' is defined in}}
+ std::partial_sum; // expected-error {{no member}} expected-note {{'std::partial_sum' is defined in}}
+ std::partition; // expected-error {{no member}} expected-note {{'std::partition' is defined in}}
+ std::partition_copy; // expected-error {{no member}} expected-note {{'std::partition_copy' is defined in}} expected-note {{'std::partition_copy' is a}}
+ std::partition_point; // expected-error {{no member}} expected-note {{'std::partition_point' is defined in}} expected-note {{'std::partition_point' is a}}
+ std::permutable; // expected-error {{no member}} expected-note {{'std::permutable' is defined in}} expected-note {{'std::permutable' is a}}
+ std::perror; // expected-error {{no member}} expected-note {{'std::perror' is defined in}}
+ std::peta; // expected-error {{no member}} expected-note {{'std::peta' is defined in}} expected-note {{'std::peta' is a}}
+ std::pico; // expected-error {{no member}} expected-note {{'std::pico' is defined in}} expected-note {{'std::pico' is a}}
+ std::piecewise_constant_distribution; // expected-error {{no member}} expected-note {{'std::piecewise_constant_distribution' is defined in}} expected-note {{'std::piecewise_constant_distribution' is a}}
+ std::piecewise_construct; // expected-error {{no member}} expected-note {{'std::piecewise_construct' is defined in}} expected-note {{'std::piecewise_construct' is a}}
+ std::piecewise_construct_t; // expected-error {{no member}} expected-note {{'std::piecewise_construct_t' is defined in}} expected-note {{'std::piecewise_construct_t' is a}}
+ std::piecewise_linear_distribution; // expected-error {{no member}} expected-note {{'std::piecewise_linear_distribution' is defined in}} expected-note {{'std::piecewise_linear_distribution' is a}}
+ std::plus; // expected-error {{no member}} expected-note {{'std::plus' is defined in}}
+ std::pointer_safety; // expected-error {{no member}} expected-note {{'std::pointer_safety' is defined in}} expected-note {{'std::pointer_safety' is a}}
+ std::pointer_traits; // expected-error {{no member}} expected-note {{'std::pointer_traits' is defined in}} expected-note {{'std::pointer_traits' is a}}
+ std::poisson_distribution; // expected-error {{no member}} expected-note {{'std::poisson_distribution' is defined in}} expected-note {{'std::poisson_distribution' is a}}
+ std::polar; // expected-error {{no member}} expected-note {{'std::polar' is defined in}}
+ std::pop_heap; // expected-error {{no member}} expected-note {{'std::pop_heap' is defined in}}
+ std::popcount; // expected-error {{no member}} expected-note {{'std::popcount' is defined in}} expected-note {{'std::popcount' is a}}
+ std::pow; // expected-error {{no member}} expected-note {{'std::pow' is defined in}}
+ std::powf; // expected-error {{no member}} expected-note {{'std::powf' is defined in}} expected-note {{'std::powf' is a}}
+ std::powl; // expected-error {{no member}} expected-note {{'std::powl' is defined in}} expected-note {{'std::powl' is a}}
+ std::predicate; // expected-error {{no member}} expected-note {{'std::predicate' is defined in}} expected-note {{'std::predicate' is a}}
+ std::preferred; // expected-error {{no member}} expected-note {{'std::preferred' is defined in}} expected-note {{'std::preferred' is a}}
+ std::prev; // expected-error {{no member}} expected-note {{'std::prev' is defined in}} expected-note {{'std::prev' is a}}
+ std::prev_permutation; // expected-error {{no member}} expected-note {{'std::prev_permutation' is defined in}}
+ std::print; // expected-error {{no member}} expected-note {{'std::print' is defined in}} expected-note {{'std::print' is a}}
+ std::printf; // expected-error {{no member}} expected-note {{'std::printf' is defined in}}
+ std::println; // expected-error {{no member}} expected-note {{'std::println' is defined in}} expected-note {{'std::println' is a}}
+ std::priority_queue; // expected-error {{no member}} expected-note {{'std::priority_queue' is defined in}}
+ std::proj; // expected-error {{no member}} expected-note {{'std::proj' is defined in}} expected-note {{'std::proj' is a}}
+ std::projected; // expected-error {{no member}} expected-note {{'std::projected' is defined in}} expected-note {{'std::projected' is a}}
+ std::promise; // expected-error {{no member}} expected-note {{'std::promise' is defined in}} expected-note {{'std::promise' is a}}
+ std::ptr_fun; // expected-error {{no member}} expected-note {{'std::ptr_fun' is defined in}}
+ std::ptrdiff_t; // expected-error {{no member}} expected-note {{'std::ptrdiff_t' is defined in}}
+ std::push_heap; // expected-error {{no member}} expected-note {{'std::push_heap' is defined in}}
+ std::put_money; // expected-error {{no member}} expected-note {{'std::put_money' is defined in}} expected-note {{'std::put_money' is a}}
+ std::put_time; // expected-error {{no member}} expected-note {{'std::put_time' is defined in}} expected-note {{'std::put_time' is a}}
+ std::putc; // expected-error {{no member}} expected-note {{'std::putc' is defined in}}
+ std::putchar; // expected-error {{no member}} expected-note {{'std::putchar' is defined in}}
+ std::puts; // expected-error {{no member}} expected-note {{'std::puts' is defined in}}
+ std::putwc; // expected-error {{no member}} expected-note {{'std::putwc' is defined in}}
+ std::putwchar; // expected-error {{no member}} expected-note {{'std::putwchar' is defined in}}
+ std::qsort; // expected-error {{no member}} expected-note {{'std::qsort' is defined in}}
+ std::quecto; // expected-error {{no member}} expected-note {{'std::quecto' is defined in}} expected-note {{'std::quecto' is a}}
+ std::quetta; // expected-error {{no member}} expected-note {{'std::quetta' is defined in}} expected-note {{'std::quetta' is a}}
+ std::queue; // expected-error {{no member}} expected-note {{'std::queue' is defined in}}
+ std::quick_exit; // expected-error {{no member}} expected-note {{'std::quick_exit' is defined in}} expected-note {{'std::quick_exit' is a}}
+ std::quoted; // expected-error {{no member}} expected-note {{'std::quoted' is defined in}} expected-note {{'std::quoted' is a}}
+ std::raise; // expected-error {{no member}} expected-note {{'std::raise' is defined in}}
+ std::rand; // expected-error {{no member}} expected-note {{'std::rand' is defined in}}
+ std::random_access_iterator; // expected-error {{no member}} expected-note {{'std::random_access_iterator' is defined in}} expected-note {{'std::random_access_iterator' is a}}
+ std::random_access_iterator_tag; // expected-error {{no member}} expected-note {{'std::random_access_iterator_tag' is defined in}}
+ std::random_device; // expected-error {{no member}} expected-note {{'std::random_device' is defined in}} expected-note {{'std::random_device' is a}}
+ std::random_shuffle; // expected-error {{no member}} expected-note {{'std::random_shuffle' is defined in}}
+ std::range_error; // expected-error {{no member}} expected-note {{'std::range_error' is defined in}}
+ std::range_format; // expected-error {{no member}} expected-note {{'std::range_format' is defined in}} expected-note {{'std::range_format' is a}}
+ std::range_formatter; // expected-error {{no member}} expected-note {{'std::range_formatter' is defined in}} expected-note {{'std::range_formatter' is a}}
+ std::rank; // expected-error {{no member}} expected-note {{'std::rank' is defined in}} expected-note {{'std::rank' is a}}
+ std::rank_v; // expected-error {{no member}} expected-note {{'std::rank_v' is defined in}} expected-note {{'std::rank_v' is a}}
+ std::ranlux24; // expected-error {{no member}} expected-note {{'std::ranlux24' is defined in}} expected-note {{'std::ranlux24' is a}}
+ std::ranlux24_base; // expected-error {{no member}} expected-note {{'std::ranlux24_base' is defined in}} expected-note {{'std::ranlux24_base' is a}}
+ std::ranlux48; // expected-error {{no member}} expected-note {{'std::ranlux48' is defined in}} expected-note {{'std::ranlux48' is a}}
+ std::ranlux48_base; // expected-error {{no member}} expected-note {{'std::ranlux48_base' is defined in}} expected-note {{'std::ranlux48_base' is a}}
+ std::ratio; // expected-error {{no member}} expected-note {{'std::ratio' is defined in}} expected-note {{'std::ratio' is a}}
+ std::ratio_add; // expected-error {{no member}} expected-note {{'std::ratio_add' is defined in}} expected-note {{'std::ratio_add' is a}}
+ std::ratio_divide; // expected-error {{no member}} expected-note {{'std::ratio_divide' is defined in}} expected-note {{'std::ratio_divide' is a}}
+ std::ratio_equal; // expected-error {{no member}} expected-note {{'std::ratio_equal' is defined in}} expected-note {{'std::ratio_equal' is a}}
+ std::ratio_equal_v; // expected-error {{no member}} expected-note {{'std::ratio_equal_v' is defined in}} expected-note {{'std::ratio_equal_v' is a}}
+ std::ratio_greater; // expected-error {{no member}} expected-note {{'std::ratio_greater' is defined in}} expected-note {{'std::ratio_greater' is a}}
+ std::ratio_greater_equal; // expected-error {{no member}} expected-note {{'std::ratio_greater_equal' is defined in}} expected-note {{'std::ratio_greater_equal' is a}}
+ std::ratio_greater_equal_v; // expected-error {{no member}} expected-note {{'std::ratio_greater_equal_v' is defined in}} expected-note {{'std::ratio_greater_equal_v' is a}}
+ std::ratio_greater_v; // expected-error {{no member}} expected-note {{'std::ratio_greater_v' is defined in}} expected-note {{'std::ratio_greater_v' is a}}
+ std::ratio_less; // expected-error {{no member}} expected-note {{'std::ratio_less' is defined in}} expected-note {{'std::ratio_less' is a}}
+ std::ratio_less_equal; // expected-error {{no member}} expected-note {{'std::ratio_less_equal' is defined in}} expected-note {{'std::ratio_less_equal' is a}}
+ std::ratio_less_equal_v; // expected-error {{no member}} expected-note {{'std::ratio_less_equal_v' is defined in}} expected-note {{'std::ratio_less_equal_v' is a}}
+ std::ratio_less_v; // expected-error {{no member}} expected-note {{'std::ratio_less_v' is defined in}} expected-note {{'std::ratio_less_v' is a}}
+ std::ratio_multiply; // expected-error {{no member}} expected-note {{'std::ratio_multiply' is defined in}} expected-note {{'std::ratio_multiply' is a}}
+ std::ratio_not_equal; // expected-error {{no member}} expected-note {{'std::ratio_not_equal' is defined in}} expected-note {{'std::ratio_not_equal' is a}}
+ std::ratio_not_equal_v; // expected-error {{no member}} expected-note {{'std::ratio_not_equal_v' is defined in}} expected-note {{'std::ratio_not_equal_v' is a}}
+ std::ratio_subtract; // expected-error {{no member}} expected-note {{'std::ratio_subtract' is defined in}} expected-note {{'std::ratio_subtract' is a}}
+ std::raw_storage_iterator; // expected-error {{no member}} expected-note {{'std::raw_storage_iterator' is defined in}}
+ std::real; // expected-error {{no member}} expected-note {{'std::real' is defined in}}
+ std::realloc; // expected-error {{no member}} expected-note {{'std::realloc' is defined in}}
+ std::recursive_mutex; // expected-error {{no member}} expected-note {{'std::recursive_mutex' is defined in}} expected-note {{'std::recursive_mutex' is a}}
+ std::recursive_timed_mutex; // expected-error {{no member}} expected-note {{'std::recursive_timed_mutex' is defined in}} expected-note {{'std::recursive_timed_mutex' is a}}
+ std::reduce; // expected-error {{no member}} expected-note {{'std::reduce' is defined in}} expected-note {{'std::reduce' is a}}
+ std::ref; // expected-error {{no member}} expected-note {{'std::ref' is defined in}} expected-note {{'std::ref' is a}}
+ std::reference_constructs_from_temporary; // expected-error {{no member}} expected-note {{'std::reference_constructs_from_temporary' is defined in}} expected-note {{'std::reference_constructs_from_temporary' is a}}
+ std::reference_converts_from_temporary; // expected-error {{no member}} expected-note {{'std::reference_converts_from_temporary' is defined in}} expected-note {{'std::reference_converts_from_temporary' is a}}
+ std::reference_wrapper; // expected-error {{no member}} expected-note {{'std::reference_wrapper' is defined in}} expected-note {{'std::reference_wrapper' is a}}
+ std::regex; // expected-error {{no member}} expected-note {{'std::regex' is defined in}} expected-note {{'std::regex' is a}}
+ std::regex_error; // expected-error {{no member}} expected-note {{'std::regex_error' is defined in}} expected-note {{'std::regex_error' is a}}
+ std::regex_iterator; // expected-error {{no member}} expected-note {{'std::regex_iterator' is defined in}} expected-note {{'std::regex_iterator' is a}}
+ std::regex_match; // expected-error {{no member}} expected-note {{'std::regex_match' is defined in}} expected-note {{'std::regex_match' is a}}
+ std::regex_replace; // expected-error {{no member}} expected-note {{'std::regex_replace' is defined in}} expected-note {{'std::regex_replace' is a}}
+ std::regex_search; // expected-error {{no member}} expected-note {{'std::regex_search' is defined in}} expected-note {{'std::regex_search' is a}}
+ std::regex_token_iterator; // expected-error {{no member}} expected-note {{'std::regex_token_iterator' is defined in}} expected-note {{'std::regex_token_iterator' is a}}
+ std::regex_traits; // expected-error {{no member}} expected-note {{'std::regex_traits' is defined in}} expected-note {{'std::regex_traits' is a}}
+ std::regular; // expected-error {{no member}} expected-note {{'std::regular' is defined in}} expected-note {{'std::regular' is a}}
+ std::regular_invocable; // expected-error {{no member}} expected-note {{'std::regular_invocable' is defined in}} expected-note {{'std::regular_invocable' is a}}
+ std::reinterpret_pointer_cast; // expected-error {{no member}} expected-note {{'std::reinterpret_pointer_cast' is defined in}} expected-note {{'std::reinterpret_pointer_cast' is a}}
+ std::relation; // expected-error {{no member}} expected-note {{'std::relation' is defined in}} expected-note {{'std::relation' is a}}
+ std::relaxed; // expected-error {{no member}} expected-note {{'std::relaxed' is defined in}} expected-note {{'std::relaxed' is a}}
+ std::remainderf; // expected-error {{no member}} expected-note {{'std::remainderf' is defined in}} expected-note {{'std::remainderf' is a}}
+ std::remainderl; // expected-error {{no member}} expected-note {{'std::remainderl' is defined in}} expected-note {{'std::remainderl' is a}}
+ std::remove_all_extents; // expected-error {{no member}} expected-note {{'std::remove_all_extents' is defined in}} expected-note {{'std::remove_all_extents' is a}}
+ std::remove_all_extents_t; // expected-error {{no member}} expected-note {{'std::remove_all_extents_t' is defined in}} expected-note {{'std::remove_all_extents_t' is a}}
+ std::remove_const; // expected-error {{no member}} expected-note {{'std::remove_const' is defined in}} expected-note {{'std::remove_const' is a}}
+ std::remove_const_t; // expected-error {{no member}} expected-note {{'std::remove_const_t' is defined in}} expected-note {{'std::remove_const_t' is a}}
+ std::remove_copy; // expected-error {{no member}} expected-note {{'std::remove_copy' is defined in}}
+ std::remove_copy_if; // expected-error {{no member}} expected-note {{'std::remove_copy_if' is defined in}}
+ std::remove_cv; // expected-error {{no member}} expected-note {{'std::remove_cv' is defined in}} expected-note {{'std::remove_cv' is a}}
+ std::remove_cv_t; // expected-error {{no member}} expected-note {{'std::remove_cv_t' is defined in}} expected-note {{'std::remove_cv_t' is a}}
+ std::remove_cvref; // expected-error {{no member}} expected-note {{'std::remove_cvref' is defined in}} expected-note {{'std::remove_cvref' is a}}
+ std::remove_cvref_t; // expected-error {{no member}} expected-note {{'std::remove_cvref_t' is defined in}} expected-note {{'std::remove_cvref_t' is a}}
+ std::remove_extent; // expected-error {{no member}} expected-note {{'std::remove_extent' is defined in}} expected-note {{'std::remove_extent' is a}}
+ std::remove_extent_t; // expected-error {{no member}} expected-note {{'std::remove_extent_t' is defined in}} expected-note {{'std::remove_extent_t' is a}}
+ std::remove_if; // expected-error {{no member}} expected-note {{'std::remove_if' is defined in}}
+ std::remove_pointer; // expected-error {{no member}} expected-note {{'std::remove_pointer' is defined in}} expected-note {{'std::remove_pointer' is a}}
+ std::remove_pointer_t; // expected-error {{no member}} expected-note {{'std::remove_pointer_t' is defined in}} expected-note {{'std::remove_pointer_t' is a}}
+ std::remove_reference; // expected-error {{no member}} expected-note {{'std::remove_reference' is defined in}} expected-note {{'std::remove_reference' is a}}
+ std::remove_reference_t; // expected-error {{no member}} expected-note {{'std::remove_reference_t' is defined in}} expected-note {{'std::remove_reference_t' is a}}
+ std::remove_volatile; // expected-error {{no member}} expected-note {{'std::remove_volatile' is defined in}} expected-note {{'std::remove_volatile' is a}}
+ std::remove_volatile_t; // expected-error {{no member}} expected-note {{'std::remove_volatile_t' is defined in}} expected-note {{'std::remove_volatile_t' is a}}
+ std::remquo; // expected-error {{no member}} expected-note {{'std::remquo' is defined in}} expected-note {{'std::remquo' is a}}
+ std::remquof; // expected-error {{no member}} expected-note {{'std::remquof' is defined in}} expected-note {{'std::remquof' is a}}
+ std::remquol; // expected-error {{no member}} expected-note {{'std::remquol' is defined in}} expected-note {{'std::remquol' is a}}
+ std::rename; // expected-error {{no member}} expected-note {{'std::rename' is defined in}}
+ std::replace; // expected-error {{no member}} expected-note {{'std::replace' is defined in}}
+ std::replace_copy; // expected-error {{no member}} expected-note {{'std::replace_copy' is defined in}}
+ std::replace_copy_if; // expected-error {{no member}} expected-note {{'std::replace_copy_if' is defined in}}
+ std::replace_if; // expected-error {{no member}} expected-note {{'std::replace_if' is defined in}}
+ std::resetiosflags; // expected-error {{no member}} expected-note {{'std::resetiosflags' is defined in}}
+ std::result_of; // expected-error {{no member}} expected-note {{'std::result_of' is defined in}} expected-note {{'std::result_of' is a}}
+ std::result_of_t; // expected-error {{no member}} expected-note {{'std::result_of_t' is defined in}} expected-note {{'std::result_of_t' is a}}
+ std::rethrow_exception; // expected-error {{no member}} expected-note {{'std::rethrow_exception' is defined in}} expected-note {{'std::rethrow_exception' is a}}
+ std::rethrow_if_nested; // expected-error {{no member}} expected-note {{'std::rethrow_if_nested' is defined in}} expected-note {{'std::rethrow_if_nested' is a}}
+ std::return_temporary_buffer; // expected-error {{no member}} expected-note {{'std::return_temporary_buffer' is defined in}}
+ std::reverse; // expected-error {{no member}} expected-note {{'std::reverse' is defined in}}
+ std::reverse_copy; // expected-error {{no member}} expected-note {{'std::reverse_copy' is defined in}}
+ std::reverse_iterator; // expected-error {{no member}} expected-note {{'std::reverse_iterator' is defined in}}
+ std::rewind; // expected-error {{no member}} expected-note {{'std::rewind' is defined in}}
+ std::riemann_zeta; // expected-error {{no member}} expected-note {{'std::riemann_zeta' is defined in}} expected-note {{'std::riemann_zeta' is a}}
+ std::riemann_zetaf; // expected-error {{no member}} expected-note {{'std::riemann_zetaf' is defined in}} expected-note {{'std::riemann_zetaf' is a}}
+ std::riemann_zetal; // expected-error {{no member}} expected-note {{'std::riemann_zetal' is defined in}} expected-note {{'std::riemann_zetal' is a}}
+ std::right; // expected-error {{no member}} expected-note {{'std::right' is defined in}}
+ std::right; // expected-error {{no member}} expected-note {{'std::right' is defined in}}
+ std::rint; // expected-error {{no member}} expected-note {{'std::rint' is defined in}} expected-note {{'std::rint' is a}}
+ std::rintf; // expected-error {{no member}} expected-note {{'std::rintf' is defined in}} expected-note {{'std::rintf' is a}}
+ std::rintl; // expected-error {{no member}} expected-note {{'std::rintl' is defined in}} expected-note {{'std::rintl' is a}}
+ std::ronna; // expected-error {{no member}} expected-note {{'std::ronna' is defined in}} expected-note {{'std::ronna' is a}}
+ std::ronto; // expected-error {{no member}} expected-note {{'std::ronto' is defined in}} expected-note {{'std::ronto' is a}}
+ std::rotate; // expected-error {{no member}} expected-note {{'std::rotate' is defined in}}
+ std::rotate_copy; // expected-error {{no member}} expected-note {{'std::rotate_copy' is defined in}}
+ std::rotl; // expected-error {{no member}} expected-note {{'std::rotl' is defined in}} expected-note {{'std::rotl' is a}}
+ std::rotr; // expected-error {{no member}} expected-note {{'std::rotr' is defined in}} expected-note {{'std::rotr' is a}}
+ std::round; // expected-error {{no member}} expected-note {{'std::round' is defined in}} expected-note {{'std::round' is a}}
+ std::round_indeterminate; // expected-error {{no member}} expected-note {{'std::round_indeterminate' is defined in}}
+ std::round_to_nearest; // expected-error {{no member}} expected-note {{'std::round_to_nearest' is defined in}}
+ std::round_toward_infinity; // expected-error {{no member}} expected-note {{'std::round_toward_infinity' is defined in}}
+ std::round_toward_neg_infinity; // expected-error {{no member}} expected-note {{'std::round_toward_neg_infinity' is defined in}}
+ std::round_toward_zero; // expected-error {{no member}} expected-note {{'std::round_toward_zero' is defined in}}
+ std::roundf; // expected-error {{no member}} expected-note {{'std::roundf' is defined in}} expected-note {{'std::roundf' is a}}
+ std::roundl; // expected-error {{no member}} expected-note {{'std::roundl' is defined in}} expected-note {{'std::roundl' is a}}
+ std::runtime_error; // expected-error {{no member}} expected-note {{'std::runtime_error' is defined in}}
+ std::runtime_format; // expected-error {{no member}} expected-note {{'std::runtime_format' is defined in}} expected-note {{'std::runtime_format' is a}}
+ std::same_as; // expected-error {{no member}} expected-note {{'std::same_as' is defined in}} expected-note {{'std::same_as' is a}}
+ std::sample; // expected-error {{no member}} expected-note {{'std::sample' is defined in}} expected-note {{'std::sample' is a}}
+ std::saturate_cast; // expected-error {{no member}} expected-note {{'std::saturate_cast' is defined in}} expected-note {{'std::saturate_cast' is a}}
+ std::scalbln; // expected-error {{no member}} expected-note {{'std::scalbln' is defined in}} expected-note {{'std::scalbln' is a}}
+ std::scalblnf; // expected-error {{no member}} expected-note {{'std::scalblnf' is defined in}} expected-note {{'std::scalblnf' is a}}
+ std::scalblnl; // expected-error {{no member}} expected-note {{'std::scalblnl' is defined in}} expected-note {{'std::scalblnl' is a}}
+ std::scalbn; // expected-error {{no member}} expected-note {{'std::scalbn' is defined in}} expected-note {{'std::scalbn' is a}}
+ std::scalbnf; // expected-error {{no member}} expected-note {{'std::scalbnf' is defined in}} expected-note {{'std::scalbnf' is a}}
+ std::scalbnl; // expected-error {{no member}} expected-note {{'std::scalbnl' is defined in}} expected-note {{'std::scalbnl' is a}}
+ std::scanf; // expected-error {{no member}} expected-note {{'std::scanf' is defined in}}
+ std::scientific; // expected-error {{no member}} expected-note {{'std::scientific' is defined in}}
+ std::scientific; // expected-error {{no member}} expected-note {{'std::scientific' is defined in}}
+ std::scoped_allocator_adaptor; // expected-error {{no member}} expected-note {{'std::scoped_allocator_adaptor' is defined in}} expected-note {{'std::scoped_allocator_adaptor' is a}}
+ std::scoped_lock; // expected-error {{no member}} expected-note {{'std::scoped_lock' is defined in}} expected-note {{'std::scoped_lock' is a}}
+ std::search; // expected-error {{no member}} expected-note {{'std::search' is defined in}}
+ std::search_n; // expected-error {{no member}} expected-note {{'std::search_n' is defined in}}
+ std::seed_seq; // expected-error {{no member}} expected-note {{'std::seed_seq' is defined in}} expected-note {{'std::seed_seq' is a}}
+ std::seek_dir; // expected-error {{no member}} expected-note {{'std::seek_dir' is defined in}}
+ std::seek_dir; // expected-error {{no member}} expected-note {{'std::seek_dir' is defined in}}
+ std::semiregular; // expected-error {{no member}} expected-note {{'std::semiregular' is defined in}} expected-note {{'std::semiregular' is a}}
+ std::sentinel_for; // expected-error {{no member}} expected-note {{'std::sentinel_for' is defined in}} expected-note {{'std::sentinel_for' is a}}
+ std::set; // expected-error {{no member}} expected-note {{'std::set' is defined in}}
+ std::set_difference; // expected-error {{no member}} expected-note {{'std::set_difference' is defined in}}
+ std::set_intersection; // expected-error {{no member}} expected-note {{'std::set_intersection' is defined in}}
+ std::set_new_handler; // expected-error {{no member}} expected-note {{'std::set_new_handler' is defined in}}
+ std::set_symmetric_difference; // expected-error {{no member}} expected-note {{'std::set_symmetric_difference' is defined in}}
+ std::set_terminate; // expected-error {{no member}} expected-note {{'std::set_terminate' is defined in}}
+ std::set_unexpected; // expected-error {{no member}} expected-note {{'std::set_unexpected' is defined in}}
+ std::set_union; // expected-error {{no member}} expected-note {{'std::set_union' is defined in}}
+ std::setbase; // expected-error {{no member}} expected-note {{'std::setbase' is defined in}}
+ std::setbuf; // expected-error {{no member}} expected-note {{'std::setbuf' is defined in}}
+ std::setfill; // expected-error {{no member}} expected-note {{'std::setfill' is defined in}}
+ std::setiosflags; // expected-error {{no member}} expected-note {{'std::setiosflags' is defined in}}
+ std::setlocale; // expected-error {{no member}} expected-note {{'std::setlocale' is defined in}}
+ std::setprecision; // expected-error {{no member}} expected-note {{'std::setprecision' is defined in}}
+ std::setvbuf; // expected-error {{no member}} expected-note {{'std::setvbuf' is defined in}}
+ std::setw; // expected-error {{no member}} expected-note {{'std::setw' is defined in}}
+ std::shared_future; // expected-error {{no member}} expected-note {{'std::shared_future' is defined in}} expected-note {{'std::shared_future' is a}}
+ std::shared_lock; // expected-error {{no member}} expected-note {{'std::shared_lock' is defined in}} expected-note {{'std::shared_lock' is a}}
+ std::shared_mutex; // expected-error {{no member}} expected-note {{'std::shared_mutex' is defined in}} expected-note {{'std::shared_mutex' is a}}
+ std::shared_ptr; // expected-error {{no member}} expected-note {{'std::shared_ptr' is defined in}} expected-note {{'std::shared_ptr' is a}}
+ std::shared_timed_mutex; // expected-error {{no member}} expected-note {{'std::shared_timed_mutex' is defined in}} expected-note {{'std::shared_timed_mutex' is a}}
+ std::shift_left; // expected-error {{no member}} expected-note {{'std::shift_left' is defined in}} expected-note {{'std::shift_left' is a}}
+ std::shift_right; // expected-error {{no member}} expected-note {{'std::shift_right' is defined in}} expected-note {{'std::shift_right' is a}}
+ std::showbase; // expected-error {{no member}} expected-note {{'std::showbase' is defined in}}
+ std::showbase; // expected-error {{no member}} expected-note {{'std::showbase' is defined in}}
+ std::showpoint; // expected-error {{no member}} expected-note {{'std::showpoint' is defined in}}
+ std::showpoint; // expected-error {{no member}} expected-note {{'std::showpoint' is defined in}}
+ std::showpos; // expected-error {{no member}} expected-note {{'std::showpos' is defined in}}
+ std::showpos; // expected-error {{no member}} expected-note {{'std::showpos' is defined in}}
+ std::shuffle; // expected-error {{no member}} expected-note {{'std::shuffle' is defined in}} expected-note {{'std::shuffle' is a}}
+ std::shuffle_order_engine; // expected-error {{no member}} expected-note {{'std::shuffle_order_engine' is defined in}} expected-note {{'std::shuffle_order_engine' is a}}
+ std::sig_atomic_t; // expected-error {{no member}} expected-note {{'std::sig_atomic_t' is defined in}}
+ std::signal; // expected-error {{no member}} expected-note {{'std::signal' is defined in}}
+ std::signed_integral; // expected-error {{no member}} expected-note {{'std::signed_integral' is defined in}} expected-note {{'std::signed_integral' is a}}
+ std::sinf; // expected-error {{no member}} expected-note {{'std::sinf' is defined in}} expected-note {{'std::sinf' is a}}
+ std::sinhf; // expected-error {{no member}} expected-note {{'std::sinhf' is defined in}} expected-note {{'std::sinhf' is a}}
+ std::sinhl; // expected-error {{no member}} expected-note {{'std::sinhl' is defined in}} expected-note {{'std::sinhl' is a}}
+ std::sinl; // expected-error {{no member}} expected-note {{'std::sinl' is defined in}} expected-note {{'std::sinl' is a}}
+ std::sized_sentinel_for; // expected-error {{no member}} expected-note {{'std::sized_sentinel_for' is defined in}} expected-note {{'std::sized_sentinel_for' is a}}
+ std::skipws; // expected-error {{no member}} expected-note {{'std::skipws' is defined in}}
+ std::skipws; // expected-error {{no member}} expected-note {{'std::skipws' is defined in}}
+ std::slice; // expected-error {{no member}} expected-note {{'std::slice' is defined in}}
+ std::slice_array; // expected-error {{no member}} expected-note {{'std::slice_array' is defined in}}
+ std::smatch; // expected-error {{no member}} expected-note {{'std::smatch' is defined in}} expected-note {{'std::smatch' is a}}
+ std::snprintf; // expected-error {{no member}} expected-note {{'std::snprintf' is defined in}} expected-note {{'std::snprintf' is a}}
+ std::sort; // expected-error {{no member}} expected-note {{'std::sort' is defined in}}
+ std::sort_heap; // expected-error {{no member}} expected-note {{'std::sort_heap' is defined in}}
+ std::sortable; // expected-error {{no member}} expected-note {{'std::sortable' is defined in}} expected-note {{'std::sortable' is a}}
+ std::source_location; // expected-error {{no member}} expected-note {{'std::source_location' is defined in}} expected-note {{'std::source_location' is a}}
+ std::span; // expected-error {{no member}} expected-note {{'std::span' is defined in}} expected-note {{'std::span' is a}}
+ std::spanbuf; // expected-error {{no member}} expected-note {{'std::spanbuf' is defined in}} expected-note {{'std::spanbuf' is a}}
+ std::spanbuf; // expected-error {{no member}} expected-note {{'std::spanbuf' is defined in}} expected-note {{'std::spanbuf' is a}}
+ std::spanstream; // expected-error {{no member}} expected-note {{'std::spanstream' is defined in}} expected-note {{'std::spanstream' is a}}
+ std::spanstream; // expected-error {{no member}} expected-note {{'std::spanstream' is defined in}} expected-note {{'std::spanstream' is a}}
+ std::sph_bessel; // expected-error {{no member}} expected-note {{'std::sph_bessel' is defined in}} expected-note {{'std::sph_bessel' is a}}
+ std::sph_besself; // expected-error {{no member}} expected-note {{'std::sph_besself' is defined in}} expected-note {{'std::sph_besself' is a}}
+ std::sph_bessell; // expected-error {{no member}} expected-note {{'std::sph_bessell' is defined in}} expected-note {{'std::sph_bessell' is a}}
+ std::sph_legendre; // expected-error {{no member}} expected-note {{'std::sph_legendre' is defined in}} expected-note {{'std::sph_legendre' is a}}
+ std::sph_legendref; // expected-error {{no member}} expected-note {{'std::sph_legendref' is defined in}} expected-note {{'std::sph_legendref' is a}}
+ std::sph_legendrel; // expected-error {{no member}} expected-note {{'std::sph_legendrel' is defined in}} expected-note {{'std::sph_legendrel' is a}}
+ std::sph_neumann; // expected-error {{no member}} expected-note {{'std::sph_neumann' is defined in}} expected-note {{'std::sph_neumann' is a}}
+ std::sph_neumannf; // expected-error {{no member}} expected-note {{'std::sph_neumannf' is defined in}} expected-note {{'std::sph_neumannf' is a}}
+ std::sph_neumannl; // expected-error {{no member}} expected-note {{'std::sph_neumannl' is defined in}} expected-note {{'std::sph_neumannl' is a}}
+ std::sprintf; // expected-error {{no member}} expected-note {{'std::sprintf' is defined in}}
+ std::sqrtf; // expected-error {{no member}} expected-note {{'std::sqrtf' is defined in}} expected-note {{'std::sqrtf' is a}}
+ std::sqrtl; // expected-error {{no member}} expected-note {{'std::sqrtl' is defined in}} expected-note {{'std::sqrtl' is a}}
+ std::srand; // expected-error {{no member}} expected-note {{'std::srand' is defined in}}
+ std::sregex_iterator; // expected-error {{no member}} expected-note {{'std::sregex_iterator' is defined in}} expected-note {{'std::sregex_iterator' is a}}
+ std::sregex_token_iterator; // expected-error {{no member}} expected-note {{'std::sregex_token_iterator' is defined in}} expected-note {{'std::sregex_token_iterator' is a}}
+ std::sscanf; // expected-error {{no member}} expected-note {{'std::sscanf' is defined in}}
+ std::ssub_match; // expected-error {{no member}} expected-note {{'std::ssub_match' is defined in}} expected-note {{'std::ssub_match' is a}}
+ std::stable_partition; // expected-error {{no member}} expected-note {{'std::stable_partition' is defined in}}
+ std::stable_sort; // expected-error {{no member}} expected-note {{'std::stable_sort' is defined in}}
+ std::stack; // expected-error {{no member}} expected-note {{'std::stack' is defined in}}
+ std::stacktrace; // expected-error {{no member}} expected-note {{'std::stacktrace' is defined in}} expected-note {{'std::stacktrace' is a}}
+ std::stacktrace_entry; // expected-error {{no member}} expected-note {{'std::stacktrace_entry' is defined in}} expected-note {{'std::stacktrace_entry' is a}}
+ std::start_lifetime_as; // expected-error {{no member}} expected-note {{'std::start_lifetime_as' is defined in}} expected-note {{'std::start_lifetime_as' is a}}
+ std::static_pointer_cast; // expected-error {{no member}} expected-note {{'std::static_pointer_cast' is defined in}} expected-note {{'std::static_pointer_cast' is a}}
+ std::stod; // expected-error {{no member}} expected-note {{'std::stod' is defined in}} expected-note {{'std::stod' is a}}
+ std::stof; // expected-error {{no member}} expected-note {{'std::stof' is defined in}} expected-note {{'std::stof' is a}}
+ std::stoi; // expected-error {{no member}} expected-note {{'std::stoi' is defined in}} expected-note {{'std::stoi' is a}}
+ std::stol; // expected-error {{no member}} expected-note {{'std::stol' is defined in}} expected-note {{'std::stol' is a}}
+ std::stold; // expected-error {{no member}} expected-note {{'std::stold' is defined in}} expected-note {{'std::stold' is a}}
+ std::stoll; // expected-error {{no member}} expected-note {{'std::stoll' is defined in}} expected-note {{'std::stoll' is a}}
+ std::stop_callback; // expected-error {{no member}} expected-note {{'std::stop_callback' is defined in}} expected-note {{'std::stop_callback' is a}}
+ std::stop_source; // expected-error {{no member}} expected-note {{'std::stop_source' is defined in}} expected-note {{'std::stop_source' is a}}
+ std::stop_token; // expected-error {{no member}} expected-note {{'std::stop_token' is defined in}} expected-note {{'std::stop_token' is a}}
+ std::stoul; // expected-error {{no member}} expected-note {{'std::stoul' is defined in}} expected-note {{'std::stoul' is a}}
+ std::stoull; // expected-error {{no member}} expected-note {{'std::stoull' is defined in}} expected-note {{'std::stoull' is a}}
+ std::strcat; // expected-error {{no member}} expected-note {{'std::strcat' is defined in}}
+ std::strchr; // expected-error {{no member}} expected-note {{'std::strchr' is defined in}}
+ std::strcmp; // expected-error {{no member}} expected-note {{'std::strcmp' is defined in}}
+ std::strcoll; // expected-error {{no member}} expected-note {{'std::strcoll' is defined in}}
+ std::strcpy; // expected-error {{no member}} expected-note {{'std::strcpy' is defined in}}
+ std::strcspn; // expected-error {{no member}} expected-note {{'std::strcspn' is defined in}}
+ std::streambuf; // expected-error {{no member}} expected-note {{'std::streambuf' is defined in}}
+ std::streambuf; // expected-error {{no member}} expected-note {{'std::streambuf' is defined in}}
+ std::streambuf; // expected-error {{no member}} expected-note {{'std::streambuf' is defined in}}
+ std::streamoff; // expected-error {{no member}} expected-note {{'std::streamoff' is defined in}}
+ std::streamoff; // expected-error {{no member}} expected-note {{'std::streamoff' is defined in}}
+ std::streampos; // expected-error {{no member}} expected-note {{'std::streampos' is defined in}}
+ std::streampos; // expected-error {{no member}} expected-note {{'std::streampos' is defined in}}
+ std::streamsize; // expected-error {{no member}} expected-note {{'std::streamsize' is defined in}}
+ std::streamsize; // expected-error {{no member}} expected-note {{'std::streamsize' is defined in}}
+ std::strerror; // expected-error {{no member}} expected-note {{'std::strerror' is defined in}}
+ std::strftime; // expected-error {{no member}} expected-note {{'std::strftime' is defined in}}
+ std::strict; // expected-error {{no member}} expected-note {{'std::strict' is defined in}} expected-note {{'std::strict' is a}}
+ std::strict_weak_order; // expected-error {{no member}} expected-note {{'std::strict_weak_order' is defined in}} expected-note {{'std::strict_weak_order' is a}}
+ std::strided_slice; // expected-error {{no member}} expected-note {{'std::strided_slice' is defined in}} expected-note {{'std::strided_slice' is a}}
+ std::string; // expected-error {{no member}} expected-note {{'std::string' is defined in}}
+ std::string_view; // expected-error {{no member}} expected-note {{'std::string_view' is defined in}} expected-note {{'std::string_view' is a}}
+ std::stringbuf; // expected-error {{no member}} expected-note {{'std::stringbuf' is defined in}}
+ std::stringbuf; // expected-error {{no member}} expected-note {{'std::stringbuf' is defined in}}
+ std::stringstream; // expected-error {{no member}} expected-note {{'std::stringstream' is defined in}}
+ std::stringstream; // expected-error {{no member}} expected-note {{'std::stringstream' is defined in}}
+ std::strlen; // expected-error {{no member}} expected-note {{'std::strlen' is defined in}}
+ std::strncat; // expected-error {{no member}} expected-note {{'std::strncat' is defined in}}
+ std::strncmp; // expected-error {{no member}} expected-note {{'std::strncmp' is defined in}}
+ std::strncpy; // expected-error {{no member}} expected-note {{'std::strncpy' is defined in}}
+ std::strong_order; // expected-error {{no member}} expected-note {{'std::strong_order' is defined in}} expected-note {{'std::strong_order' is a}}
+ std::strong_ordering; // expected-error {{no member}} expected-note {{'std::strong_ordering' is defined in}} expected-note {{'std::strong_ordering' is a}}
+ std::strpbrk; // expected-error {{no member}} expected-note {{'std::strpbrk' is defined in}}
+ std::strrchr; // expected-error {{no member}} expected-note {{'std::strrchr' is defined in}}
+ std::strspn; // expected-error {{no member}} expected-note {{'std::strspn' is defined in}}
+ std::strstr; // expected-error {{no member}} expected-note {{'std::strstr' is defined in}}
+ std::strstream; // expected-error {{no member}} expected-note {{'std::strstream' is defined in}}
+ std::strstreambuf; // expected-error {{no member}} expected-note {{'std::strstreambuf' is defined in}}
+ std::strtod; // expected-error {{no member}} expected-note {{'std::strtod' is defined in}}
+ std::strtof; // expected-error {{no member}} expected-note {{'std::strtof' is defined in}} expected-note {{'std::strtof' is a}}
+ std::strtoimax; // expected-error {{no member}} expected-note {{'std::strtoimax' is defined in}} expected-note {{'std::strtoimax' is a}}
+ std::strtok; // expected-error {{no member}} expected-note {{'std::strtok' is defined in}}
+ std::strtol; // expected-error {{no member}} expected-note {{'std::strtol' is defined in}}
+ std::strtold; // expected-error {{no member}} expected-note {{'std::strtold' is defined in}}
+ std::strtoll; // expected-error {{no member}} expected-note {{'std::strtoll' is defined in}} expected-note {{'std::strtoll' is a}}
+ std::strtoul; // expected-error {{no member}} expected-note {{'std::strtoul' is defined in}}
+ std::strtoull; // expected-error {{no member}} expected-note {{'std::strtoull' is defined in}} expected-note {{'std::strtoull' is a}}
+ std::strtoumax; // expected-error {{no member}} expected-note {{'std::strtoumax' is defined in}} expected-note {{'std::strtoumax' is a}}
+ std::strxfrm; // expected-error {{no member}} expected-note {{'std::strxfrm' is defined in}}
+ std::student_t_distribution; // expected-error {{no member}} expected-note {{'std::student_t_distribution' is defined in}} expected-note {{'std::student_t_distribution' is a}}
+ std::sub_match; // expected-error {{no member}} expected-note {{'std::sub_match' is defined in}} expected-note {{'std::sub_match' is a}}
+ std::sub_sat; // expected-error {{no member}} expected-note {{'std::sub_sat' is defined in}} expected-note {{'std::sub_sat' is a}}
+ std::submdspan_mapping_result; // expected-error {{no member}} expected-note {{'std::submdspan_mapping_result' is defined in}} expected-note {{'std::submdspan_mapping_result' is a}}
+ std::subtract_with_carry_engine; // expected-error {{no member}} expected-note {{'std::subtract_with_carry_engine' is defined in}} expected-note {{'std::subtract_with_carry_engine' is a}}
+ std::suspend_always; // expected-error {{no member}} expected-note {{'std::suspend_always' is defined in}} expected-note {{'std::suspend_always' is a}}
+ std::suspend_never; // expected-error {{no member}} expected-note {{'std::suspend_never' is defined in}} expected-note {{'std::suspend_never' is a}}
+ std::swap_ranges; // expected-error {{no member}} expected-note {{'std::swap_ranges' is defined in}}
+ std::swappable; // expected-error {{no member}} expected-note {{'std::swappable' is defined in}} expected-note {{'std::swappable' is a}}
+ std::swappable_with; // expected-error {{no member}} expected-note {{'std::swappable_with' is defined in}} expected-note {{'std::swappable_with' is a}}
+ std::swprintf; // expected-error {{no member}} expected-note {{'std::swprintf' is defined in}}
+ std::swscanf; // expected-error {{no member}} expected-note {{'std::swscanf' is defined in}}
+ std::syncbuf; // expected-error {{no member}} expected-note {{'std::syncbuf' is defined in}} expected-note {{'std::syncbuf' is a}}
+ std::syncbuf; // expected-error {{no member}} expected-note {{'std::syncbuf' is defined in}} expected-note {{'std::syncbuf' is a}}
+ std::system; // expected-error {{no member}} expected-note {{'std::system' is defined in}}
+ std::system_category; // expected-error {{no member}} expected-note {{'std::system_category' is defined in}} expected-note {{'std::system_category' is a}}
+ std::system_error; // expected-error {{no member}} expected-note {{'std::system_error' is defined in}} expected-note {{'std::system_error' is a}}
+ std::tanf; // expected-error {{no member}} expected-note {{'std::tanf' is defined in}} expected-note {{'std::tanf' is a}}
+ std::tanhf; // expected-error {{no member}} expected-note {{'std::tanhf' is defined in}} expected-note {{'std::tanhf' is a}}
+ std::tanhl; // expected-error {{no member}} expected-note {{'std::tanhl' is defined in}} expected-note {{'std::tanhl' is a}}
+ std::tanl; // expected-error {{no member}} expected-note {{'std::tanl' is defined in}} expected-note {{'std::tanl' is a}}
+ std::tera; // expected-error {{no member}} expected-note {{'std::tera' is defined in}} expected-note {{'std::tera' is a}}
+ std::terminate; // expected-error {{no member}} expected-note {{'std::terminate' is defined in}}
+ std::terminate_handler; // expected-error {{no member}} expected-note {{'std::terminate_handler' is defined in}}
+ std::text_encoding; // expected-error {{no member}} expected-note {{'std::text_encoding' is defined in}} expected-note {{'std::text_encoding' is a}}
+ std::tgammaf; // expected-error {{no member}} expected-note {{'std::tgammaf' is defined in}} expected-note {{'std::tgammaf' is a}}
+ std::tgammal; // expected-error {{no member}} expected-note {{'std::tgammal' is defined in}} expected-note {{'std::tgammal' is a}}
+ std::thread; // expected-error {{no member}} expected-note {{'std::thread' is defined in}} expected-note {{'std::thread' is a}}
+ std::three_way_comparable; // expected-error {{no member}} expected-note {{'std::three_way_comparable' is defined in}} expected-note {{'std::three_way_comparable' is a}}
+ std::three_way_comparable_with; // expected-error {{no member}} expected-note {{'std::three_way_comparable_with' is defined in}} expected-note {{'std::three_way_comparable_with' is a}}
+ std::throw_with_nested; // expected-error {{no member}} expected-note {{'std::throw_with_nested' is defined in}} expected-note {{'std::throw_with_nested' is a}}
+ std::tie; // expected-error {{no member}} expected-note {{'std::tie' is defined in}} expected-note {{'std::tie' is a}}
+ std::time; // expected-error {{no member}} expected-note {{'std::time' is defined in}}
+ std::time_base; // expected-error {{no member}} expected-note {{'std::time_base' is defined in}}
+ std::time_get; // expected-error {{no member}} expected-note {{'std::time_get' is defined in}}
+ std::time_get_byname; // expected-error {{no member}} expected-note {{'std::time_get_byname' is defined in}}
+ std::time_put; // expected-error {{no member}} expected-note {{'std::time_put' is defined in}}
+ std::time_put_byname; // expected-error {{no member}} expected-note {{'std::time_put_byname' is defined in}}
+ std::time_t; // expected-error {{no member}} expected-note {{'std::time_t' is defined in}}
+ std::timed_mutex; // expected-error {{no member}} expected-note {{'std::timed_mutex' is defined in}} expected-note {{'std::timed_mutex' is a}}
+ std::timespec; // expected-error {{no member}} expected-note {{'std::timespec' is defined in}} expected-note {{'std::timespec' is a}}
+ std::timespec_get; // expected-error {{no member}} expected-note {{'std::timespec_get' is defined in}} expected-note {{'std::timespec_get' is a}}
+ std::tm; // expected-error {{no member}} expected-note {{'std::tm' is defined in}}
+ std::tmpfile; // expected-error {{no member}} expected-note {{'std::tmpfile' is defined in}}
+ std::tmpnam; // expected-error {{no member}} expected-note {{'std::tmpnam' is defined in}}
+ std::to_address; // expected-error {{no member}} expected-note {{'std::to_address' is defined in}} expected-note {{'std::to_address' is a}}
+ std::to_array; // expected-error {{no member}} expected-note {{'std::to_array' is defined in}} expected-note {{'std::to_array' is a}}
+ std::to_chars; // expected-error {{no member}} expected-note {{'std::to_chars' is defined in}} expected-note {{'std::to_chars' is a}}
+ std::to_chars_result; // expected-error {{no member}} expected-note {{'std::to_chars_result' is defined in}} expected-note {{'std::to_chars_result' is a}}
+ std::to_integer; // expected-error {{no member}} expected-note {{'std::to_integer' is defined in}} expected-note {{'std::to_integer' is a}}
+ std::to_string; // expected-error {{no member}} expected-note {{'std::to_string' is defined in}} expected-note {{'std::to_string' is a}}
+ std::to_underlying; // expected-error {{no member}} expected-note {{'std::to_underlying' is defined in}} expected-note {{'std::to_underlying' is a}}
+ std::to_wstring; // expected-error {{no member}} expected-note {{'std::to_wstring' is defined in}} expected-note {{'std::to_wstring' is a}}
+ std::tolower; // expected-error {{no member}} expected-note {{'std::tolower' is defined in}}
+ std::totally_ordered; // expected-error {{no member}} expected-note {{'std::totally_ordered' is defined in}} expected-note {{'std::totally_ordered' is a}}
+ std::totally_ordered_with; // expected-error {{no member}} expected-note {{'std::totally_ordered_with' is defined in}} expected-note {{'std::totally_ordered_with' is a}}
+ std::toupper; // expected-error {{no member}} expected-note {{'std::toupper' is defined in}}
+ std::towctrans; // expected-error {{no member}} expected-note {{'std::towctrans' is defined in}}
+ std::towlower; // expected-error {{no member}} expected-note {{'std::towlower' is defined in}}
+ std::towupper; // expected-error {{no member}} expected-note {{'std::towupper' is defined in}}
+ std::transform; // expected-error {{no member}} expected-note {{'std::transform' is defined in}}
+ std::transform_exclusive_scan; // expected-error {{no member}} expected-note {{'std::transform_exclusive_scan' is defined in}} expected-note {{'std::transform_exclusive_scan' is a}}
+ std::transform_inclusive_scan; // expected-error {{no member}} expected-note {{'std::transform_inclusive_scan' is defined in}} expected-note {{'std::transform_inclusive_scan' is a}}
+ std::transform_reduce; // expected-error {{no member}} expected-note {{'std::transform_reduce' is defined in}} expected-note {{'std::transform_reduce' is a}}
+ std::true_type; // expected-error {{no member}} expected-note {{'std::true_type' is defined in}} expected-note {{'std::true_type' is a}}
+ std::truncf; // expected-error {{no member}} expected-note {{'std::truncf' is defined in}} expected-note {{'std::truncf' is a}}
+ std::truncl; // expected-error {{no member}} expected-note {{'std::truncl' is defined in}} expected-note {{'std::truncl' is a}}
+ std::try_lock; // expected-error {{no member}} expected-note {{'std::try_lock' is defined in}} expected-note {{'std::try_lock' is a}}
+ std::try_to_lock; // expected-error {{no member}} expected-note {{'std::try_to_lock' is defined in}} expected-note {{'std::try_to_lock' is a}}
+ std::try_to_lock_t; // expected-error {{no member}} expected-note {{'std::try_to_lock_t' is defined in}} expected-note {{'std::try_to_lock_t' is a}}
+ std::tuple; // expected-error {{no member}} expected-note {{'std::tuple' is defined in}} expected-note {{'std::tuple' is a}}
+ std::tuple_cat; // expected-error {{no member}} expected-note {{'std::tuple_cat' is defined in}} expected-note {{'std::tuple_cat' is a}}
+ std::tuple_element_t; // expected-error {{no member}} expected-note {{'std::tuple_element_t' is defined in}} expected-note {{'std::tuple_element_t' is a}}
+ std::tuple_size_v; // expected-error {{no member}} expected-note {{'std::tuple_size_v' is defined in}} expected-note {{'std::tuple_size_v' is a}}
+ std::type_identity; // expected-error {{no member}} expected-note {{'std::type_identity' is defined in}} expected-note {{'std::type_identity' is a}}
+ std::type_identity_t; // expected-error {{no member}} expected-note {{'std::type_identity_t' is defined in}} expected-note {{'std::type_identity_t' is a}}
+ std::type_index; // expected-error {{no member}} expected-note {{'std::type_index' is defined in}} expected-note {{'std::type_index' is a}}
+ std::type_info; // expected-error {{no member}} expected-note {{'std::type_info' is defined in}}
+ std::u16streampos; // expected-error {{no member}} expected-note {{'std::u16streampos' is defined in}} expected-note {{'std::u16streampos' is a}}
+ std::u16streampos; // expected-error {{no member}} expected-note {{'std::u16streampos' is defined in}} expected-note {{'std::u16streampos' is a}}
+ std::u16string; // expected-error {{no member}} expected-note {{'std::u16string' is defined in}} expected-note {{'std::u16string' is a}}
+ std::u16string_view; // expected-error {{no member}} expected-note {{'std::u16string_view' is defined in}} expected-note {{'std::u16string_view' is a}}
+ std::u32streampos; // expected-error {{no member}} expected-note {{'std::u32streampos' is defined in}} expected-note {{'std::u32streampos' is a}}
+ std::u32streampos; // expected-error {{no member}} expected-note {{'std::u32streampos' is defined in}} expected-note {{'std::u32streampos' is a}}
+ std::u32string; // expected-error {{no member}} expected-note {{'std::u32string' is defined in}} expected-note {{'std::u32string' is a}}
+ std::u32string_view; // expected-error {{no member}} expected-note {{'std::u32string_view' is defined in}} expected-note {{'std::u32string_view' is a}}
+ std::u8streampos; // expected-error {{no member}} expected-note {{'std::u8streampos' is defined in}} expected-note {{'std::u8streampos' is a}}
+ std::u8streampos; // expected-error {{no member}} expected-note {{'std::u8streampos' is defined in}} expected-note {{'std::u8streampos' is a}}
+ std::u8string; // expected-error {{no member}} expected-note {{'std::u8string' is defined in}} expected-note {{'std::u8string' is a}}
+ std::u8string_view; // expected-error {{no member}} expected-note {{'std::u8string_view' is defined in}} expected-note {{'std::u8string_view' is a}}
+ std::uint16_t; // expected-error {{no member}} expected-note {{'std::uint16_t' is defined in}} expected-note {{'std::uint16_t' is a}}
+ std::uint32_t; // expected-error {{no member}} expected-note {{'std::uint32_t' is defined in}} expected-note {{'std::uint32_t' is a}}
+ std::uint64_t; // expected-error {{no member}} expected-note {{'std::uint64_t' is defined in}} expected-note {{'std::uint64_t' is a}}
+ std::uint8_t; // expected-error {{no member}} expected-note {{'std::uint8_t' is defined in}} expected-note {{'std::uint8_t' is a}}
+ std::uint_fast16_t; // expected-error {{no member}} expected-note {{'std::uint_fast16_t' is defined in}} expected-note {{'std::uint_fast16_t' is a}}
+ std::uint_fast32_t; // expected-error {{no member}} expected-note {{'std::uint_fast32_t' is defined in}} expected-note {{'std::uint_fast32_t' is a}}
+ std::uint_fast64_t; // expected-error {{no member}} expected-note {{'std::uint_fast64_t' is defined in}} expected-note {{'std::uint_fast64_t' is a}}
+ std::uint_fast8_t; // expected-error {{no member}} expected-note {{'std::uint_fast8_t' is defined in}} expected-note {{'std::uint_fast8_t' is a}}
+ std::uint_least16_t; // expected-error {{no member}} expected-note {{'std::uint_least16_t' is defined in}} expected-note {{'std::uint_least16_t' is a}}
+ std::uint_least32_t; // expected-error {{no member}} expected-note {{'std::uint_least32_t' is defined in}} expected-note {{'std::uint_least32_t' is a}}
+ std::uint_least64_t; // expected-error {{no member}} expected-note {{'std::uint_least64_t' is defined in}} expected-note {{'std::uint_least64_t' is a}}
+ std::uint_least8_t; // expected-error {{no member}} expected-note {{'std::uint_least8_t' is defined in}} expected-note {{'std::uint_least8_t' is a}}
+ std::uintmax_t; // expected-error {{no member}} expected-note {{'std::uintmax_t' is defined in}} expected-note {{'std::uintmax_t' is a}}
+ std::uintptr_t; // expected-error {{no member}} expected-note {{'std::uintptr_t' is defined in}} expected-note {{'std::uintptr_t' is a}}
+ std::unary_function; // expected-error {{no member}} expected-note {{'std::unary_function' is defined in}}
+ std::unary_negate; // expected-error {{no member}} expected-note {{'std::unary_negate' is defined in}}
+ std::uncaught_exception; // expected-error {{no member}} expected-note {{'std::uncaught_exception' is defined in}}
+ std::uncaught_exceptions; // expected-error {{no member}} expected-note {{'std::uncaught_exceptions' is defined in}} expected-note {{'std::uncaught_exceptions' is a}}
+ std::undeclare_no_pointers; // expected-error {{no member}} expected-note {{'std::undeclare_no_pointers' is defined in}} expected-note {{'std::undeclare_no_pointers' is a}}
+ std::undeclare_reachable; // expected-error {{no member}} expected-note {{'std::undeclare_reachable' is defined in}} expected-note {{'std::undeclare_reachable' is a}}
+ std::underflow_error; // expected-error {{no member}} expected-note {{'std::underflow_error' is defined in}}
+ std::underlying_type; // expected-error {{no member}} expected-note {{'std::underlying_type' is defined in}} expected-note {{'std::underlying_type' is a}}
+ std::underlying_type_t; // expected-error {{no member}} expected-note {{'std::underlying_type_t' is defined in}} expected-note {{'std::underlying_type_t' is a}}
+ std::unexpect; // expected-error {{no member}} expected-note {{'std::unexpect' is defined in}} expected-note {{'std::unexpect' is a}}
+ std::unexpect_t; // expected-error {{no member}} expected-note {{'std::unexpect_t' is defined in}} expected-note {{'std::unexpect_t' is a}}
+ std::unexpected; // expected-error {{no member}} expected-note {{'std::unexpected' is defined in}} expected-note {{'std::unexpected' is a}}
+ std::unexpected_handler; // expected-error {{no member}} expected-note {{'std::unexpected_handler' is defined in}}
+ std::ungetc; // expected-error {{no member}} expected-note {{'std::ungetc' is defined in}}
+ std::ungetwc; // expected-error {{no member}} expected-note {{'std::ungetwc' is defined in}}
+ std::uniform_int_distribution; // expected-error {{no member}} expected-note {{'std::uniform_int_distribution' is defined in}} expected-note {{'std::uniform_int_distribution' is a}}
+ std::uniform_random_bit_generator; // expected-error {{no member}} expected-note {{'std::uniform_random_bit_generator' is defined in}} expected-note {{'std::uniform_random_bit_generator' is a}}
+ std::uniform_real_distribution; // expected-error {{no member}} expected-note {{'std::uniform_real_distribution' is defined in}} expected-note {{'std::uniform_real_distribution' is a}}
+ std::uninitialized_construct_using_allocator; // expected-error {{no member}} expected-note {{'std::uninitialized_construct_using_allocator' is defined in}} expected-note {{'std::uninitialized_construct_using_allocator' is a}}
+ std::uninitialized_copy; // expected-error {{no member}} expected-note {{'std::uninitialized_copy' is defined in}}
+ std::uninitialized_copy_n; // expected-error {{no member}} expected-note {{'std::uninitialized_copy_n' is defined in}} expected-note {{'std::uninitialized_copy_n' is a}}
+ std::uninitialized_default_construct; // expected-error {{no member}} expected-note {{'std::uninitialized_default_construct' is defined in}} expected-note {{'std::uninitialized_default_construct' is a}}
+ std::uninitialized_default_construct_n; // expected-error {{no member}} expected-note {{'std::uninitialized_default_construct_n' is defined in}} expected-note {{'std::uninitialized_default_construct_n' is a}}
+ std::uninitialized_fill; // expected-error {{no member}} expected-note {{'std::uninitialized_fill' is defined in}}
+ std::uninitialized_fill_n; // expected-error {{no member}} expected-note {{'std::uninitialized_fill_n' is defined in}}
+ std::uninitialized_move; // expected-error {{no member}} expected-note {{'std::uninitialized_move' is defined in}} expected-note {{'std::uninitialized_move' is a}}
+ std::uninitialized_move_n; // expected-error {{no member}} expected-note {{'std::uninitialized_move_n' is defined in}} expected-note {{'std::uninitialized_move_n' is a}}
+ std::uninitialized_value_construct; // expected-error {{no member}} expected-note {{'std::uninitialized_value_construct' is defined in}} expected-note {{'std::uninitialized_value_construct' is a}}
+ std::uninitialized_value_construct_n; // expected-error {{no member}} expected-note {{'std::uninitialized_value_construct_n' is defined in}} expected-note {{'std::uninitialized_value_construct_n' is a}}
+ std::unique; // expected-error {{no member}} expected-note {{'std::unique' is defined in}}
+ std::unique_copy; // expected-error {{no member}} expected-note {{'std::unique_copy' is defined in}}
+ std::unique_lock; // expected-error {{no member}} expected-note {{'std::unique_lock' is defined in}} expected-note {{'std::unique_lock' is a}}
+ std::unique_ptr; // expected-error {{no member}} expected-note {{'std::unique_ptr' is defined in}} expected-note {{'std::unique_ptr' is a}}
+ std::unitbuf; // expected-error {{no member}} expected-note {{'std::unitbuf' is defined in}}
+ std::unitbuf; // expected-error {{no member}} expected-note {{'std::unitbuf' is defined in}}
+ std::unordered_map; // expected-error {{no member}} expected-note {{'std::unordered_map' is defined in}} expected-note {{'std::unordered_map' is a}}
+ std::unordered_multimap; // expected-error {{no member}} expected-note {{'std::unordered_multimap' is defined in}} expected-note {{'std::unordered_multimap' is a}}
+ std::unordered_multiset; // expected-error {{no member}} expected-note {{'std::unordered_multiset' is defined in}} expected-note {{'std::unordered_multiset' is a}}
+ std::unordered_set; // expected-error {{no member}} expected-note {{'std::unordered_set' is defined in}} expected-note {{'std::unordered_set' is a}}
+ std::unreachable; // expected-error {{no member}} expected-note {{'std::unreachable' is defined in}} expected-note {{'std::unreachable' is a}}
+ std::unreachable_sentinel; // expected-error {{no member}} expected-note {{'std::unreachable_sentinel' is defined in}} expected-note {{'std::unreachable_sentinel' is a}}
+ std::unreachable_sentinel_t; // expected-error {{no member}} expected-note {{'std::unreachable_sentinel_t' is defined in}} expected-note {{'std::unreachable_sentinel_t' is a}}
+ std::unsigned_integral; // expected-error {{no member}} expected-note {{'std::unsigned_integral' is defined in}} expected-note {{'std::unsigned_integral' is a}}
+ std::upper_bound; // expected-error {{no member}} expected-note {{'std::upper_bound' is defined in}}
+ std::uppercase; // expected-error {{no member}} expected-note {{'std::uppercase' is defined in}}
+ std::uppercase; // expected-error {{no member}} expected-note {{'std::uppercase' is defined in}}
+ std::use_facet; // expected-error {{no member}} expected-note {{'std::use_facet' is defined in}}
+ std::uses_allocator; // expected-error {{no member}} expected-note {{'std::uses_allocator' is defined in}} expected-note {{'std::uses_allocator' is a}}
+ std::uses_allocator_construction_args; // expected-error {{no member}} expected-note {{'std::uses_allocator_construction_args' is defined in}} expected-note {{'std::uses_allocator_construction_args' is a}}
+ std::uses_allocator_v; // expected-error {{no member}} expected-note {{'std::uses_allocator_v' is defined in}} expected-note {{'std::uses_allocator_v' is a}}
+ std::va_list; // expected-error {{no member}} expected-note {{'std::va_list' is defined in}}
+ std::valarray; // expected-error {{no member}} expected-note {{'std::valarray' is defined in}}
+ std::variant; // expected-error {{no member}} expected-note {{'std::variant' is defined in}} expected-note {{'std::variant' is a}}
+ std::variant_alternative; // expected-error {{no member}} expected-note {{'std::variant_alternative' is defined in}} expected-note {{'std::variant_alternative' is a}}
+ std::variant_alternative_t; // expected-error {{no member}} expected-note {{'std::variant_alternative_t' is defined in}} expected-note {{'std::variant_alternative_t' is a}}
+ std::variant_npos; // expected-error {{no member}} expected-note {{'std::variant_npos' is defined in}} expected-note {{'std::variant_npos' is a}}
+ std::variant_size; // expected-error {{no member}} expected-note {{'std::variant_size' is defined in}} expected-note {{'std::variant_size' is a}}
+ std::variant_size_v; // expected-error {{no member}} expected-note {{'std::variant_size_v' is defined in}} expected-note {{'std::variant_size_v' is a}}
+ std::vector; // expected-error {{no member}} expected-note {{'std::vector' is defined in}}
+ std::vformat; // expected-error {{no member}} expected-note {{'std::vformat' is defined in}} expected-note {{'std::vformat' is a}}
+ std::vformat_to; // expected-error {{no member}} expected-note {{'std::vformat_to' is defined in}} expected-note {{'std::vformat_to' is a}}
+ std::vfprintf; // expected-error {{no member}} expected-note {{'std::vfprintf' is defined in}}
+ std::vfscanf; // expected-error {{no member}} expected-note {{'std::vfscanf' is defined in}} expected-note {{'std::vfscanf' is a}}
+ std::vfwprintf; // expected-error {{no member}} expected-note {{'std::vfwprintf' is defined in}}
+ std::vfwscanf; // expected-error {{no member}} expected-note {{'std::vfwscanf' is defined in}} expected-note {{'std::vfwscanf' is a}}
+ std::visit; // expected-error {{no member}} expected-note {{'std::visit' is defined in}} expected-note {{'std::visit' is a}}
+ std::visit_format_arg; // expected-error {{no member}} expected-note {{'std::visit_format_arg' is defined in}} expected-note {{'std::visit_format_arg' is a}}
+ std::void_t; // expected-error {{no member}} expected-note {{'std::void_t' is defined in}} expected-note {{'std::void_t' is a}}
+ std::vprint_nonunicode; // expected-error {{no member}} expected-note {{'std::vprint_nonunicode' is defined in}} expected-note {{'std::vprint_nonunicode' is a}}
+ std::vprint_nonunicode_buffered; // expected-error {{no member}} expected-note {{'std::vprint_nonunicode_buffered' is defined in}} expected-note {{'std::vprint_nonunicode_buffered' is a}}
+ std::vprint_unicode; // expected-error {{no member}} expected-note {{'std::vprint_unicode' is defined in}} expected-note {{'std::vprint_unicode' is a}}
+ std::vprint_unicode_buffered; // expected-error {{no member}} expected-note {{'std::vprint_unicode_buffered' is defined in}} expected-note {{'std::vprint_unicode_buffered' is a}}
+ std::vprintf; // expected-error {{no member}} expected-note {{'std::vprintf' is defined in}}
+ std::vscanf; // expected-error {{no member}} expected-note {{'std::vscanf' is defined in}} expected-note {{'std::vscanf' is a}}
+ std::vsnprintf; // expected-error {{no member}} expected-note {{'std::vsnprintf' is defined in}} expected-note {{'std::vsnprintf' is a}}
+ std::vsprintf; // expected-error {{no member}} expected-note {{'std::vsprintf' is defined in}}
+ std::vsscanf; // expected-error {{no member}} expected-note {{'std::vsscanf' is defined in}} expected-note {{'std::vsscanf' is a}}
+ std::vswprintf; // expected-error {{no member}} expected-note {{'std::vswprintf' is defined in}}
+ std::vswscanf; // expected-error {{no member}} expected-note {{'std::vswscanf' is defined in}} expected-note {{'std::vswscanf' is a}}
+ std::vwprintf; // expected-error {{no member}} expected-note {{'std::vwprintf' is defined in}}
+ std::vwscanf; // expected-error {{no member}} expected-note {{'std::vwscanf' is defined in}} expected-note {{'std::vwscanf' is a}}
+ std::wbuffer_convert; // expected-error {{no member}} expected-note {{'std::wbuffer_convert' is defined in}}
+ std::wbuffer_convert; // expected-error {{no member}} expected-note {{'std::wbuffer_convert' is defined in}}
+ std::wcerr; // expected-error {{no member}} expected-note {{'std::wcerr' is defined in}}
+ std::wcin; // expected-error {{no member}} expected-note {{'std::wcin' is defined in}}
+ std::wclog; // expected-error {{no member}} expected-note {{'std::wclog' is defined in}}
+ std::wcmatch; // expected-error {{no member}} expected-note {{'std::wcmatch' is defined in}} expected-note {{'std::wcmatch' is a}}
+ std::wcout; // expected-error {{no member}} expected-note {{'std::wcout' is defined in}}
+ std::wcregex_iterator; // expected-error {{no member}} expected-note {{'std::wcregex_iterator' is defined in}} expected-note {{'std::wcregex_iterator' is a}}
+ std::wcregex_token_iterator; // expected-error {{no member}} expected-note {{'std::wcregex_token_iterator' is defined in}} expected-note {{'std::wcregex_token_iterator' is a}}
+ std::wcrtomb; // expected-error {{no member}} expected-note {{'std::wcrtomb' is defined in}}
+ std::wcscat; // expected-error {{no member}} expected-note {{'std::wcscat' is defined in}}
+ std::wcschr; // expected-error {{no member}} expected-note {{'std::wcschr' is defined in}}
+ std::wcscmp; // expected-error {{no member}} expected-note {{'std::wcscmp' is defined in}}
+ std::wcscoll; // expected-error {{no member}} expected-note {{'std::wcscoll' is defined in}}
+ std::wcscpy; // expected-error {{no member}} expected-note {{'std::wcscpy' is defined in}}
+ std::wcscspn; // expected-error {{no member}} expected-note {{'std::wcscspn' is defined in}}
+ std::wcsftime; // expected-error {{no member}} expected-note {{'std::wcsftime' is defined in}}
+ std::wcslen; // expected-error {{no member}} expected-note {{'std::wcslen' is defined in}}
+ std::wcsncat; // expected-error {{no member}} expected-note {{'std::wcsncat' is defined in}}
+ std::wcsncmp; // expected-error {{no member}} expected-note {{'std::wcsncmp' is defined in}}
+ std::wcsncpy; // expected-error {{no member}} expected-note {{'std::wcsncpy' is defined in}}
+ std::wcspbrk; // expected-error {{no member}} expected-note {{'std::wcspbrk' is defined in}}
+ std::wcsrchr; // expected-error {{no member}} expected-note {{'std::wcsrchr' is defined in}}
+ std::wcsrtombs; // expected-error {{no member}} expected-note {{'std::wcsrtombs' is defined in}}
+ std::wcsspn; // expected-error {{no member}} expected-note {{'std::wcsspn' is defined in}}
+ std::wcsstr; // expected-error {{no member}} expected-note {{'std::wcsstr' is defined in}}
+ std::wcstod; // expected-error {{no member}} expected-note {{'std::wcstod' is defined in}}
+ std::wcstof; // expected-error {{no member}} expected-note {{'std::wcstof' is defined in}} expected-note {{'std::wcstof' is a}}
+ std::wcstoimax; // expected-error {{no member}} expected-note {{'std::wcstoimax' is defined in}} expected-note {{'std::wcstoimax' is a}}
+ std::wcstok; // expected-error {{no member}} expected-note {{'std::wcstok' is defined in}}
+ std::wcstol; // expected-error {{no member}} expected-note {{'std::wcstol' is defined in}}
+ std::wcstold; // expected-error {{no member}} expected-note {{'std::wcstold' is defined in}} expected-note {{'std::wcstold' is a}}
+ std::wcstoll; // expected-error {{no member}} expected-note {{'std::wcstoll' is defined in}} expected-note {{'std::wcstoll' is a}}
+ std::wcstombs; // expected-error {{no member}} expected-note {{'std::wcstombs' is defined in}}
+ std::wcstoul; // expected-error {{no member}} expected-note {{'std::wcstoul' is defined in}}
+ std::wcstoull; // expected-error {{no member}} expected-note {{'std::wcstoull' is defined in}} expected-note {{'std::wcstoull' is a}}
+ std::wcstoumax; // expected-error {{no member}} expected-note {{'std::wcstoumax' is defined in}} expected-note {{'std::wcstoumax' is a}}
+ std::wcsub_match; // expected-error {{no member}} expected-note {{'std::wcsub_match' is defined in}} expected-note {{'std::wcsub_match' is a}}
+ std::wcsxfrm; // expected-error {{no member}} expected-note {{'std::wcsxfrm' is defined in}}
+ std::wctob; // expected-error {{no member}} expected-note {{'std::wctob' is defined in}}
+ std::wctomb; // expected-error {{no member}} expected-note {{'std::wctomb' is defined in}}
+ std::wctrans; // expected-error {{no member}} expected-note {{'std::wctrans' is defined in}}
+ std::wctrans_t; // expected-error {{no member}} expected-note {{'std::wctrans_t' is defined in}}
+ std::wctype; // expected-error {{no member}} expected-note {{'std::wctype' is defined in}}
+ std::wctype_t; // expected-error {{no member}} expected-note {{'std::wctype_t' is defined in}}
+ std::weak_order; // expected-error {{no member}} expected-note {{'std::weak_order' is defined in}} expected-note {{'std::weak_order' is a}}
+ std::weak_ordering; // expected-error {{no member}} expected-note {{'std::weak_ordering' is defined in}} expected-note {{'std::weak_ordering' is a}}
+ std::weak_ptr; // expected-error {{no member}} expected-note {{'std::weak_ptr' is defined in}} expected-note {{'std::weak_ptr' is a}}
+ std::weakly_incrementable; // expected-error {{no member}} expected-note {{'std::weakly_incrementable' is defined in}} expected-note {{'std::weakly_incrementable' is a}}
+ std::weibull_distribution; // expected-error {{no member}} expected-note {{'std::weibull_distribution' is defined in}} expected-note {{'std::weibull_distribution' is a}}
+ std::wfilebuf; // expected-error {{no member}} expected-note {{'std::wfilebuf' is defined in}}
+ std::wfilebuf; // expected-error {{no member}} expected-note {{'std::wfilebuf' is defined in}}
+ std::wformat_args; // expected-error {{no member}} expected-note {{'std::wformat_args' is defined in}} expected-note {{'std::wformat_args' is a}}
+ std::wformat_context; // expected-error {{no member}} expected-note {{'std::wformat_context' is defined in}} expected-note {{'std::wformat_context' is a}}
+ std::wformat_parse_context; // expected-error {{no member}} expected-note {{'std::wformat_parse_context' is defined in}} expected-note {{'std::wformat_parse_context' is a}}
+ std::wformat_string; // expected-error {{no member}} expected-note {{'std::wformat_string' is defined in}} expected-note {{'std::wformat_string' is a}}
+ std::wfstream; // expected-error {{no member}} expected-note {{'std::wfstream' is defined in}}
+ std::wfstream; // expected-error {{no member}} expected-note {{'std::wfstream' is defined in}}
+ std::wifstream; // expected-error {{no member}} expected-note {{'std::wifstream' is defined in}}
+ std::wifstream; // expected-error {{no member}} expected-note {{'std::wifstream' is defined in}}
+ std::wios; // expected-error {{no member}} expected-note {{'std::wios' is defined in}}
+ std::wios; // expected-error {{no member}} expected-note {{'std::wios' is defined in}}
+ std::wios; // expected-error {{no member}} expected-note {{'std::wios' is defined in}}
+ std::wiostream; // expected-error {{no member}} expected-note {{'std::wiostream' is defined in}}
+ std::wiostream; // expected-error {{no member}} expected-note {{'std::wiostream' is defined in}}
+ std::wiostream; // expected-error {{no member}} expected-note {{'std::wiostream' is defined in}}
+ std::wispanstream; // expected-error {{no member}} expected-note {{'std::wispanstream' is defined in}} expected-note {{'std::wispanstream' is a}}
+ std::wispanstream; // expected-error {{no member}} expected-note {{'std::wispanstream' is defined in}} expected-note {{'std::wispanstream' is a}}
+ std::wistream; // expected-error {{no member}} expected-note {{'std::wistream' is defined in}}
+ std::wistream; // expected-error {{no member}} expected-note {{'std::wistream' is defined in}}
+ std::wistream; // expected-error {{no member}} expected-note {{'std::wistream' is defined in}}
+ std::wistringstream; // expected-error {{no member}} expected-note {{'std::wistringstream' is defined in}}
+ std::wistringstream; // expected-error {{no member}} expected-note {{'std::wistringstream' is defined in}}
+ std::wmemchr; // expected-error {{no member}} expected-note {{'std::wmemchr' is defined in}}
+ std::wmemcmp; // expected-error {{no member}} expected-note {{'std::wmemcmp' is defined in}}
+ std::wmemcpy; // expected-error {{no member}} expected-note {{'std::wmemcpy' is defined in}}
+ std::wmemmove; // expected-error {{no member}} expected-note {{'std::wmemmove' is defined in}}
+ std::wmemset; // expected-error {{no member}} expected-note {{'std::wmemset' is defined in}}
+ std::wofstream; // expected-error {{no member}} expected-note {{'std::wofstream' is defined in}}
+ std::wofstream; // expected-error {{no member}} expected-note {{'std::wofstream' is defined in}}
+ std::wospanstream; // expected-error {{no member}} expected-note {{'std::wospanstream' is defined in}} expected-note {{'std::wospanstream' is a}}
+ std::wospanstream; // expected-error {{no member}} expected-note {{'std::wospanstream' is defined in}} expected-note {{'std::wospanstream' is a}}
+ std::wostream; // expected-error {{no member}} expected-note {{'std::wostream' is defined in}}
+ std::wostream; // expected-error {{no member}} expected-note {{'std::wostream' is defined in}}
+ std::wostream; // expected-error {{no member}} expected-note {{'std::wostream' is defined in}}
+ std::wostringstream; // expected-error {{no member}} expected-note {{'std::wostringstream' is defined in}}
+ std::wostringstream; // expected-error {{no member}} expected-note {{'std::wostringstream' is defined in}}
+ std::wosyncstream; // expected-error {{no member}} expected-note {{'std::wosyncstream' is defined in}} expected-note {{'std::wosyncstream' is a}}
+ std::wosyncstream; // expected-error {{no member}} expected-note {{'std::wosyncstream' is defined in}} expected-note {{'std::wosyncstream' is a}}
+ std::wprintf; // expected-error {{no member}} expected-note {{'std::wprintf' is defined in}}
+ std::wregex; // expected-error {{no member}} expected-note {{'std::wregex' is defined in}} expected-note {{'std::wregex' is a}}
+ std::ws; // expected-error {{no member}} expected-note {{'std::ws' is defined in}}
+ std::ws; // expected-error {{no member}} expected-note {{'std::ws' is defined in}}
+ std::wscanf; // expected-error {{no member}} expected-note {{'std::wscanf' is defined in}}
+ std::wsmatch; // expected-error {{no member}} expected-note {{'std::wsmatch' is defined in}} expected-note {{'std::wsmatch' is a}}
+ std::wspanbuf; // expected-error {{no member}} expected-note {{'std::wspanbuf' is defined in}} expected-note {{'std::wspanbuf' is a}}
+ std::wspanbuf; // expected-error {{no member}} expected-note {{'std::wspanbuf' is defined in}} expected-note {{'std::wspanbuf' is a}}
+ std::wspanstream; // expected-error {{no member}} expected-note {{'std::wspanstream' is defined in}} expected-note {{'std::wspanstream' is a}}
+ std::wspanstream; // expected-error {{no member}} expected-note {{'std::wspanstream' is defined in}} expected-note {{'std::wspanstream' is a}}
+ std::wsregex_iterator; // expected-error {{no member}} expected-note {{'std::wsregex_iterator' is defined in}} expected-note {{'std::wsregex_iterator' is a}}
+ std::wsregex_token_iterator; // expected-error {{no member}} expected-note {{'std::wsregex_token_iterator' is defined in}} expected-note {{'std::wsregex_token_iterator' is a}}
+ std::wssub_match; // expected-error {{no member}} expected-note {{'std::wssub_match' is defined in}} expected-note {{'std::wssub_match' is a}}
+ std::wstreambuf; // expected-error {{no member}} expected-note {{'std::wstreambuf' is defined in}}
+ std::wstreambuf; // expected-error {{no member}} expected-note {{'std::wstreambuf' is defined in}}
+ std::wstreambuf; // expected-error {{no member}} expected-note {{'std::wstreambuf' is defined in}}
+ std::wstreampos; // expected-error {{no member}} expected-note {{'std::wstreampos' is defined in}}
+ std::wstreampos; // expected-error {{no member}} expected-note {{'std::wstreampos' is defined in}}
+ std::wstring; // expected-error {{no member}} expected-note {{'std::wstring' is defined in}}
+ std::wstring_convert; // expected-error {{no member}} expected-note {{'std::wstring_convert' is defined in}}
+ std::wstring_convert; // expected-error {{no member}} expected-note {{'std::wstring_convert' is defined in}}
+ std::wstring_view; // expected-error {{no member}} expected-note {{'std::wstring_view' is defined in}} expected-note {{'std::wstring_view' is a}}
+ std::wstringbuf; // expected-error {{no member}} expected-note {{'std::wstringbuf' is defined in}}
+ std::wstringbuf; // expected-error {{no member}} expected-note {{'std::wstringbuf' is defined in}}
+ std::wstringstream; // expected-error {{no member}} expected-note {{'std::wstringstream' is defined in}}
+ std::wstringstream; // expected-error {{no member}} expected-note {{'std::wstringstream' is defined in}}
+ std::wsyncbuf; // expected-error {{no member}} expected-note {{'std::wsyncbuf' is defined in}} expected-note {{'std::wsyncbuf' is a}}
+ std::wsyncbuf; // expected-error {{no member}} expected-note {{'std::wsyncbuf' is defined in}} expected-note {{'std::wsyncbuf' is a}}
+ std::yocto; // expected-error {{no member}} expected-note {{'std::yocto' is defined in}} expected-note {{'std::yocto' is a}}
+ std::yotta; // expected-error {{no member}} expected-note {{'std::yotta' is defined in}} expected-note {{'std::yotta' is a}}
+ std::zepto; // expected-error {{no member}} expected-note {{'std::zepto' is defined in}} expected-note {{'std::zepto' is a}}
+ std::zetta; // expected-error {{no member}} expected-note {{'std::zetta' is defined in}} expected-note {{'std::zetta' is a}}
}
diff --git a/clang/test/SemaCXX/no-implicit-builtin-decls.cpp b/clang/test/SemaCXX/no-implicit-builtin-decls.cpp
index 3707799ec4ee0..88e854ac64853 100644
--- a/clang/test/SemaCXX/no-implicit-builtin-decls.cpp
+++ b/clang/test/SemaCXX/no-implicit-builtin-decls.cpp
@@ -1,7 +1,7 @@
// RUN: %clang_cc1 -fsyntax-only -verify %s
void f() {
- void *p = malloc(sizeof(int) * 10); // expected-error{{use of undeclared identifier 'malloc'}} expected-note {{maybe try to include <cstdlib>; 'malloc' is defined in <cstdlib>}}
+ void *p = malloc(sizeof(int) * 10); // expected-error{{use of undeclared identifier 'malloc'}} expected-note {{'malloc' is defined in}}
}
int malloc(double);
More information about the cfe-commits
mailing list