[libc++] [P1032] Finish constexpr-ifying <iterator>, <string_view>, <tuple>, <utility>.

[• Quuxplusone]

Summary

This completes the implementation of P1032's changes to <iterator>,
<string_view>, <tuple>, and <utility> in C++20.
http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p1032r1.html

Drive-by fix a couple of unintended rvalues in "*iterators*/*.fail.cpp".

[ldionne]

Confirmed with Arthur that we're still missing some constexpr-ification in tuple, so we shouldn't mark the paper as implemented here. However, how about we add the missing constexprification in tuple in this patch?

Also, this is missing constexpr tests for all the iterators. We should write a dummy constexpr container to test those.

[• Quuxplusone]

Oops, remove the change to libcxx/docs/Cxx2aStatusPaperStatus.csv — there are still plenty of parts to P1032 besides the iterator parts.

[• Quuxplusone]

Finish implementing P1032 so we can really mark it "complete."
Lacks tests for constexpr pair and tuple.
Lacks tests for constexpr predef.iterators.

[• Quuxplusone]

Oops, update the feature-test macros for the newly added stuff.

Tangentially, @ldionne, I believe that the feature-test macro for
http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p1006r1.pdf (that's your own paper!)
i.e. __cpp_lib_constexpr_memory = 201811 should also be defined at this point. Could you confirm that and either commit it or ask me to commit it? :)

[• Quuxplusone]

New constexpr tests for insert iterators.

[ldionne]

Thanks for the heads up about __cpp_lib_constexpr_memory, fixed in 5d0d465ad4d25398519b85879d61fc126abd641c.

This is great, it's only missing some more tests. I don't foresee any additional issues given the appropriate tests.

libcxx/include/chrono

2311 ↗

(On Diff #322846)

Those changes are orthogonal to the patch, could you please remove them (and commit them separately without review if you want, I don't mind).

[• Quuxplusone]

Split out and merge the <chrono> cleanup. Rebase on main. void __swallow can't be constexpr before C++14.

[ldionne]

I think this is great, but it needs to pass tests on GCC. It also probably needs rebasing onto main now. And all the things we're making constexpr should have their tests moved to check constexpr-friendliness too.

Requesting changes so it shows up right in the queue.

[• Quuxplusone]

Rebased on main. (Looks like it rebased cleanly.) I don't remember why buildkite was unhappy before; let's see if it's happy this week.

[• Quuxplusone]

Unsupport the failing string_view test on GCC (ostensibly until they get __builtin_strlen working, or until libc++ chooses to stop using it in char_traits).

libcxx/test/std/strings/string.view/string.view.ops/copy.pass.cpp

90

I've figured out that line 85 fails on GCC because libc++'s char_traits<char>::length calls __builtin_strlen, which is not a constant expression on GCC yet. See https://gcc.gnu.org/bugzilla/show_bug.cgi?id=70816

GNU libstdc++ works around this GCC bug by saying "okay, past C++17 we won't use __builtin_strlen anymore." See
https://github.com/gcc-mirror/gcc/blob/master/libstdc%2B%2B-v3/include/bits/char_traits.h#L364-L372

Should libc++ copy their cop-out (conditional on !defined(__clang__))? Or should I just mark this test as UNSUPPORTED: gcc-10 and move on? For now I'll upload a diff marked UNSUPPORTED just to prove that that'll make buildkite happy enough to land this if that's the route we want to take.

[zoecarver]

A few small comments now. More later (probably).

libcxx/test/std/strings/string.view/string.view.ops/copy.pass.cpp

59

Too bad we can't test this in a constexpr context 😔

83

Nit: might make sense to either name these a, g, and b or all abcde, ghijk, bcdjk.

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.assign/copy.pass.cpp

99

Mind adding a comment "Cannot be constexpr because of std::string" or something like that?

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.assign/move.pass.cpp

129

Why not put this all in test?

129

Actually, it looks like CountAssign cant' be constexpr because of its global static vars.

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.creation/make_tuple.pass.cpp

44

We're losing test coverage of constexpr between 11 and 20.

[• Quuxplusone]

Address @zoecarver's initial review feedback.

[ldionne]

This looks pretty good, but it seems that you included some changes that were not strictly added in P1032 in this patch too (eg some tests for tuple being constexpr). I'm fine with that, but I'd like to confirm that this was intentional.

libcxx/include/version

340

Why is this changing?

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.creation/make_tuple.pass.cpp

14

Isn't that constexpr since C++14?

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.creation/tie.pass.cpp

16

Same, this is constexpr since C++14?

[• Quuxplusone]

libcxx/include/version

340

Fallout from D97904. I'll re-upload.

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.creation/make_tuple.pass.cpp

14

make_tuple is; but the test case I'm modifying here also uses std::ref, which is constexpr in C++20 only.

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.creation/tie.pass.cpp

16

Yes, but res = std::make_tuple(101, nullptr, -1.0); on line 38 is constexpr only in C++20 because operator=.

[• Quuxplusone]

Re-upload with new and excitingly different spurious diffs in the autogenerated tests. 😛

[• Quuxplusone]

libcxx/test/std/strings/string.view/string.view.ops/copy.pass.cpp

9–11

@ldionne, any thoughts on this bit?

[ldionne]

libcxx/test/std/strings/string.view/string.view.ops/copy.pass.cpp

9–11

I think this is reasonable. I think I'd rather wait for GCC to make their __builtin_strlen constexpr than add a GCC specific workaround for that in the library.

We could make it XFAIL so we're notified (by an XPASS) once GCC makes it constexpr.

[ldionne]

LGTM with UNSUPPORTED => XFAIL for the gcc test.

[uabelho]

Hi,

I noticed that the following test failed with this patch:

Failed Tests (1):
  libc++ :: std/utilities/tuple/tuple.tuple/tuple.assign/convert_copy.pass.cpp

It hits an assertion:

clang-13: /repo/uabelho/master-github/clang/lib/AST/ExprConstant.cpp:5947: bool HandleUnionActiveMemberChange((anonymous namespace)::EvalInfo &, const clang::Expr *, const (anonymous namespace)::LValue &): Assertion `declaresSameEntity(Elt->getType()->getAsCXXRecordDecl(), LHS.Designator.Entries[PathLength] .getAsBaseOrMember().getPointer())' failed.
PLEASE submit a bug report to https://bugs.llvm.org/ and include the crash backtrace, preprocessed source, and associated run script.
Stack dump:
0.	Program arguments: /repo/uabelho/master-github/llvm/build-all-builtins/bin/clang-13 -cc1 -triple x86_64-unknown-linux-gnu -emit-obj -mrelax-all --mrelax-relocations -disable-free -main-file-name convert_copy.pass.cpp -mrelocation-model static -mframe-pointer=all -fmath-errno -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -v -fcoverage-compilation-dir=/repo/uabelho/master-github/llvm/build-all-builtins/runtimes/runtimes-x86_64-unknown-linux-gnu-bins/libcxx/test/std/utilities/tuple/tuple.tuple/tuple.assign -nostdinc++ -resource-dir /repo/uabelho/master-github/llvm/build-all-builtins/lib/clang/13.0.0 -include /repo/uabelho/master-github/llvm/build-all-builtins/runtimes/runtimes-x86_64-unknown-linux-gnu-bins/libcxx/__config_site -include /repo/uabelho/master-github/libcxx/test/support/nasty_macros.h -I /repo/uabelho/master-github/libcxx/include -I /repo/uabelho/master-github/llvm/build-all-builtins/runtimes/runtimes-x86_64-unknown-linux-gnu-bins/libcxx/include/c++build -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -D __STDC_CONSTANT_MACROS -I /repo/uabelho/master-github/libcxx/test/support -D _LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER -D _LIBCPP_DISABLE_AVAILABILITY -D _LIBCPP_HAS_THREAD_API_PTHREAD -D _LIBCPP_ABI_VERSION=1 -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-redhat-linux/4.8.5/../../../../x86_64-redhat-linux/include -internal-isystem /repo/uabelho/master-github/llvm/build-all-builtins/lib/clang/13.0.0/include -internal-externc-isystem /include -internal-externc-isystem /usr/include -Werror -Wall -Wextra -Wshadow -Wno-unused-command-line-argument -Wno-attributes -Wno-pessimizing-move -Wno-c++11-extensions -Wno-user-defined-literals -Wno-noexcept-type -Wno-atomic-alignment -Wsign-compare -Wunused-variable -Wunused-parameter -Wunreachable-code -Wno-unused-local-typedef -Werror=thread-safety -Wuser-defined-warnings -Wno-macro-redefined -Wno-macro-redefined -std=c++2b -fdeprecated-macro -fdebug-compilation-dir=/repo/uabelho/master-github/llvm/build-all-builtins/runtimes/runtimes-x86_64-unknown-linux-gnu-bins/libcxx/test/std/utilities/tuple/tuple.tuple/tuple.assign -ferror-limit 19 -fcoroutines-ts -fgnuc-version=4.2.1 -fcxx-exceptions -fexceptions -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/convert_copy-5d8b65.o -x c++ /repo/uabelho/master-github/libcxx/test/std/utilities/tuple/tuple.tuple/tuple.assign/convert_copy.pass.cpp
1.	/repo/uabelho/master-github/libcxx/test/std/utilities/tuple/tuple.tuple/tuple.assign/convert_copy.pass.cpp:111:5: current parser token '{'
2.	/repo/uabelho/master-github/libcxx/test/std/utilities/tuple/tuple.tuple/tuple.assign/convert_copy.pass.cpp:105:1: parsing function body 'main'
3.	/repo/uabelho/master-github/libcxx/test/std/utilities/tuple/tuple.tuple/tuple.assign/convert_copy.pass.cpp:105:1: in compound statement ('{}')
 #0 0x0000000002ada0f3 llvm::sys::PrintStackTrace(llvm::raw_ostream&, int) (/repo/uabelho/master-github/llvm/build-all-builtins/bin/clang-13+0x2ada0f3)
 #1 0x0000000002ad7dae llvm::sys::RunSignalHandlers() (/repo/uabelho/master-github/llvm/build-all-builtins/bin/clang-13+0x2ad7dae)
 #2 0x0000000002ada5b6 SignalHandler(int) Signals.cpp:0:0
 #3 0x00007f8fa58f7630 __restore_rt sigaction.c:0:0
 #4 0x00007f8fa302a387 raise (/lib64/libc.so.6+0x36387)
 #5 0x00007f8fa302ba78 abort (/lib64/libc.so.6+0x37a78)
 #6 0x00007f8fa30231a6 __assert_fail_base (/lib64/libc.so.6+0x2f1a6)
 #7 0x00007f8fa3023252 (/lib64/libc.so.6+0x2f252)
 #8 0x000000000509b722 HandleUnionActiveMemberChange((anonymous namespace)::EvalInfo&, clang::Expr const*, (anonymous namespace)::LValue const&) ExprConstant.cpp:0:0
 #9 0x0000000005092a9e HandleFunctionCall(clang::SourceLocation, clang::FunctionDecl const*, (anonymous namespace)::LValue const*, llvm::ArrayRef<clang::Expr const*>, (anonymous namespace)::CallRef, clang::Stmt const*, (anonymous namespace)::EvalInfo&, clang::APValue&, (anonymous namespace)::LValue const*) ExprConstant.cpp:0:0
#10 0x0000000005099c04 (anonymous namespace)::ExprEvaluatorBase<(anonymous namespace)::LValueExprEvaluator>::VisitCallExpr(clang::CallExpr const*) ExprConstant.cpp:0:0
#11 0x000000000508b200 EvaluateLValue(clang::Expr const*, (anonymous namespace)::LValue&, (anonymous namespace)::EvalInfo&, bool) ExprConstant.cpp:0:0
#12 0x0000000005090aca Evaluate(clang::APValue&, (anonymous namespace)::EvalInfo&, clang::Expr const*) ExprConstant.cpp:0:0
#13 0x0000000005117d34 (anonymous namespace)::ExprEvaluatorBase<(anonymous namespace)::VoidExprEvaluator>::VisitBinaryOperator(clang::BinaryOperator const*) ExprConstant.cpp:0:0
#14 0x00000000050918b3 Evaluate(clang::APValue&, (anonymous namespace)::EvalInfo&, clang::Expr const*) ExprConstant.cpp:0:0
#15 0x0000000005095631 clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::LValueExprEvaluator, bool>::Visit(clang::Stmt const*) ExprConstant.cpp:0:0
#16 0x000000000508b200 EvaluateLValue(clang::Expr const*, (anonymous namespace)::LValue&, (anonymous namespace)::EvalInfo&, bool) ExprConstant.cpp:0:0
#17 0x0000000005090aca Evaluate(clang::APValue&, (anonymous namespace)::EvalInfo&, clang::Expr const*) ExprConstant.cpp:0:0
#18 0x000000000508c907 EvaluateInPlace(clang::APValue&, (anonymous namespace)::EvalInfo&, (anonymous namespace)::LValue const&, clang::Expr const*, bool) ExprConstant.cpp:0:0
#19 0x000000000509081e EvaluateCallArg(clang::ParmVarDecl const*, clang::Expr const*, (anonymous namespace)::CallRef, (anonymous namespace)::EvalInfo&, bool) ExprConstant.cpp:0:0
#20 0x00000000050afe7f EvaluateArgs(llvm::ArrayRef<clang::Expr const*>, (anonymous namespace)::CallRef, (anonymous namespace)::EvalInfo&, clang::FunctionDecl const*, bool) ExprConstant.cpp:0:0
#21 0x0000000005118ca5 (anonymous namespace)::ExprEvaluatorBase<(anonymous namespace)::VoidExprEvaluator>::handleCallExpr(clang::CallExpr const*, clang::APValue&, (anonymous namespace)::LValue const*) ExprConstant.cpp:0:0
#22 0x0000000005115769 clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::VoidExprEvaluator, bool>::Visit(clang::Stmt const*) ExprConstant.cpp:0:0
#23 0x000000000511619b clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::VoidExprEvaluator, bool>::Visit(clang::Stmt const*) ExprConstant.cpp:0:0
#24 0x00000000050918b3 Evaluate(clang::APValue&, (anonymous namespace)::EvalInfo&, clang::Expr const*) ExprConstant.cpp:0:0
#25 0x00000000050b4fd7 EvaluateStmt((anonymous namespace)::StmtResult&, (anonymous namespace)::EvalInfo&, clang::Stmt const*, clang::SwitchCase const*) ExprConstant.cpp:0:0
#26 0x00000000050b550a EvaluateStmt((anonymous namespace)::StmtResult&, (anonymous namespace)::EvalInfo&, clang::Stmt const*, clang::SwitchCase const*) ExprConstant.cpp:0:0
#27 0x000000000509289e HandleFunctionCall(clang::SourceLocation, clang::FunctionDecl const*, (anonymous namespace)::LValue const*, llvm::ArrayRef<clang::Expr const*>, (anonymous namespace)::CallRef, clang::Stmt const*, (anonymous namespace)::EvalInfo&, clang::APValue&, (anonymous namespace)::LValue const*) ExprConstant.cpp:0:0
#28 0x00000000051192d7 (anonymous namespace)::ExprEvaluatorBase<(anonymous namespace)::VoidExprEvaluator>::handleCallExpr(clang::CallExpr const*, clang::APValue&, (anonymous namespace)::LValue const*) ExprConstant.cpp:0:0
#29 0x0000000005115769 clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::VoidExprEvaluator, bool>::Visit(clang::Stmt const*) ExprConstant.cpp:0:0
#30 0x00000000050918b3 Evaluate(clang::APValue&, (anonymous namespace)::EvalInfo&, clang::Expr const*) ExprConstant.cpp:0:0
#31 0x00000000050b4fd7 EvaluateStmt((anonymous namespace)::StmtResult&, (anonymous namespace)::EvalInfo&, clang::Stmt const*, clang::SwitchCase const*) ExprConstant.cpp:0:0
#32 0x00000000050b550a EvaluateStmt((anonymous namespace)::StmtResult&, (anonymous namespace)::EvalInfo&, clang::Stmt const*, clang::SwitchCase const*) ExprConstant.cpp:0:0
#33 0x000000000509289e HandleFunctionCall(clang::SourceLocation, clang::FunctionDecl const*, (anonymous namespace)::LValue const*, llvm::ArrayRef<clang::Expr const*>, (anonymous namespace)::CallRef, clang::Stmt const*, (anonymous namespace)::EvalInfo&, clang::APValue&, (anonymous namespace)::LValue const*) ExprConstant.cpp:0:0
#34 0x0000000005099c04 (anonymous namespace)::ExprEvaluatorBase<(anonymous namespace)::LValueExprEvaluator>::VisitCallExpr(clang::CallExpr const*) ExprConstant.cpp:0:0
#35 0x000000000508b200 EvaluateLValue(clang::Expr const*, (anonymous namespace)::LValue&, (anonymous namespace)::EvalInfo&, bool) ExprConstant.cpp:0:0
#36 0x0000000005090aca Evaluate(clang::APValue&, (anonymous namespace)::EvalInfo&, clang::Expr const*) ExprConstant.cpp:0:0
#37 0x00000000050b4fd7 EvaluateStmt((anonymous namespace)::StmtResult&, (anonymous namespace)::EvalInfo&, clang::Stmt const*, clang::SwitchCase const*) ExprConstant.cpp:0:0
#38 0x00000000050b550a EvaluateStmt((anonymous namespace)::StmtResult&, (anonymous namespace)::EvalInfo&, clang::Stmt const*, clang::SwitchCase const*) ExprConstant.cpp:0:0
#39 0x00000000050b550a EvaluateStmt((anonymous namespace)::StmtResult&, (anonymous namespace)::EvalInfo&, clang::Stmt const*, clang::SwitchCase const*) ExprConstant.cpp:0:0
#40 0x000000000509289e HandleFunctionCall(clang::SourceLocation, clang::FunctionDecl const*, (anonymous namespace)::LValue const*, llvm::ArrayRef<clang::Expr const*>, (anonymous namespace)::CallRef, clang::Stmt const*, (anonymous namespace)::EvalInfo&, clang::APValue&, (anonymous namespace)::LValue const*) ExprConstant.cpp:0:0
#41 0x00000000050eb527 (anonymous namespace)::ExprEvaluatorBase<(anonymous namespace)::IntExprEvaluator>::handleCallExpr(clang::CallExpr const*, clang::APValue&, (anonymous namespace)::LValue const*) ExprConstant.cpp:0:0
#42 0x00000000050c38b8 clang::StmtVisitorBase<llvm::make_const_ptr, (anonymous namespace)::IntExprEvaluator, bool>::Visit(clang::Stmt const*) ExprConstant.cpp:0:0
#43 0x0000000005090ca8 Evaluate(clang::APValue&, (anonymous namespace)::EvalInfo&, clang::Expr const*) ExprConstant.cpp:0:0
#44 0x000000000508e130 EvaluateAsRValue((anonymous namespace)::EvalInfo&, clang::Expr const*, clang::APValue&) ExprConstant.cpp:0:0
#45 0x000000000508a2ce clang::Expr::EvaluateAsRValue(clang::Expr::EvalResult&, clang::ASTContext const&, bool) const (/repo/uabelho/master-github/llvm/build-all-builtins/bin/clang-13+0x508a2ce)
#46 0x00000000047ebcb2 clang::Sema::VerifyIntegerConstantExpression(clang::Expr*, llvm::APSInt*, clang::Sema::VerifyICEDiagnoser&, clang::Sema::AllowFoldKind) (/repo/uabelho/master-github/llvm/build-all-builtins/bin/clang-13+0x47ebcb2)
#47 0x00000000047e9675 clang::Sema::VerifyIntegerConstantExpression(clang::Expr*, llvm::APSInt*, unsigned int, clang::Sema::AllowFoldKind) (/repo/uabelho/master-github/llvm/build-all-builtins/bin/clang-13+0x47e9675)
#48 0x00000000047361a9 clang::Sema::BuildStaticAssertDeclaration(clang::SourceLocation, clang::Expr*, clang::StringLiteral*, clang::SourceLocation, bool) (/repo/uabelho/master-github/llvm/build-all-builtins/bin/clang-13+0x47361a9)
#49 0x0000000004475bf8 clang::Parser::ParseStaticAssertDeclaration(clang::SourceLocation&) (/repo/uabelho/master-github/llvm/build-all-builtins/bin/clang-13+0x4475bf8)
#50 0x0000000004453815 clang::Parser::ParseDeclaration(clang::DeclaratorContext, clang::SourceLocation&, clang::Parser::ParsedAttributesWithRange&, clang::SourceLocation*) (/repo/uabelho/master-github/llvm/build-all-builtins/bin/clang-13+0x4453815)
#51 0x00000000044f4fbd clang::Parser::ParseStatementOrDeclarationAfterAttributes(llvm::SmallVector<clang::Stmt*, 32u>&, clang::Parser::ParsedStmtContext, clang::SourceLocation*, clang::Parser::ParsedAttributesWithRange&) (/repo/uabelho/master-github/llvm/build-all-builtins/bin/clang-13+0x44f4fbd)
#52 0x00000000044f3f41 clang::Parser::ParseStatementOrDeclaration(llvm::SmallVector<clang::Stmt*, 32u>&, clang::Parser::ParsedStmtContext, clang::SourceLocation*) (/repo/uabelho/master-github/llvm/build-all-builtins/bin/clang-13+0x44f3f41)
#53 0x00000000044fde01 clang::Parser::ParseCompoundStatementBody(bool) (/repo/uabelho/master-github/llvm/build-all-builtins/bin/clang-13+0x44fde01)
#54 0x00000000044ff055 clang::Parser::ParseFunctionStatementBody(clang::Decl*, clang::Parser::ParseScope&) (/repo/uabelho/master-github/llvm/build-all-builtins/bin/clang-13+0x44ff055)
#55 0x0000000004439efd clang::Parser::ParseFunctionDefinition(clang::ParsingDeclarator&, clang::Parser::ParsedTemplateInfo const&, clang::Parser::LateParsedAttrList*) (/repo/uabelho/master-github/llvm/build-all-builtins/bin/clang-13+0x4439efd)
#56 0x000000000445a096 clang::Parser::ParseDeclGroup(clang::ParsingDeclSpec&, clang::DeclaratorContext, clang::SourceLocation*, clang::Parser::ForRangeInit*) (/repo/uabelho/master-github/llvm/build-all-builtins/bin/clang-13+0x445a096)
#57 0x0000000004439095 clang::Parser::ParseDeclOrFunctionDefInternal(clang::Parser::ParsedAttributesWithRange&, clang::ParsingDeclSpec&, clang::AccessSpecifier) (/repo/uabelho/master-github/llvm/build-all-builtins/bin/clang-13+0x4439095)
#58 0x0000000004438af5 clang::Parser::ParseDeclarationOrFunctionDefinition(clang::Parser::ParsedAttributesWithRange&, clang::ParsingDeclSpec*, clang::AccessSpecifier) (/repo/uabelho/master-github/llvm/build-all-builtins/bin/clang-13+0x4438af5)
#59 0x00000000044379d6 clang::Parser::ParseExternalDeclaration(clang::Parser::ParsedAttributesWithRange&, clang::ParsingDeclSpec*) (/repo/uabelho/master-github/llvm/build-all-builtins/bin/clang-13+0x44379d6)
#60 0x000000000443578d clang::Parser::ParseTopLevelDecl(clang::OpaquePtr<clang::DeclGroupRef>&, bool) (/repo/uabelho/master-github/llvm/build-all-builtins/bin/clang-13+0x443578d)
#61 0x000000000442fd48 clang::ParseAST(clang::Sema&, bool, bool) (/repo/uabelho/master-github/llvm/build-all-builtins/bin/clang-13+0x442fd48)
#62 0x00000000033796f3 clang::FrontendAction::Execute() (/repo/uabelho/master-github/llvm/build-all-builtins/bin/clang-13+0x33796f3)
#63 0x00000000032f0474 clang::CompilerInstance::ExecuteAction(clang::FrontendAction&) (/repo/uabelho/master-github/llvm/build-all-builtins/bin/clang-13+0x32f0474)
#64 0x000000000342aad1 clang::ExecuteCompilerInvocation(clang::CompilerInstance*) (/repo/uabelho/master-github/llvm/build-all-builtins/bin/clang-13+0x342aad1)
#65 0x00000000009de555 cc1_main(llvm::ArrayRef<char const*>, char const*, void*) (/repo/uabelho/master-github/llvm/build-all-builtins/bin/clang-13+0x9de555)
#66 0x00000000009dc991 ExecuteCC1Tool(llvm::SmallVectorImpl<char const*>&) driver.cpp:0:0
#67 0x00000000009dc44c main (/repo/uabelho/master-github/llvm/build-all-builtins/bin/clang-13+0x9dc44c)
#68 0x00007f8fa3016555 __libc_start_main (/lib64/libc.so.6+0x22555)
#69 0x00000000009d93bd _start (/repo/uabelho/master-github/llvm/build-all-builtins/bin/clang-13+0x9d93bd)
clang-13: error: unable to execute command: Aborted
clang-13: error: clang frontend command failed due to signal (use -v to see invocation)
clang version 13.0.0
Target: x86_64-unknown-linux-gnu
Thread model: posix

[• Quuxplusone]

In D96385#2652515, @uabelho wrote:

Hi,

I noticed that the following test failed with this patch:

Failed Tests (1):
  libc++ :: std/utilities/tuple/tuple.tuple/tuple.assign/convert_copy.pass.cpp

It hits an assertion:

clang-13: /repo/uabelho/master-github/clang/lib/AST/ExprConstant.cpp:5947: bool HandleUnionActiveMemberChange((anonymous namespace)::EvalInfo &, const clang::Expr *, const (anonymous namespace)::LValue &): Assertion `declaresSameEntity(Elt->getType()->getAsCXXRecordDecl(), LHS.Designator.Entries[PathLength] .getAsBaseOrMember().getPointer())' failed.
PLEASE submit a bug report to https://bugs.llvm.org/ and include the crash backtrace, preprocessed source, and associated run script.

Hi @uabelho, could you file a bug report against Clang on https://bugs.llvm.org/ ? If you have the ability to reduce the test case using creduce, that would be awesome.
https://bugs.llvm.org/show_bug.cgi?id=45879 seems related but not identical (because the assertion that fails in that case is different).

[vvereschaka]

Hi @Quuxplusone,

the same assert happens on the ARM cross toolchain builders:

• aarch64 https://lab.llvm.org/buildbot/#/builders/119/builds/2911/steps/14/logs/FAIL__libc____convert_copy_pass_cpp
• armv7 https://lab.llvm.org/buildbot/#/builders/60/builds/2497/steps/14/logs/FAIL__libc____convert_copy_pass_cpp

FAIL: libc++::convert_copy.pass.cpp

Assertion failed: declaresSameEntity(Elt->getType()->getAsCXXRecordDecl(), LHS.Designator.Entries[PathLength] .getAsBaseOrMember().getPointer()), file C:\buildbot\as-builder-1\x-armv7l\llvm-project\clang\lib\AST\ExprConstant.cpp, line 5947
PLEASE submit a bug report to https://bugs.llvm.org/ and include the crash backtrace, preprocessed source, and associated run script.
Stack dump:
0.	Program arguments: C:\\buildbot\\as-builder-1\\x-armv7l\\build\\bin\\clang++.exe -cc1 -triple armv7-unknown-linux-gnueabihf -emit-obj -mrelax-all --mrelax-relocations -disable-free -main-file-name convert_copy.pass.cpp -mrelocation-model static -mframe-pointer=all -fmath-errno -fno-rounding-math -mconstructor-aliases -target-cpu generic -target-abi aapcs-linux -mfloat-abi hard -fallow-half-arguments-and-returns -debugger-tuning=gdb -v -fcoverage-compilation-dir=C:\\buildbot\\as-builder-1\\x-armv7l\\build\\runtimes\\runtimes-bins\\libcxx\\test\\std\\utilities\\tuple\\tuple.tuple\\tuple.assign -nostdinc++ -resource-dir C:\\buildbot\\as-builder-1\\x-armv7l\\build\\lib\\clang\\13.0.0 -include C:/buildbot/as-builder-1/x-armv7l/build/runtimes/runtimes-bins/libcxx\\__config_site -include C:/buildbot/as-builder-1/x-armv7l/llvm-project/libcxx\\test\\support\\nasty_macros.h -I C:/buildbot/as-builder-1/x-armv7l/llvm-project/libcxx\\include -I C:/buildbot/as-builder-1/x-armv7l/build/runtimes/runtimes-bins/libcxx\\include\\c++build -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -D __STDC_CONSTANT_MACROS -I C:/buildbot/as-builder-1/x-armv7l/llvm-project/libcxx\\test/support -D _LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER -D _LIBCPP_DISABLE_AVAILABILITY -D _LIBCPP_HAS_THREAD_API_PTHREAD -D _LIBCPP_ABI_VERSION=1 -isysroot C:/buildbot/.arm-ubuntu -internal-isystem C:/buildbot/.arm-ubuntu/usr/local/include -internal-isystem C:/buildbot/.arm-ubuntu/usr/lib/gcc/arm-linux-gnueabihf/5.4.0/../../../../arm-linux-gnueabihf/include -internal-isystem C:\\buildbot\\as-builder-1\\x-armv7l\\build\\lib\\clang\\13.0.0\\include -internal-externc-isystem C:/buildbot/.arm-ubuntu/usr/include/arm-linux-gnueabihf -internal-externc-isystem C:/buildbot/.arm-ubuntu/include -internal-externc-isystem C:/buildbot/.arm-ubuntu/usr/include -Werror -Wall -Wextra -Wshadow -Wno-unused-command-line-argument -Wno-attributes -Wno-pessimizing-move -Wno-c++11-extensions -Wno-user-defined-literals -Wno-noexcept-type -Wno-atomic-alignment -Wsign-compare -Wunused-variable -Wunused-parameter -Wunreachable-code -Wno-unused-local-typedef -Werror=thread-safety -Wuser-defined-warnings -Wno-macro-redefined -Wno-macro-redefined -std=c++2b -fdeprecated-macro -fdebug-compilation-dir=C:\\buildbot\\as-builder-1\\x-armv7l\\build\\runtimes\\runtimes-bins\\libcxx\\test\\std\\utilities\\tuple\\tuple.tuple\\tuple.assign -ferror-limit 19 -fcoroutines-ts -fno-signed-char -fgnuc-version=4.2.1 -fcxx-exceptions -fexceptions -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o C:\\Users\\buildbot\\AppData\\Local\\Temp\\convert_copy-f069d8.o -x c++ C:/buildbot/as-builder-1/x-armv7l/llvm-project/libcxx/test/std/utilities/tuple/tuple.tuple/tuple.assign/convert_copy.pass.cpp
1.	C:/buildbot/as-builder-1/x-armv7l/llvm-project/libcxx/test/std/utilities/tuple/tuple.tuple/tuple.assign/convert_copy.pass.cpp:111:5: current parser token '{'
2.	C:/buildbot/as-builder-1/x-armv7l/llvm-project/libcxx/test/std/utilities/tuple/tuple.tuple/tuple.assign/convert_copy.pass.cpp:105:1: parsing function body 'main'
3.	C:/buildbot/as-builder-1/x-armv7l/llvm-project/libcxx/test/std/utilities/tuple/tuple.tuple/tuple.assign/convert_copy.pass.cpp:105:1: in compound statement ('{}')
...
...

[• Quuxplusone]

Hi @vvereschaka, I've been working on reducing the Clang bug using creduce, but I made the mistake of not checking the exact assertion message in the interestingness check, and apparently assertion failures in debug mode are a dime a dozen. :) I've filed https://bugs.llvm.org/show_bug.cgi?id=49734 so far, and may file more if I can convince creduce to show me where they are.

The specific bug being triggered here is definitely https://bugs.llvm.org/show_bug.cgi?id=45879 , and I have just added a comment over there. Unfortunately it seems to have existed since May of last year, so a "quick fix" might not be likely. This seems like a no-win situation:

• libc++ is supposed to work on Clang version X.Y
• libc++ is also supposed to support C++20 constexpr tuple
• constexpr tuple crashes Clang version X.Y (for now)
• I don't think we're able to completely change how we implement tuple in order to work around the bug

@ldionne, what do you think? I'm thinking either "revert until we have a fix" — but that could be forever, there doesn't seem like any good option here — or "just UNSUPPORTED: this one test."
Is there an annotation like "UNSUPPORTED: clang-trunk"? 😛 Or if there's a way for #ifdef to tell that the compiler is Clang compiled in debug mode, that would be even cooler; we could skip just the failing part of the test, just in debug mode.

[vvereschaka]

Hi @Quuxplusone, understood, thank you! I agree with you that temporary disabling of the test for some configurations would be optimal for now.

There is no clang-trunk LIT feature currently, but probably UNSUPPORTED: clang-13 will help.

Or if there's a way for #ifdef to tell that the compiler is Clang compiled in debug mode,

There is nothing like that as far as I know.

[uabelho]

What do you think about doing something about the failing test?

If you think this patch makes the testcase just trigger already existing bugs then disable the testcase so the bot goes back to green?

[• Quuxplusone]

Okay @ldionne @uabelho @vvereschaka, I've pushed 3bdd674fbf767d719dc67e10bc079cb183dd3a3f to hopefully green the buildbots again.

For the record, the specific culprit here is
https://bugs.llvm.org/show_bug.cgi?id=45879

But running creduce on the failing test, with different random seeds, also produced instances of
https://bugs.llvm.org/show_bug.cgi?id=21826
https://bugs.llvm.org/show_bug.cgi?id=49734
https://bugs.llvm.org/show_bug.cgi?id=49735
https://bugs.llvm.org/show_bug.cgi?id=49749
https://bugs.llvm.org/show_bug.cgi?id=49759

[ldionne]

In D96385#2661434, @Quuxplusone wrote:

Okay @ldionne @uabelho @vvereschaka, I've pushed 3bdd674fbf767d719dc67e10bc079cb183dd3a3f to hopefully green the buildbots again.

For the record, the specific culprit here is
https://bugs.llvm.org/show_bug.cgi?id=45879

But running creduce on the failing test, with different random seeds, also produced instances of
https://bugs.llvm.org/show_bug.cgi?id=21826
https://bugs.llvm.org/show_bug.cgi?id=49734
https://bugs.llvm.org/show_bug.cgi?id=49735
https://bugs.llvm.org/show_bug.cgi?id=49749
https://bugs.llvm.org/show_bug.cgi?id=49759

Thanks for your investigations Arthur, and sorry for missing your previous @ on March 26th.

I think marking the test as unsupported is fine as a temporary solution to keep the bots green, which is the #1 priority.

However, this is going to start failing again next release, and so on, until we fix the underlying bug, so I think we should either work on a libc++ workaround to stop triggering the bug, or on fixing the actual Clang issue.

[ldionne]

libcxx/test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.insert.iter.cons/container.pass.cpp

1

@Quuxplusone You didn't constexpr-ify this test (the default constructor one) for back_insert_iterator. Can you please go back and make sure you didn't forget others?

[ldionne]

libcxx/test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.insert.iter.cons/container.pass.cpp

1

Ugh, I mean the constexpr explicit back_insert_iterator(Container&) constructor, not the default constructor.

Also, it would be great to tidy this up at the top of the test files:

// explicit front_insert_iterator(Cont& x);

should become

// explicit front_insert_iterator(Cont& x); // constexpr in C++20

libcxx/docs/Cxx2aStatusPaperStatus.csv

 "`P0771R1 <https://wg21.link/P0771R1>`__","LWG","std::function move constructor should be noexcept","San Diego","|Complete|","6.0"
 "`P0896R4 <https://wg21.link/P0896R4>`__","LWG","The One Ranges Proposal","San Diego","* *",""
 "`P0899R1 <https://wg21.link/P0899R1>`__","LWG","P0899R1 - LWG 3016 is not a defect","San Diego","|Nothing To Do|",""
 "`P0919R3 <https://wg21.link/P0919R3>`__","LWG","Heterogeneous lookup for unordered containers","San Diego","|Complete|","12.0"
 "`P0972R0 <https://wg21.link/P0972R0>`__","LWG","<chrono> ``zero()``\ , ``min()``\ , and ``max()``\  should be noexcept","San Diego","|Complete|","8.0"
 "`P1006R1 <https://wg21.link/P1006R1>`__","LWG","Constexpr in std::pointer_traits","San Diego","|Complete|","8.0"
 "`P1007R3 <https://wg21.link/P1007R3>`__","LWG","``std::assume_aligned``\ ","San Diego","* *",""
 "`P1020R1 <https://wg21.link/P1020R1>`__","LWG","Smart pointer creation with default initialization","San Diego","* *",""
-"`P1032R1 <https://wg21.link/P1032R1>`__","LWG","Misc constexpr bits","San Diego","* *",""
+"`P1032R1 <https://wg21.link/P1032R1>`__","LWG","Misc constexpr bits","San Diego","|Complete|","13.0"
 "`P1085R2 <https://wg21.link/P1085R2>`__","LWG","Should Span be Regular?","San Diego","|Complete|","8.0"
 "`P1123R0 <https://wg21.link/P1123R0>`__","LWG","Editorial Guidance for merging P0019r8 and P0528r3","San Diego","* *",""
 "`P1148R0 <https://wg21.link/P1148R0>`__","LWG","Cleaning up Clause 20","San Diego","* *",""
 "`P1165R1 <https://wg21.link/P1165R1>`__","LWG","Make stateful allocator propagation more consistent for ``operator+(basic_string)``\ ","San Diego","* *",""
 "`P1209R0 <https://wg21.link/P1209R0>`__","LWG","Adopt Consistent Container Erasure from Library Fundamentals 2 for C++20","San Diego","|Complete|","8.0"
 "`P1210R0 <https://wg21.link/P1210R0>`__","LWG","Completing the Rebase of Library Fundamentals, Version 3, Working Draft","San Diego","* *",""
 "`P1236R1 <https://wg21.link/P1236R1>`__","CWG","Alternative Wording for P0907R4 Signed Integers are Two's Complement","San Diego","* *",""
 "`P1248R1 <https://wg21.link/P1248R1>`__","LWG","Remove CommonReference requirement from StrictWeakOrdering (a.k.a Fixing Relations)","San Diego","* *",""

libcxx/docs/FeatureTestMacroTable.rst

.. table:: Current Status
     ``__cpp_lib_constexpr_algorithms``                ``201806L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_constexpr_complex``                   *unimplemented*
     ------------------------------------------------- -----------------
     ``__cpp_lib_constexpr_dynamic_alloc``             ``201907L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_constexpr_functional``                ``201907L``
     ------------------------------------------------- -----------------
-    ``__cpp_lib_constexpr_iterator``                  *unimplemented*
+    ``__cpp_lib_constexpr_iterator``                  ``201811L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_constexpr_memory``                    ``201811L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_constexpr_numeric``                   ``201911L``
     ------------------------------------------------- -----------------
-    ``__cpp_lib_constexpr_string``                    *unimplemented*
+    ``__cpp_lib_constexpr_string``                    ``201811L``
     ------------------------------------------------- -----------------
-    ``__cpp_lib_constexpr_string_view``               *unimplemented*
+    ``__cpp_lib_constexpr_string_view``               ``201811L``
     ------------------------------------------------- -----------------
-    ``__cpp_lib_constexpr_tuple``                     *unimplemented*
+    ``__cpp_lib_constexpr_tuple``                     ``201811L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_constexpr_utility``                   ``201811L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_constexpr_vector``                    *unimplemented*
     ------------------------------------------------- -----------------
     ``__cpp_lib_coroutine``                           *unimplemented*
     ------------------------------------------------- -----------------
     ``__cpp_lib_destroying_delete``                   ``201806L``

libcxx/include/iterator

protected:
     Container* container;
 public:
     typedef Container                   container_type;
     typedef void                        value_type;
     typedef void                        difference_type;
     typedef void                        reference;
     typedef void                        pointer;
 
-    explicit back_insert_iterator(Container& x);
-    back_insert_iterator& operator=(const typename Container::value_type& value);
-    back_insert_iterator& operator*();
-    back_insert_iterator& operator++();
-    back_insert_iterator  operator++(int);
+    explicit back_insert_iterator(Container& x);  // constexpr in C++20
+    back_insert_iterator& operator=(const typename Container::value_type& value);  // constexpr in C++20
+    back_insert_iterator& operator*();  // constexpr in C++20
+    back_insert_iterator& operator++();  // constexpr in C++20
+    back_insert_iterator  operator++(int);  // constexpr in C++20
 };
 
-template <class Container> back_insert_iterator<Container> back_inserter(Container& x);
+template <class Container> back_insert_iterator<Container> back_inserter(Container& x);  // constexpr in C++20
 
 template <class Container>
 class front_insert_iterator
 {
 protected:
     Container* container;
 public:
     typedef Container                    container_type;
     typedef void                         value_type;
     typedef void                         difference_type;
     typedef void                         reference;
     typedef void                         pointer;
 
-    explicit front_insert_iterator(Container& x);
-    front_insert_iterator& operator=(const typename Container::value_type& value);
-    front_insert_iterator& operator*();
-    front_insert_iterator& operator++();
-    front_insert_iterator  operator++(int);
+    explicit front_insert_iterator(Container& x);  // constexpr in C++20
+    front_insert_iterator& operator=(const typename Container::value_type& value);  // constexpr in C++20
+    front_insert_iterator& operator*();  // constexpr in C++20
+    front_insert_iterator& operator++();  // constexpr in C++20
+    front_insert_iterator  operator++(int);  // constexpr in C++20
 };
 
-template <class Container> front_insert_iterator<Container> front_inserter(Container& x);
+template <class Container> front_insert_iterator<Container> front_inserter(Container& x);  // constexpr in C++20
 
 template <class Container>
 class insert_iterator
 {
 protected:
     Container* container;
     typename Container::iterator iter;
 public:
     typedef Container              container_type;
     typedef void                   value_type;
     typedef void                   difference_type;
     typedef void                   reference;
     typedef void                   pointer;
 
-    insert_iterator(Container& x, typename Container::iterator i);
-    insert_iterator& operator=(const typename Container::value_type& value);
-    insert_iterator& operator*();
-    insert_iterator& operator++();
-    insert_iterator& operator++(int);
+    insert_iterator(Container& x, typename Container::iterator i);  // constexpr in C++20
+    insert_iterator& operator=(const typename Container::value_type& value);  // constexpr in C++20
+    insert_iterator& operator*();  // constexpr in C++20
+    insert_iterator& operator++();  // constexpr in C++20
+    insert_iterator& operator++(int);  // constexpr in C++20
 };
 
 template <class Container, class Iterator>
-insert_iterator<Container> inserter(Container& x, Iterator i);
+insert_iterator<Container> inserter(Container& x, Iterator i);  // constexpr in C++20
 
 template <class Iterator>
 class move_iterator {
 public:
     typedef Iterator                                              iterator_type;
     typedef typename iterator_traits<Iterator>::difference_type   difference_type;
     typedef Iterator                                              pointer;
     typedef typename iterator_traits<Iterator>::value_type        value_type;
: public iterator<output_iterator_tag,
                       void,
                       void>
 {
 protected:
     _Container* container;
 public:
     typedef _Container container_type;
 
-    _LIBCPP_INLINE_VISIBILITY explicit back_insert_iterator(_Container& __x) : container(_VSTD::addressof(__x)) {}
-    _LIBCPP_INLINE_VISIBILITY back_insert_iterator& operator=(const typename _Container::value_type& __value_)
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 explicit back_insert_iterator(_Container& __x) : container(_VSTD::addressof(__x)) {}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 back_insert_iterator& operator=(const typename _Container::value_type& __value_)
         {container->push_back(__value_); return *this;}
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY back_insert_iterator& operator=(typename _Container::value_type&& __value_)
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 back_insert_iterator& operator=(typename _Container::value_type&& __value_)
         {container->push_back(_VSTD::move(__value_)); return *this;}
 #endif  // _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY back_insert_iterator& operator*()     {return *this;}
-    _LIBCPP_INLINE_VISIBILITY back_insert_iterator& operator++()    {return *this;}
-    _LIBCPP_INLINE_VISIBILITY back_insert_iterator  operator++(int) {return *this;}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 back_insert_iterator& operator*()     {return *this;}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 back_insert_iterator& operator++()    {return *this;}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 back_insert_iterator  operator++(int) {return *this;}
 };
 
 template <class _Container>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 back_insert_iterator<_Container>
 back_inserter(_Container& __x)
 {
     return back_insert_iterator<_Container>(__x);
 }
 
 template <class _Container>
 class _LIBCPP_TEMPLATE_VIS front_insert_iterator
     : public iterator<output_iterator_tag,
                       void,
                       void,
                       void,
                       void>
 {
 protected:
     _Container* container;
 public:
     typedef _Container container_type;
 
-    _LIBCPP_INLINE_VISIBILITY explicit front_insert_iterator(_Container& __x) : container(_VSTD::addressof(__x)) {}
-    _LIBCPP_INLINE_VISIBILITY front_insert_iterator& operator=(const typename _Container::value_type& __value_)
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 explicit front_insert_iterator(_Container& __x) : container(_VSTD::addressof(__x)) {}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 front_insert_iterator& operator=(const typename _Container::value_type& __value_)
         {container->push_front(__value_); return *this;}
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY front_insert_iterator& operator=(typename _Container::value_type&& __value_)
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 front_insert_iterator& operator=(typename _Container::value_type&& __value_)
         {container->push_front(_VSTD::move(__value_)); return *this;}
 #endif  // _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY front_insert_iterator& operator*()     {return *this;}
-    _LIBCPP_INLINE_VISIBILITY front_insert_iterator& operator++()    {return *this;}
-    _LIBCPP_INLINE_VISIBILITY front_insert_iterator  operator++(int) {return *this;}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 front_insert_iterator& operator*()     {return *this;}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 front_insert_iterator& operator++()    {return *this;}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 front_insert_iterator  operator++(int) {return *this;}
 };
 
 template <class _Container>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 front_insert_iterator<_Container>
 front_inserter(_Container& __x)
 {
     return front_insert_iterator<_Container>(__x);
 }
 
 template <class _Container>
 class _LIBCPP_TEMPLATE_VIS insert_iterator
     : public iterator<output_iterator_tag,
                       void,
                       void,
                       void,
                       void>
 {
 protected:
     _Container* container;
     typename _Container::iterator iter;
 public:
     typedef _Container container_type;
 
-    _LIBCPP_INLINE_VISIBILITY insert_iterator(_Container& __x, typename _Container::iterator __i)
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 insert_iterator(_Container& __x, typename _Container::iterator __i)
         : container(_VSTD::addressof(__x)), iter(__i) {}
-    _LIBCPP_INLINE_VISIBILITY insert_iterator& operator=(const typename _Container::value_type& __value_)
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 insert_iterator& operator=(const typename _Container::value_type& __value_)
         {iter = container->insert(iter, __value_); ++iter; return *this;}
 #ifndef _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY insert_iterator& operator=(typename _Container::value_type&& __value_)
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 insert_iterator& operator=(typename _Container::value_type&& __value_)
         {iter = container->insert(iter, _VSTD::move(__value_)); ++iter; return *this;}
 #endif  // _LIBCPP_CXX03_LANG
-    _LIBCPP_INLINE_VISIBILITY insert_iterator& operator*()        {return *this;}
-    _LIBCPP_INLINE_VISIBILITY insert_iterator& operator++()       {return *this;}
-    _LIBCPP_INLINE_VISIBILITY insert_iterator& operator++(int)    {return *this;}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 insert_iterator& operator*()        {return *this;}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 insert_iterator& operator++()       {return *this;}
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 insert_iterator& operator++(int)    {return *this;}
 };
 
 template <class _Container>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 insert_iterator<_Container>
 inserter(_Container& __x, typename _Container::iterator __i)
 {
     return insert_iterator<_Container>(__x, __i);
 }
 
 template <class _Tp, class _CharT = char,
           class _Traits = char_traits<_CharT>, class _Distance = ptrdiff_t>

libcxx/include/string_view

class basic_string_view {
       constexpr const_reference back() const;
       constexpr const_pointer data() const noexcept;
 
       // 7.7, basic_string_view modifiers
       constexpr void remove_prefix(size_type n);
       constexpr void remove_suffix(size_type n);
       constexpr void swap(basic_string_view& s) noexcept;
 
-      size_type copy(charT* s, size_type n, size_type pos = 0) const;
+      size_type copy(charT* s, size_type n, size_type pos = 0) const;  // constexpr in C++20
 
       constexpr basic_string_view substr(size_type pos = 0, size_type n = npos) const;
       constexpr int compare(basic_string_view s) const noexcept;
       constexpr int compare(size_type pos1, size_type n1, basic_string_view s) const;
       constexpr int compare(size_type pos1, size_type n1,
                             basic_string_view s, size_type pos2, size_type n2) const;
       constexpr int compare(const charT* s) const;
       constexpr int compare(size_type pos1, size_type n1, const charT* s) const;
void swap(basic_string_view& __other) _NOEXCEPT
         __data = __other.__data;
         __other.__data = __p;
 
         size_type __sz = __size;
         __size = __other.__size;
         __other.__size = __sz;
     }
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     size_type copy(_CharT* __s, size_type __n, size_type __pos = 0) const
     {
         if (__pos > size())
             __throw_out_of_range("string_view::copy");
         size_type __rlen = _VSTD::min(__n, size() - __pos);
         _Traits::copy(__s, data() + __pos, __rlen);
         return __rlen;
     }

libcxx/include/tuple

template <class U1, class U2>
         explicit(see-below) tuple(const pair<U1, U2>&); // iff sizeof...(T) == 2 // constexpr in C++14
     template <class U1, class U2>
         explicit(see-below) tuple(pair<U1, U2>&&); // iff sizeof...(T) == 2  // constexpr in C++14
 
     // allocator-extended constructors
     template <class Alloc>
         tuple(allocator_arg_t, const Alloc& a);
     template <class Alloc>
-        explicit(see-below) tuple(allocator_arg_t, const Alloc& a, const T&...);
+        explicit(see-below) tuple(allocator_arg_t, const Alloc& a, const T&...);          // constexpr in C++20
     template <class Alloc, class... U>
-        explicit(see-below) tuple(allocator_arg_t, const Alloc& a, U&&...);
+        explicit(see-below) tuple(allocator_arg_t, const Alloc& a, U&&...);               // constexpr in C++20
     template <class Alloc>
-        tuple(allocator_arg_t, const Alloc& a, const tuple&);
+        tuple(allocator_arg_t, const Alloc& a, const tuple&);                             // constexpr in C++20
     template <class Alloc>
-        tuple(allocator_arg_t, const Alloc& a, tuple&&);
+        tuple(allocator_arg_t, const Alloc& a, tuple&&);                                  // constexpr in C++20
     template <class Alloc, class... U>
-        explicit(see-below) tuple(allocator_arg_t, const Alloc& a, const tuple<U...>&);
+        explicit(see-below) tuple(allocator_arg_t, const Alloc& a, const tuple<U...>&);   // constexpr in C++20
     template <class Alloc, class... U>
-        explicit(see-below) tuple(allocator_arg_t, const Alloc& a, tuple<U...>&&);
+        explicit(see-below) tuple(allocator_arg_t, const Alloc& a, tuple<U...>&&);        // constexpr in C++20
     template <class Alloc, class U1, class U2>
-        explicit(see-below) tuple(allocator_arg_t, const Alloc& a, const pair<U1, U2>&);
+        explicit(see-below) tuple(allocator_arg_t, const Alloc& a, const pair<U1, U2>&);  // constexpr in C++20
     template <class Alloc, class U1, class U2>
-        explicit(see-below) tuple(allocator_arg_t, const Alloc& a, pair<U1, U2>&&);
+        explicit(see-below) tuple(allocator_arg_t, const Alloc& a, pair<U1, U2>&&);       // constexpr in C++20
 
-    tuple& operator=(const tuple&);
-    tuple& operator=(tuple&&) noexcept(is_nothrow_move_assignable_v<T> && ...);
+    tuple& operator=(const tuple&);                                                       // constexpr in C++20
+    tuple& operator=(tuple&&) noexcept(is_nothrow_move_assignable_v<T> && ...);           // constexpr in C++20
     template <class... U>
-        tuple& operator=(const tuple<U...>&);
+        tuple& operator=(const tuple<U...>&);                                             // constexpr in C++20
     template <class... U>
-        tuple& operator=(tuple<U...>&&);
+        tuple& operator=(tuple<U...>&&);                                                  // constexpr in C++20
     template <class U1, class U2>
-        tuple& operator=(const pair<U1, U2>&); // iff sizeof...(T) == 2
+        tuple& operator=(const pair<U1, U2>&); // iff sizeof...(T) == 2                   // constexpr in C++20
     template <class U1, class U2>
-        tuple& operator=(pair<U1, U2>&&); // iff sizeof...(T) == 2
+        tuple& operator=(pair<U1, U2>&&); // iff sizeof...(T) == 2                        // constexpr in C++20
 
     template<class U, size_t N>
         tuple& operator=(array<U, N> const&) // iff sizeof...(T) == N, EXTENSION
     template<class U, size_t N>
         tuple& operator=(array<U, N>&&) // iff sizeof...(T) == N, EXTENSION
 
-    void swap(tuple&) noexcept(AND(swap(declval<T&>(), declval<T&>())...));
+    void swap(tuple&) noexcept(AND(swap(declval<T&>(), declval<T&>())...));               // constexpr in C++20
 };
 
 template <class ...T>
 tuple(T...) -> tuple<T...>;                                         // since C++17
 template <class T1, class T2>
 tuple(pair<T1, T2>) -> tuple<T1, T2>;                               // since C++17
 template <class Alloc, class ...T>
 tuple(allocator_arg_t, Alloc, T...) -> tuple<T...>;                 // since C++17

 // __tuple_leaf
 
 template <size_t _Ip, class _Hp,
           bool=is_empty<_Hp>::value && !__libcpp_is_final<_Hp>::value
          >
 class __tuple_leaf;
 
 template <size_t _Ip, class _Hp, bool _Ep>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 void swap(__tuple_leaf<_Ip, _Hp, _Ep>& __x, __tuple_leaf<_Ip, _Hp, _Ep>& __y)
     _NOEXCEPT_(__is_nothrow_swappable<_Hp>::value)
 {
     swap(__x.get(), __y.get());
 }
 
 template <size_t _Ip, class _Hp, bool>
 class __tuple_leaf
 {
     _Hp __value_;
 
     template <class _Tp>
     static constexpr bool __can_bind_reference() {
 #if __has_keyword(__reference_binds_to_temporary)
       return !__reference_binds_to_temporary(_Hp, _Tp);
 #else
       return true;
 #endif
     }
 
+    _LIBCPP_CONSTEXPR_AFTER_CXX11
     __tuple_leaf& operator=(const __tuple_leaf&);
 public:
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR __tuple_leaf()
+    _LIBCPP_INLINE_VISIBILITY constexpr __tuple_leaf()
              _NOEXCEPT_(is_nothrow_default_constructible<_Hp>::value) : __value_()
        {static_assert(!is_reference<_Hp>::value,
               "Attempted to default construct a reference element in a tuple");}
 
     template <class _Alloc>
-        _LIBCPP_INLINE_VISIBILITY
+        _LIBCPP_INLINE_VISIBILITY constexpr
         __tuple_leaf(integral_constant<int, 0>, const _Alloc&)
             : __value_()
         {static_assert(!is_reference<_Hp>::value,
               "Attempted to default construct a reference element in a tuple");}
 
     template <class _Alloc>
-        _LIBCPP_INLINE_VISIBILITY
+        _LIBCPP_INLINE_VISIBILITY constexpr
         __tuple_leaf(integral_constant<int, 1>, const _Alloc& __a)
             : __value_(allocator_arg_t(), __a)
         {static_assert(!is_reference<_Hp>::value,
               "Attempted to default construct a reference element in a tuple");}
 
     template <class _Alloc>
-        _LIBCPP_INLINE_VISIBILITY
+        _LIBCPP_INLINE_VISIBILITY constexpr
         __tuple_leaf(integral_constant<int, 2>, const _Alloc& __a)
             : __value_(__a)
         {static_assert(!is_reference<_Hp>::value,
               "Attempted to default construct a reference element in a tuple");}
 
     template <class _Tp,
               class = _EnableIf<
                   _And<
                       _IsNotSame<__uncvref_t<_Tp>, __tuple_leaf>,
                       is_constructible<_Hp, _Tp>
                     >::value
                 >
             >
         _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
         explicit __tuple_leaf(_Tp&& __t) _NOEXCEPT_((is_nothrow_constructible<_Hp, _Tp>::value))
             : __value_(_VSTD::forward<_Tp>(__t))
         {static_assert(__can_bind_reference<_Tp&&>(),
        "Attempted construction of reference element binds to a temporary whose lifetime has ended");}
 
     template <class _Tp, class _Alloc>
-        _LIBCPP_INLINE_VISIBILITY
+        _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
         explicit __tuple_leaf(integral_constant<int, 0>, const _Alloc&, _Tp&& __t)
             : __value_(_VSTD::forward<_Tp>(__t))
         {static_assert(__can_bind_reference<_Tp&&>(),
        "Attempted construction of reference element binds to a temporary whose lifetime has ended");}
 
     template <class _Tp, class _Alloc>
-        _LIBCPP_INLINE_VISIBILITY
+        _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
         explicit __tuple_leaf(integral_constant<int, 1>, const _Alloc& __a, _Tp&& __t)
             : __value_(allocator_arg_t(), __a, _VSTD::forward<_Tp>(__t))
         {static_assert(!is_reference<_Hp>::value,
             "Attempted to uses-allocator construct a reference element in a tuple");}
 
     template <class _Tp, class _Alloc>
-        _LIBCPP_INLINE_VISIBILITY
+        _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
         explicit __tuple_leaf(integral_constant<int, 2>, const _Alloc& __a, _Tp&& __t)
             : __value_(_VSTD::forward<_Tp>(__t), __a)
         {static_assert(!is_reference<_Hp>::value,
            "Attempted to uses-allocator construct a reference element in a tuple");}
 
     __tuple_leaf(const __tuple_leaf& __t) = default;
     __tuple_leaf(__tuple_leaf&& __t) = default;
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
     int swap(__tuple_leaf& __t) _NOEXCEPT_(__is_nothrow_swappable<__tuple_leaf>::value)
     {
         _VSTD::swap(*this, __t);
         return 0;
     }
 
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11       _Hp& get()       _NOEXCEPT {return __value_;}
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 const _Hp& get() const _NOEXCEPT {return __value_;}
 };
 
 template <size_t _Ip, class _Hp>
 class __tuple_leaf<_Ip, _Hp, true>
     : private _Hp
 {
-
+    _LIBCPP_CONSTEXPR_AFTER_CXX11
     __tuple_leaf& operator=(const __tuple_leaf&);
 public:
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR __tuple_leaf()
+    _LIBCPP_INLINE_VISIBILITY constexpr __tuple_leaf()
              _NOEXCEPT_(is_nothrow_default_constructible<_Hp>::value) {}
 
     template <class _Alloc>
-        _LIBCPP_INLINE_VISIBILITY
+        _LIBCPP_INLINE_VISIBILITY constexpr
         __tuple_leaf(integral_constant<int, 0>, const _Alloc&) {}
 
     template <class _Alloc>
-        _LIBCPP_INLINE_VISIBILITY
+        _LIBCPP_INLINE_VISIBILITY constexpr
         __tuple_leaf(integral_constant<int, 1>, const _Alloc& __a)
             : _Hp(allocator_arg_t(), __a) {}
 
     template <class _Alloc>
-        _LIBCPP_INLINE_VISIBILITY
+        _LIBCPP_INLINE_VISIBILITY constexpr
         __tuple_leaf(integral_constant<int, 2>, const _Alloc& __a)
             : _Hp(__a) {}
 
     template <class _Tp,
               class = _EnableIf<
                   _And<
                     _IsNotSame<__uncvref_t<_Tp>, __tuple_leaf>,
                     is_constructible<_Hp, _Tp>
                   >::value
                 >
             >
         _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
         explicit __tuple_leaf(_Tp&& __t) _NOEXCEPT_((is_nothrow_constructible<_Hp, _Tp>::value))
             : _Hp(_VSTD::forward<_Tp>(__t)) {}
 
     template <class _Tp, class _Alloc>
-        _LIBCPP_INLINE_VISIBILITY
+        _LIBCPP_INLINE_VISIBILITY constexpr
         explicit __tuple_leaf(integral_constant<int, 0>, const _Alloc&, _Tp&& __t)
             : _Hp(_VSTD::forward<_Tp>(__t)) {}
 
     template <class _Tp, class _Alloc>
-        _LIBCPP_INLINE_VISIBILITY
+        _LIBCPP_INLINE_VISIBILITY constexpr
         explicit __tuple_leaf(integral_constant<int, 1>, const _Alloc& __a, _Tp&& __t)
             : _Hp(allocator_arg_t(), __a, _VSTD::forward<_Tp>(__t)) {}
 
     template <class _Tp, class _Alloc>
-        _LIBCPP_INLINE_VISIBILITY
+        _LIBCPP_INLINE_VISIBILITY constexpr
         explicit __tuple_leaf(integral_constant<int, 2>, const _Alloc& __a, _Tp&& __t)
             : _Hp(_VSTD::forward<_Tp>(__t), __a) {}
 
     __tuple_leaf(__tuple_leaf const &) = default;
     __tuple_leaf(__tuple_leaf &&) = default;
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
     int
     swap(__tuple_leaf& __t) _NOEXCEPT_(__is_nothrow_swappable<__tuple_leaf>::value)
     {
         _VSTD::swap(*this, __t);
         return 0;
     }
 
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11       _Hp& get()       _NOEXCEPT {return static_cast<_Hp&>(*this);}
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 const _Hp& get() const _NOEXCEPT {return static_cast<const _Hp&>(*this);}
 };
 
 template <class ..._Tp>
-_LIBCPP_INLINE_VISIBILITY
+_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 void __swallow(_Tp&&...) _NOEXCEPT {}
 
 template <class _Tp>
 struct __all_default_constructible;
 
 template <class ..._Tp>
 struct __all_default_constructible<__tuple_types<_Tp...>>
     : __all<is_default_constructible<_Tp>::value...>
 { };
 
 // __tuple_impl
 
 template<class _Indx, class ..._Tp> struct __tuple_impl;
 
 template<size_t ..._Indx, class ..._Tp>
 struct _LIBCPP_DECLSPEC_EMPTY_BASES __tuple_impl<__tuple_indices<_Indx...>, _Tp...>
     : public __tuple_leaf<_Indx, _Tp>...
 {
     _LIBCPP_INLINE_VISIBILITY
-    _LIBCPP_CONSTEXPR __tuple_impl()
+    constexpr __tuple_impl()
         _NOEXCEPT_(__all<is_nothrow_default_constructible<_Tp>::value...>::value) {}
 
     template <size_t ..._Uf, class ..._Tf,
               size_t ..._Ul, class ..._Tl, class ..._Up>
         _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
         explicit
         __tuple_impl(__tuple_indices<_Uf...>, __tuple_types<_Tf...>,
                      __tuple_indices<_Ul...>, __tuple_types<_Tl...>,
                      _Up&&... __u)
                      _NOEXCEPT_((__all<is_nothrow_constructible<_Tf, _Up>::value...>::value &&
                                  __all<is_nothrow_default_constructible<_Tl>::value...>::value)) :
             __tuple_leaf<_Uf, _Tf>(_VSTD::forward<_Up>(__u))...,
             __tuple_leaf<_Ul, _Tl>()...
             {}
 
     template <class _Alloc, size_t ..._Uf, class ..._Tf,
               size_t ..._Ul, class ..._Tl, class ..._Up>
-        _LIBCPP_INLINE_VISIBILITY
+        _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
         explicit
         __tuple_impl(allocator_arg_t, const _Alloc& __a,
                      __tuple_indices<_Uf...>, __tuple_types<_Tf...>,
                      __tuple_indices<_Ul...>, __tuple_types<_Tl...>,
                      _Up&&... __u) :
             __tuple_leaf<_Uf, _Tf>(__uses_alloc_ctor<_Tf, _Alloc, _Up>(), __a,
             _VSTD::forward<_Up>(__u))...,
             __tuple_leaf<_Ul, _Tl>(__uses_alloc_ctor<_Tl, _Alloc>(), __a)...
template <class _Tuple,
             {}
 
     template <class _Alloc, class _Tuple,
               class = typename enable_if
                       <
                          __tuple_constructible<_Tuple, tuple<_Tp...> >::value
                       >::type
              >
-        _LIBCPP_INLINE_VISIBILITY
+        _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
         __tuple_impl(allocator_arg_t, const _Alloc& __a, _Tuple&& __t)
             : __tuple_leaf<_Indx, _Tp>(__uses_alloc_ctor<_Tp, _Alloc, typename tuple_element<_Indx,
                                        typename __make_tuple_types<_Tuple>::type>::type>(), __a,
                                        _VSTD::forward<typename tuple_element<_Indx,
                                        typename __make_tuple_types<_Tuple>::type>::type>(_VSTD::get<_Indx>(__t)))...
             {}
 
     __tuple_impl(const __tuple_impl&) = default;
     __tuple_impl(__tuple_impl&&) = default;
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
     void swap(__tuple_impl& __t)
         _NOEXCEPT_(__all<__is_nothrow_swappable<_Tp>::value...>::value)
     {
         _VSTD::__swallow(__tuple_leaf<_Indx, _Tp>::swap(static_cast<__tuple_leaf<_Indx, _Tp>&>(__t))...);
     }
 };
 
 template<class _Dest, class _Source, size_t ..._Np>
-_LIBCPP_INLINE_VISIBILITY
+_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 void __memberwise_copy_assign(_Dest& __dest, _Source const& __source, __tuple_indices<_Np...>) {
     _VSTD::__swallow(((_VSTD::get<_Np>(__dest) = _VSTD::get<_Np>(__source)), void(), 0)...);
 }
 
 template<class _Dest, class _Source, class ..._Up, size_t ..._Np>
-_LIBCPP_INLINE_VISIBILITY
+_LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 void __memberwise_forward_assign(_Dest& __dest, _Source&& __source, __tuple_types<_Up...>, __tuple_indices<_Np...>) {
     _VSTD::__swallow(((
         _VSTD::get<_Np>(__dest) = _VSTD::forward<_Up>(_VSTD::get<_Np>(__source))
     ), void(), 0)...);
 }
 
 template <class ..._Tp>
 class _LIBCPP_TEMPLATE_VIS tuple
template <size_t _Jp, class ..._Up> friend _LIBCPP_CONSTEXPR_AFTER_CXX11
         typename tuple_element<_Jp, tuple<_Up...> >::type&& get(tuple<_Up...>&&) _NOEXCEPT;
     template <size_t _Jp, class ..._Up> friend _LIBCPP_CONSTEXPR_AFTER_CXX11
         const typename tuple_element<_Jp, tuple<_Up...> >::type&& get(const tuple<_Up...>&&) _NOEXCEPT;
 public:
 
     template <bool _Dummy = true, _EnableIf<
         _CheckArgsConstructor<_Dummy>::__enable_implicit_default()
     , void*> = nullptr>
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
+    _LIBCPP_INLINE_VISIBILITY constexpr
     tuple()
         _NOEXCEPT_(__all<is_nothrow_default_constructible<_Tp>::value...>::value) {}
 
     template <bool _Dummy = true, _EnableIf<
         _CheckArgsConstructor<_Dummy>::__enable_explicit_default()
     , void*> = nullptr>
-    explicit _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
+    explicit _LIBCPP_INLINE_VISIBILITY constexpr
     tuple()
         _NOEXCEPT_(__all<is_nothrow_default_constructible<_Tp>::value...>::value) {}
 
     tuple(tuple const&) = default;
     tuple(tuple&&) = default;
 
     template <class _AllocArgT, class _Alloc, _EnableIf<
              _CheckArgsConstructor<_IsSame<allocator_arg_t, _AllocArgT>::value >::__enable_implicit_default()
       , void*> = nullptr
     >
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     tuple(_AllocArgT, _Alloc const& __a)
       : __base_(allocator_arg_t(), __a,
                     __tuple_indices<>(), __tuple_types<>(),
                     typename __make_tuple_indices<sizeof...(_Tp), 0>::type(),
                     __tuple_types<_Tp...>()) {}
 
     template <class _AllocArgT, class _Alloc, _EnableIf<
              _CheckArgsConstructor<_IsSame<allocator_arg_t, _AllocArgT>::value>::__enable_explicit_default()
       , void*> = nullptr
     >
-    explicit _LIBCPP_INLINE_VISIBILITY
+    explicit _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     tuple(_AllocArgT, _Alloc const& __a)
       : __base_(allocator_arg_t(), __a,
                     __tuple_indices<>(), __tuple_types<>(),
                     typename __make_tuple_indices<sizeof...(_Tp), 0>::type(),
                     __tuple_types<_Tp...>()) {}
 
     template <bool _Dummy = true,
               typename enable_if
template <class _Alloc, bool _Dummy = true,
               typename enable_if
                       <
                          _CheckArgsConstructor<
                             _Dummy
                          >::template __enable_implicit<_Tp const&...>(),
                          bool
                       >::type = false
         >
-      _LIBCPP_INLINE_VISIBILITY
+      _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
       tuple(allocator_arg_t, const _Alloc& __a, const _Tp& ... __t)
         : __base_(allocator_arg_t(), __a,
                 typename __make_tuple_indices<sizeof...(_Tp)>::type(),
                 typename __make_tuple_types<tuple, sizeof...(_Tp)>::type(),
                 typename __make_tuple_indices<0>::type(),
                 typename __make_tuple_types<tuple, 0>::type(),
                 __t...
                ) {}
 
     template <class _Alloc, bool _Dummy = true,
               typename enable_if
                       <
                          _CheckArgsConstructor<
                             _Dummy
                          >::template __enable_explicit<_Tp const&...>(),
                          bool
                       >::type = false
         >
-      _LIBCPP_INLINE_VISIBILITY
+      _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
       explicit
       tuple(allocator_arg_t, const _Alloc& __a, const _Tp& ... __t)
         : __base_(allocator_arg_t(), __a,
                 typename __make_tuple_indices<sizeof...(_Tp)>::type(),
                 typename __make_tuple_types<tuple, sizeof...(_Tp)>::type(),
                 typename __make_tuple_indices<0>::type(),
                 typename __make_tuple_types<tuple, 0>::type(),
                 __t...
template <class _Alloc, class ..._Up,
                       <
                          _CheckArgsConstructor<
                              sizeof...(_Up) == sizeof...(_Tp) &&
                              !_PackExpandsToThisTuple<_Up...>::value
                          >::template __enable_implicit<_Up...>(),
                          bool
                       >::type = false
              >
-        _LIBCPP_INLINE_VISIBILITY
+        _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
         tuple(allocator_arg_t, const _Alloc& __a, _Up&&... __u)
             : __base_(allocator_arg_t(), __a,
                     typename __make_tuple_indices<sizeof...(_Up)>::type(),
                     typename __make_tuple_types<tuple, sizeof...(_Up)>::type(),
                     typename __make_tuple_indices<sizeof...(_Tp), sizeof...(_Up)>::type(),
                     typename __make_tuple_types<tuple, sizeof...(_Tp), sizeof...(_Up)>::type(),
                     _VSTD::forward<_Up>(__u)...) {}
 
     template <class _Alloc, class ..._Up,
               typename enable_if
                       <
                          _CheckArgsConstructor<
                              sizeof...(_Up) == sizeof...(_Tp) &&
                              !_PackExpandsToThisTuple<_Up...>::value
                          >::template __enable_explicit<_Up...>(),
                          bool
                       >::type = false
              >
-        _LIBCPP_INLINE_VISIBILITY
+        _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
         explicit
         tuple(allocator_arg_t, const _Alloc& __a, _Up&&... __u)
             : __base_(allocator_arg_t(), __a,
                     typename __make_tuple_indices<sizeof...(_Up)>::type(),
                     typename __make_tuple_types<tuple, sizeof...(_Up)>::type(),
                     typename __make_tuple_indices<sizeof...(_Tp), sizeof...(_Up)>::type(),
                     typename __make_tuple_types<tuple, sizeof...(_Tp), sizeof...(_Up)>::type(),
                     _VSTD::forward<_Up>(__u)...) {}
template <class _Alloc, class _Tuple,
               typename enable_if
                       <
                          _CheckTupleLikeConstructor<
                              __tuple_like_with_size<_Tuple, sizeof...(_Tp)>::value
                          >::template __enable_implicit<_Tuple>(),
                          bool
                       >::type = false
              >
-        _LIBCPP_INLINE_VISIBILITY
+        _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
         tuple(allocator_arg_t, const _Alloc& __a, _Tuple&& __t)
             : __base_(allocator_arg_t(), __a, _VSTD::forward<_Tuple>(__t)) {}
 
     template <class _Alloc, class _Tuple,
               typename enable_if
                       <
                          _CheckTupleLikeConstructor<
                              __tuple_like_with_size<_Tuple, sizeof...(_Tp)>::value
                          >::template __enable_explicit<_Tuple>(),
                          bool
                       >::type = false
              >
-        _LIBCPP_INLINE_VISIBILITY
+        _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
         explicit
         tuple(allocator_arg_t, const _Alloc& __a, _Tuple&& __t)
             : __base_(allocator_arg_t(), __a, _VSTD::forward<_Tuple>(__t)) {}
 
     // [tuple.assign]
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     tuple& operator=(_If<_And<is_copy_assignable<_Tp>...>::value, tuple, __nat> const& __tuple)
         _NOEXCEPT_((_And<is_nothrow_copy_assignable<_Tp>...>::value))
     {
         _VSTD::__memberwise_copy_assign(*this, __tuple,
             typename __make_tuple_indices<sizeof...(_Tp)>::type());
         return *this;
     }
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     tuple& operator=(_If<_And<is_move_assignable<_Tp>...>::value, tuple, __nat>&& __tuple)
         _NOEXCEPT_((_And<is_nothrow_move_assignable<_Tp>...>::value))
     {
         _VSTD::__memberwise_forward_assign(*this, _VSTD::move(__tuple),
             __tuple_types<_Tp...>(),
             typename __make_tuple_indices<sizeof...(_Tp)>::type());
         return *this;
     }
 
     template<class... _Up, _EnableIf<
         _And<
             _BoolConstant<sizeof...(_Tp) == sizeof...(_Up)>,
             is_assignable<_Tp&, _Up const&>...
         >::value
     ,int> = 0>
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     tuple& operator=(tuple<_Up...> const& __tuple)
         _NOEXCEPT_((_And<is_nothrow_assignable<_Tp&, _Up const&>...>::value))
     {
         _VSTD::__memberwise_copy_assign(*this, __tuple,
             typename __make_tuple_indices<sizeof...(_Tp)>::type());
         return *this;
     }
 
     template<class... _Up, _EnableIf<
         _And<
             _BoolConstant<sizeof...(_Tp) == sizeof...(_Up)>,
             is_assignable<_Tp&, _Up>...
         >::value
     ,int> = 0>
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     tuple& operator=(tuple<_Up...>&& __tuple)
         _NOEXCEPT_((_And<is_nothrow_assignable<_Tp&, _Up>...>::value))
     {
         _VSTD::__memberwise_forward_assign(*this, _VSTD::move(__tuple),
             __tuple_types<_Up...>(),
             typename __make_tuple_indices<sizeof...(_Tp)>::type());
         return *this;
     }
 
     template<class _Up1, class _Up2, class _Dep = true_type, _EnableIf<
         _And<_Dep,
             _BoolConstant<sizeof...(_Tp) == 2>,
             is_assignable<_FirstType<_Tp..., _Dep>&, _Up1 const&>,
             is_assignable<_SecondType<_Tp..., _Dep>&, _Up2 const&>
         >::value
     ,int> = 0>
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     tuple& operator=(pair<_Up1, _Up2> const& __pair)
         _NOEXCEPT_((_And<
             is_nothrow_assignable<_FirstType<_Tp...>&, _Up1 const&>,
             is_nothrow_assignable<_SecondType<_Tp...>&, _Up2 const&>
         >::value))
     {
         _VSTD::get<0>(*this) = __pair.first;
         _VSTD::get<1>(*this) = __pair.second;
         return *this;
     }
 
     template<class _Up1, class _Up2, class _Dep = true_type, _EnableIf<
         _And<_Dep,
             _BoolConstant<sizeof...(_Tp) == 2>,
             is_assignable<_FirstType<_Tp..., _Dep>&, _Up1>,
             is_assignable<_SecondType<_Tp..., _Dep>&, _Up2>
         >::value
     ,int> = 0>
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     tuple& operator=(pair<_Up1, _Up2>&& __pair)
         _NOEXCEPT_((_And<
             is_nothrow_assignable<_FirstType<_Tp...>&, _Up1>,
             is_nothrow_assignable<_SecondType<_Tp...>&, _Up2>
         >::value))
     {
         _VSTD::get<0>(*this) = _VSTD::forward<_Up1>(__pair.first);
         _VSTD::get<1>(*this) = _VSTD::forward<_Up2>(__pair.second);
         return *this;
     }
 
     // EXTENSION
     template<class _Up, size_t _Np, class = _EnableIf<
         _And<
             _BoolConstant<_Np == sizeof...(_Tp)>,
             is_assignable<_Tp&, _Up const&>...
         >::value
     > >
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     tuple& operator=(array<_Up, _Np> const& __array)
         _NOEXCEPT_((_And<is_nothrow_assignable<_Tp&, _Up const&>...>::value))
     {
         _VSTD::__memberwise_copy_assign(*this, __array,
             typename __make_tuple_indices<sizeof...(_Tp)>::type());
         return *this;
     }
 
     // EXTENSION
     template<class _Up, size_t _Np, class = void, class = _EnableIf<
         _And<
             _BoolConstant<_Np == sizeof...(_Tp)>,
             is_assignable<_Tp&, _Up>...
         >::value
     > >
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     tuple& operator=(array<_Up, _Np>&& __array)
         _NOEXCEPT_((_And<is_nothrow_assignable<_Tp&, _Up>...>::value))
     {
         _VSTD::__memberwise_forward_assign(*this, _VSTD::move(__array),
             __tuple_types<_If<true, _Up, _Tp>...>(),
             typename __make_tuple_indices<sizeof...(_Tp)>::type());
         return *this;
     }
 
     // [tuple.swap]
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     void swap(tuple& __t) _NOEXCEPT_(__all<__is_nothrow_swappable<_Tp>::value...>::value)
         {__base_.swap(__t.__base_);}
 };
 
 template <>
 class _LIBCPP_TEMPLATE_VIS tuple<>
 {
 public:
-    _LIBCPP_INLINE_VISIBILITY
-    _LIBCPP_CONSTEXPR tuple() _NOEXCEPT = default;
+    _LIBCPP_INLINE_VISIBILITY constexpr
+        tuple() _NOEXCEPT = default;
     template <class _Alloc>
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
         tuple(allocator_arg_t, const _Alloc&) _NOEXCEPT {}
     template <class _Alloc>
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
         tuple(allocator_arg_t, const _Alloc&, const tuple&) _NOEXCEPT {}
     template <class _Up>
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
         tuple(array<_Up, 0>) _NOEXCEPT {}
     template <class _Alloc, class _Up>
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
         tuple(allocator_arg_t, const _Alloc&, array<_Up, 0>) _NOEXCEPT {}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     void swap(tuple&) _NOEXCEPT {}
 };
 
 #ifndef _LIBCPP_HAS_NO_DEDUCTION_GUIDES
 template <class ..._Tp>
 tuple(_Tp...) -> tuple<_Tp...>;
 template <class _Tp1, class _Tp2>
 tuple(pair<_Tp1, _Tp2>) -> tuple<_Tp1, _Tp2>;
 template <class _Alloc, class ..._Tp>
 tuple(allocator_arg_t, _Alloc, _Tp...) -> tuple<_Tp...>;
 template <class _Alloc, class _Tp1, class _Tp2>
 tuple(allocator_arg_t, _Alloc, pair<_Tp1, _Tp2>) -> tuple<_Tp1, _Tp2>;
 template <class _Alloc, class ..._Tp>
 tuple(allocator_arg_t, _Alloc, tuple<_Tp...>) -> tuple<_Tp...>;
 #endif
 
 template <class ..._Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 typename enable_if
 <
     __all<__is_swappable<_Tp>::value...>::value,
     void
 >::type
 swap(tuple<_Tp...>& __t, tuple<_Tp...>& __u)
                  _NOEXCEPT_(__all<__is_nothrow_swappable<_Tp>::value...>::value)
     {__t.swap(__u);}

libcxx/include/utility

struct pair
     pair(pair&&) = default;
     explicit(see-below) constexpr pair();
     explicit(see-below) pair(const T1& x, const T2& y);                          // constexpr in C++14
     template <class U, class V> explicit(see-below) pair(U&& x, V&& y);          // constexpr in C++14
     template <class U, class V> explicit(see-below) pair(const pair<U, V>& p);   // constexpr in C++14
     template <class U, class V> explicit(see-below) pair(pair<U, V>&& p);        // constexpr in C++14
     template <class... Args1, class... Args2>
         pair(piecewise_construct_t, tuple<Args1...> first_args,
-             tuple<Args2...> second_args);
+             tuple<Args2...> second_args);                                       // constexpr in C++20
 
-    template <class U, class V> pair& operator=(const pair<U, V>& p);
+    template <class U, class V> pair& operator=(const pair<U, V>& p);            // constexpr in C++20
     pair& operator=(pair&& p) noexcept(is_nothrow_move_assignable<T1>::value &&
-                                       is_nothrow_move_assignable<T2>::value);
-    template <class U, class V> pair& operator=(pair<U, V>&& p);
+                                       is_nothrow_move_assignable<T2>::value);   // constexpr in C++20
+    template <class U, class V> pair& operator=(pair<U, V>&& p);                 // constexpr in C++20
 
     void swap(pair& p) noexcept(is_nothrow_swappable_v<T1> &&
-                                is_nothrow_swappable_v<T2>);
+                                is_nothrow_swappable_v<T2>);                     // constexpr in C++20
 };
 
 template <class T1, class T2> bool operator==(const pair<T1,T2>&, const pair<T1,T2>&); // constexpr in C++14
 template <class T1, class T2> bool operator!=(const pair<T1,T2>&, const pair<T1,T2>&); // constexpr in C++14
 template <class T1, class T2> bool operator< (const pair<T1,T2>&, const pair<T1,T2>&); // constexpr in C++14
 template <class T1, class T2> bool operator> (const pair<T1,T2>&, const pair<T1,T2>&); // constexpr in C++14
 template <class T1, class T2> bool operator>=(const pair<T1,T2>&, const pair<T1,T2>&); // constexpr in C++14
 template <class T1, class T2> bool operator<=(const pair<T1,T2>&, const pair<T1,T2>&); // constexpr in C++14
 
-template <class T1, class T2> pair<V1, V2> make_pair(T1&&, T2&&);   // constexpr in C++14
+template <class T1, class T2> pair<V1, V2> make_pair(T1&&, T2&&);                // constexpr in C++14
 template <class T1, class T2>
 void
-swap(pair<T1, T2>& x, pair<T1, T2>& y) noexcept(noexcept(x.swap(y)));
+swap(pair<T1, T2>& x, pair<T1, T2>& y) noexcept(noexcept(x.swap(y)));            // constexpr in C++20
 
 struct piecewise_construct_t { explicit piecewise_construct_t() = default; };
 inline constexpr piecewise_construct_t piecewise_construct = piecewise_construct_t();
 
 template <class T> struct tuple_size;
 template <size_t I, class T> struct tuple_element;
 
 template <class T1, class T2> struct tuple_size<pair<T1, T2> >;

libcxx/include/version

 __cpp_lib_concepts                                      202002L <concepts>
 __cpp_lib_constexpr_algorithms                          201806L <algorithm>
 __cpp_lib_constexpr_complex                             201711L <complex>
 __cpp_lib_constexpr_dynamic_alloc                       201907L <memory>
 __cpp_lib_constexpr_functional                          201907L <functional>
 __cpp_lib_constexpr_iterator                            201811L <iterator>
 __cpp_lib_constexpr_memory                              201811L <memory>
 __cpp_lib_constexpr_numeric                             201911L <numeric>
-__cpp_lib_constexpr_string                              201907L <string>
+__cpp_lib_constexpr_string                              201811L <string>
 __cpp_lib_constexpr_string_view                         201811L <string_view>
 __cpp_lib_constexpr_tuple                               201811L <tuple>
 __cpp_lib_constexpr_utility                             201811L <utility>
 __cpp_lib_constexpr_vector                              201907L <vector>
 __cpp_lib_coroutine                                     201902L <coroutine>
 __cpp_lib_destroying_delete                             201806L <new>
 __cpp_lib_enable_shared_from_this                       201603L <memory>
 __cpp_lib_endian                                        201907L <bit>

 # if !defined(_LIBCPP_NO_HAS_CHAR8_T)
 #   define __cpp_lib_char8_t                            201811L
 # endif
 // # define __cpp_lib_concepts                             202002L
 # define __cpp_lib_constexpr_algorithms                 201806L
 // # define __cpp_lib_constexpr_complex                    201711L
 # define __cpp_lib_constexpr_dynamic_alloc              201907L
 # define __cpp_lib_constexpr_functional                 201907L
-// # define __cpp_lib_constexpr_iterator                   201811L
+# define __cpp_lib_constexpr_iterator                   201811L
 # define __cpp_lib_constexpr_memory                     201811L
 # define __cpp_lib_constexpr_numeric                    201911L
-// # define __cpp_lib_constexpr_string                     201907L
-// # define __cpp_lib_constexpr_string_view                201811L
-// # define __cpp_lib_constexpr_tuple                      201811L
+# define __cpp_lib_constexpr_string                     201811L
+# define __cpp_lib_constexpr_string_view                201811L
+# define __cpp_lib_constexpr_tuple                      201811L
 # define __cpp_lib_constexpr_utility                    201811L
 // # define __cpp_lib_constexpr_vector                     201907L
 // # define __cpp_lib_coroutine                            201902L
 # if _LIBCPP_STD_VER > 17 && defined(__cpp_impl_destroying_delete) && __cpp_impl_destroying_delete >= 201806L
 #   define __cpp_lib_destroying_delete                  201806L
 # endif
 # define __cpp_lib_endian                               201907L
 # define __cpp_lib_erase_if                             202002L

 // # define __cpp_lib_is_pointer_interconvertible          201907L
 # if !defined(_LIBCPP_HAS_NO_THREADS)
 // #   define __cpp_lib_jthread                            201911L
 # endif
 # if !defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_latch)
 #   define __cpp_lib_latch                              201907L
 # endif
 # define __cpp_lib_list_remove_return_type              201806L
 # if !defined(_LIBCPP_HAS_NO_CONCEPTS)
 #   define __cpp_lib_math_constants                     201907L
 # endif
 // # define __cpp_lib_polymorphic_allocator                201902L
 // # define __cpp_lib_ranges                               201811L
 # define __cpp_lib_remove_cvref                         201711L
 # if !defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_semaphore)
 #   define __cpp_lib_semaphore                          201907L
 # endif

libcxx/test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.insert.iter.cons/container.compile.fail.cpp

 
 // test for explicit
 
 #include <iterator>
 #include <vector>
 
 int main(int, char**)
 {
-    std::back_insert_iterator<std::vector<int> > i = std::vector<int>();
+    std::vector<int> v;
+    std::back_insert_iterator<std::vector<int> > i = v;
 
   return 0;
 }

libcxx/test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.insert.iter.op++/post.pass.cpp

 
 // back_insert_iterator
 
 // back_insert_iterator<Cont> operator++(int);
 
 #include <iterator>
 #include <vector>
 #include <cassert>
-#include "nasty_containers.h"
 
 #include "test_macros.h"
+#include "nasty_containers.h"
+#include "test_constexpr_container.h"
 
 template <class C>
-void
+TEST_CONSTEXPR_CXX20 bool
 test(C c)
 {
     std::back_insert_iterator<C> i(c);
     std::back_insert_iterator<C> r = i++;
     r = 0;
     assert(c.size() == 1);
     assert(c.back() == 0);
+    return true;
 }
 
 int main(int, char**)
 {
     test(std::vector<int>());
     test(nasty_vector<int>());
-
+#if TEST_STD_VER >= 20
+    test(ConstexprFixedCapacityDeque<int, 10>());
+    static_assert(test(ConstexprFixedCapacityDeque<int, 10>()));
+#endif
     return 0;
 }

libcxx/test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.insert.iter.op++/pre.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <iterator>
 
 // back_insert_iterator
 
 // back_insert_iterator<Cont>& operator++();
 
+#include <cassert>
 #include <iterator>
 #include <vector>
-#include <cassert>
-#include "nasty_containers.h"
 
 #include "test_macros.h"
+#include "nasty_containers.h"
+#include "test_constexpr_container.h"
 
 template <class C>
-void
+TEST_CONSTEXPR_CXX20 bool
 test(C c)
 {
     std::back_insert_iterator<C> i(c);
     std::back_insert_iterator<C>& r = ++i;
     assert(&r == &i);
+    return true;
 }
 
 int main(int, char**)
 {
     test(std::vector<int>());
     test(nasty_vector<int>());
-
+#if TEST_STD_VER >= 20
+    test(ConstexprFixedCapacityDeque<int, 10>());
+    static_assert(test(ConstexprFixedCapacityDeque<int, 10>()));
+#endif
     return 0;
 }

libcxx/test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.insert.iter.op=/lv_value.pass.cpp

 //   back_insert_iterator<Cont>&
 //   operator=(const Cont::value_type& value);
 
 #include <iterator>
 #include <vector>
 #include <cassert>
 
 #include "test_macros.h"
+#include "test_constexpr_container.h"
 
 template <class C>
-void
+TEST_CONSTEXPR_CXX14 bool
 test(C c)
 {
     const typename C::value_type v = typename C::value_type();
     std::back_insert_iterator<C> i(c);
     i = v;
     assert(c.back() == v);
+    return true;
 }
 
 class Copyable
 {
     int data_;
 public:
     Copyable() : data_(0) {}
     ~Copyable() {data_ = -1;}
 
     friend bool operator==(const Copyable& x, const Copyable& y)
         {return x.data_ == y.data_;}
 };
 
 int main(int, char**)
 {
     test(std::vector<Copyable>());
-
+#if TEST_STD_VER >= 20
+    test(ConstexprFixedCapacityDeque<int, 10>());
+    static_assert(test(ConstexprFixedCapacityDeque<int, 10>()));
+#endif
     return 0;
 }

libcxx/test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.insert.iter.op=/rv_value.pass.cpp

 
 #include <iterator>
 
 #include <vector>
 #include <memory>
 #include <cassert>
 
 #include "test_macros.h"
+#include "test_constexpr_container.h"
 
 template <class C>
-void
+TEST_CONSTEXPR_CXX14 bool
 test(C c)
 {
     std::back_insert_iterator<C> i(c);
     i = typename C::value_type();
     assert(c.back() == typename C::value_type());
+    return true;
 }
 
 int main(int, char**)
 {
     test(std::vector<std::unique_ptr<int> >());
-
+#if TEST_STD_VER >= 20
+    test(ConstexprFixedCapacityDeque<int, 10>());
+    static_assert(test(ConstexprFixedCapacityDeque<int, 10>()));
+#endif
     return 0;
 }

libcxx/test/std/iterators/predef.iterators/insert.iterators/back.insert.iter.ops/back.insert.iter.op_astrk/test.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <iterator>
 
 // back_insert_iterator
 
 // back_insert_iterator<Cont>& operator*();
 
+#include <cassert>
 #include <iterator>
 #include <vector>
-#include <cassert>
-#include "nasty_containers.h"
 
 #include "test_macros.h"
+#include "nasty_containers.h"
+#include "test_constexpr_container.h"
 
 template <class C>
-void
+TEST_CONSTEXPR_CXX20 bool
 test(C c)
 {
     std::back_insert_iterator<C> i(c);
     std::back_insert_iterator<C>& r = *i;
     assert(&r == &i);
+    return true;
 }
 
 int main(int, char**)
 {
     test(std::vector<int>());
     test(nasty_vector<int>());
-
+#if TEST_STD_VER >= 20
+    test(ConstexprFixedCapacityDeque<int, 10>());
+    static_assert(test(ConstexprFixedCapacityDeque<int, 10>()));
+#endif
     return 0;
 }

libcxx/test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.insert.iter.cons/container.compile.fail.cpp

 
 // test for explicit
 
 #include <iterator>
 #include <list>
 
 int main(int, char**)
 {
-    std::front_insert_iterator<std::list<int> > i = std::list<int>();
+    std::list<int> l;
+    std::front_insert_iterator<std::list<int> > i = l;
 
   return 0;
 }

libcxx/test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.insert.iter.cons/container.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <iterator>
 
 // front_insert_iterator
 
 // explicit front_insert_iterator(Cont& x);
 
 #include <iterator>
 #include <list>
-#include "nasty_containers.h"
 
 #include "test_macros.h"
+#include "nasty_containers.h"
+#include "test_constexpr_container.h"
 
 template <class C>
-void
+TEST_CONSTEXPR_CXX20 bool
 test(C c)
 {
     std::front_insert_iterator<C> i(c);
+    return true;
 }
 
 int main(int, char**)
 {
     test(std::list<int>());
     test(nasty_list<int>());
-
+#if TEST_STD_VER >= 20
+    test(ConstexprFixedCapacityDeque<int, 10>());
+    static_assert(test(ConstexprFixedCapacityDeque<int, 10>()));
+#endif
     return 0;
 }

libcxx/test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.insert.iter.op++/post.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <iterator>
 
 // front_insert_iterator
 
 // front_insert_iterator<Cont> operator++(int);
 
+#include <cassert>
 #include <iterator>
 #include <list>
-#include <cassert>
-#include "nasty_containers.h"
 
 #include "test_macros.h"
+#include "nasty_containers.h"
+#include "test_constexpr_container.h"
 
 template <class C>
-void
+TEST_CONSTEXPR_CXX20 bool
 test(C c)
 {
     std::front_insert_iterator<C> i(c);
     std::front_insert_iterator<C> r = i++;
     r = 0;
     assert(c.size() == 1);
     assert(c.back() == 0);
+    return true;
 }
 
 int main(int, char**)
 {
     test(std::list<int>());
     test(nasty_list<int>());
-
+#if TEST_STD_VER >= 20
+    test(ConstexprFixedCapacityDeque<int, 10>());
+    static_assert(test(ConstexprFixedCapacityDeque<int, 10>()));
+#endif
     return 0;
 }

libcxx/test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.insert.iter.op++/pre.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <iterator>
 
 // front_insert_iterator
 
 // front_insert_iterator<Cont>& operator++();
 
+#include <cassert>
 #include <iterator>
 #include <list>
-#include <cassert>
-#include "nasty_containers.h"
 
 #include "test_macros.h"
+#include "nasty_containers.h"
+#include "test_constexpr_container.h"
 
 template <class C>
-void
+TEST_CONSTEXPR_CXX20 bool
 test(C c)
 {
     std::front_insert_iterator<C> i(c);
     std::front_insert_iterator<C>& r = ++i;
     assert(&r == &i);
+    return true;
 }
 
 int main(int, char**)
 {
     test(std::list<int>());
     test(nasty_list<int>());
-
+#if TEST_STD_VER >= 20
+    test(ConstexprFixedCapacityDeque<int, 10>());
+    static_assert(test(ConstexprFixedCapacityDeque<int, 10>()));
+#endif
     return 0;
 }

libcxx/test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.insert.iter.op=/lv_value.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <iterator>
 
 // front_insert_iterator
 
 // front_insert_iterator<Cont>&
 //   operator=(const Cont::value_type& value);
 
+#include <cassert>
 #include <iterator>
 #include <list>
-#include <cassert>
-#include "nasty_containers.h"
 
 #include "test_macros.h"
+#include "nasty_containers.h"
+#include "test_constexpr_container.h"
 
 template <class C>
-void
+TEST_CONSTEXPR_CXX20 bool
 test(C c)
 {
     const typename C::value_type v = typename C::value_type();
     std::front_insert_iterator<C> i(c);
     i = v;
     assert(c.front() == v);
+    return true;
 }
 
 class Copyable
 {
     int data_;
 public:
     Copyable() : data_(0) {}
     ~Copyable() {data_ = -1;}
 
     friend bool operator==(const Copyable& x, const Copyable& y)
         {return x.data_ == y.data_;}
 };
 
 int main(int, char**)
 {
     test(std::list<Copyable>());
     test(nasty_list<Copyable>());
-
+#if TEST_STD_VER >= 20
+    test(ConstexprFixedCapacityDeque<int, 10>());
+    static_assert(test(ConstexprFixedCapacityDeque<int, 10>()));
+#endif
     return 0;
 }

libcxx/test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.insert.iter.op=/rv_value.pass.cpp

 
 // <iterator>
 
 // front_insert_iterator
 
 // front_insert_iterator<Cont>&
 //   operator=(Cont::value_type&& value);
 
+#include <cassert>
 #include <iterator>
 #include <list>
 #include <memory>
-#include <cassert>
 
 #include "test_macros.h"
+#include "test_constexpr_container.h"
 
 template <class C>
-void
+TEST_CONSTEXPR_CXX20 bool
 test(C c)
 {
     std::front_insert_iterator<C> i(c);
     i = typename C::value_type();
     assert(c.front() == typename C::value_type());
+    return true;
 }
 
 int main(int, char**)
 {
     test(std::list<std::unique_ptr<int> >());
-
+#if TEST_STD_VER >= 20
+    test(ConstexprFixedCapacityDeque<int, 10>());
+    static_assert(test(ConstexprFixedCapacityDeque<int, 10>()));
+#endif
     return 0;
 }

libcxx/test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.insert.iter.op_astrk/test.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <iterator>
 
 // front_insert_iterator
 
 // front_insert_iterator<Cont>& operator*();
 
+#include <cassert>
 #include <iterator>
 #include <list>
-#include <cassert>
-#include "nasty_containers.h"
 
 #include "test_macros.h"
+#include "nasty_containers.h"
+#include "test_constexpr_container.h"
 
 template <class C>
-void
+TEST_CONSTEXPR_CXX20 bool
 test(C c)
 {
     std::front_insert_iterator<C> i(c);
     std::front_insert_iterator<C>& r = *i;
     assert(&r == &i);
+    return true;
 }
 
 int main(int, char**)
 {
     test(std::list<int>());
     test(nasty_list<int>());
-
+#if TEST_STD_VER >= 20
+    test(ConstexprFixedCapacityDeque<int, 10>());
+    static_assert(test(ConstexprFixedCapacityDeque<int, 10>()));
+#endif
     return 0;
 }

libcxx/test/std/iterators/predef.iterators/insert.iterators/front.insert.iter.ops/front.inserter/test.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <iterator>
 
 // template <BackInsertionContainer Cont>
 //   front_insert_iterator<Cont>
 //   front_inserter(Cont& x);
 
+#include <cassert>
 #include <iterator>
 #include <list>
-#include <cassert>
-#include "nasty_containers.h"
 
 #include "test_macros.h"
+#include "nasty_containers.h"
+#include "test_constexpr_container.h"
 
 template <class C>
-void
+TEST_CONSTEXPR_CXX20 bool
 test(C c)
 {
     std::front_insert_iterator<C> i = std::front_inserter(c);
     i = 0;
     assert(c.size() == 1);
     assert(c.front() == 0);
+    return true;
 }
 
 int main(int, char**)
 {
     test(std::list<int>());
     test(nasty_list<int>());
-
+#if TEST_STD_VER >= 20
+    test(ConstexprFixedCapacityDeque<int, 10>());
+    static_assert(test(ConstexprFixedCapacityDeque<int, 10>()));
+#endif
     return 0;
 }

libcxx/test/std/iterators/predef.iterators/insert.iterators/insert.iter.ops/insert.iter.cons/test.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <iterator>
 
 // insert_iterator
 
 // insert_iterator(Cont& x, Cont::iterator i);
 
 #include <iterator>
 #include <vector>
-#include "nasty_containers.h"
 
 #include "test_macros.h"
+#include "nasty_containers.h"
+#include "test_constexpr_container.h"
 
 template <class C>
-void
+TEST_CONSTEXPR_CXX20 bool
 test(C c)
 {
     std::insert_iterator<C> i(c, c.begin());
+    return true;
 }
 
 int main(int, char**)
 {
     test(std::vector<int>());
     test(nasty_vector<int>());
-
+#if TEST_STD_VER >= 20
+    test(ConstexprFixedCapacityDeque<int, 10>());
+    static_assert(test(ConstexprFixedCapacityDeque<int, 10>()));
+#endif
     return 0;
 }

libcxx/test/std/iterators/predef.iterators/insert.iterators/insert.iter.ops/insert.iter.op++/post.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <iterator>
 
 // insert_iterator
 
 // insert_iterator<Cont> operator++(int);
 
+#include <cassert>
 #include <iterator>
 #include <vector>
-#include <cassert>
-#include "nasty_containers.h"
 
 #include "test_macros.h"
+#include "nasty_containers.h"
+#include "test_constexpr_container.h"
 
 template <class C>
-void
+TEST_CONSTEXPR_CXX20 bool
 test(C c)
 {
     std::insert_iterator<C> i(c, c.end());
     std::insert_iterator<C> r = i++;
     r = 0;
     assert(c.size() == 1);
     assert(c.back() == 0);
+    return true;
 }
 
 int main(int, char**)
 {
     test(std::vector<int>());
     test(nasty_vector<int>());
-
+#if TEST_STD_VER >= 20
+    test(ConstexprFixedCapacityDeque<int, 10>());
+    static_assert(test(ConstexprFixedCapacityDeque<int, 10>()));
+#endif
     return 0;
 }

libcxx/test/std/iterators/predef.iterators/insert.iterators/insert.iter.ops/insert.iter.op++/pre.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <iterator>
 
 // insert_iterator
 
 // insert_iterator<Cont>& operator++();
 
+#include <cassert>
 #include <iterator>
 #include <vector>
-#include <cassert>
-#include "nasty_containers.h"
 
 #include "test_macros.h"
+#include "nasty_containers.h"
+#include "test_constexpr_container.h"
 
 template <class C>
-void
+TEST_CONSTEXPR_CXX20 bool
 test(C c)
 {
     std::insert_iterator<C> i(c, c.end());
     std::insert_iterator<C>& r = ++i;
     assert(&r == &i);
+    return true;
 }
 
 int main(int, char**)
 {
     test(std::vector<int>());
     test(nasty_vector<int>());
-
+#if TEST_STD_VER >= 20
+    test(ConstexprFixedCapacityDeque<int, 10>());
+    static_assert(test(ConstexprFixedCapacityDeque<int, 10>()));
+#endif
     return 0;
 }

libcxx/test/std/iterators/predef.iterators/insert.iterators/insert.iter.ops/insert.iter.op_astrk/test.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <iterator>
 
 // insert_iterator
 
 // insert_iterator<Cont>& operator*();
 
+#include <cassert>
 #include <iterator>
 #include <vector>
-#include <cassert>
-#include "nasty_containers.h"
 
 #include "test_macros.h"
+#include "nasty_containers.h"
+#include "test_constexpr_container.h"
 
 template <class C>
-void
+TEST_CONSTEXPR_CXX20 bool
 test(C c)
 {
     std::insert_iterator<C> i(c, c.end());
     std::insert_iterator<C>& r = *i;
     assert(&r == &i);
+    return true;
 }
 
 int main(int, char**)
 {
     test(std::vector<int>());
     test(nasty_vector<int>());
-
+#if TEST_STD_VER >= 20
+    test(ConstexprFixedCapacityDeque<int, 10>());
+    static_assert(test(ConstexprFixedCapacityDeque<int, 10>()));
+#endif
     return 0;
 }

libcxx/test/std/iterators/predef.iterators/insert.iterators/insert.iter.ops/inserter/test.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <iterator>
 
 // template <InsertionContainer Cont>
 //   insert_iterator<Cont>
 //   inserter(Cont& x, Cont::iterator i);
 
+#include <cassert>
 #include <iterator>
 #include <vector>
-#include <cassert>
-#include "nasty_containers.h"
 
 #include "test_macros.h"
+#include "nasty_containers.h"
+#include "test_constexpr_container.h"
 
 template <class C>
-void
+TEST_CONSTEXPR_CXX20 bool
 test(C c)
 {
     std::insert_iterator<C> i = std::inserter(c, c.end());
     i = 0;
     assert(c.size() == 1);
     assert(c.back() == 0);
+    return true;
 }
 
 int main(int, char**)
 {
     test(std::vector<int>());
     test(nasty_vector<int>());
-
+#if TEST_STD_VER >= 20
+    test(ConstexprFixedCapacityDeque<int, 10>());
+    static_assert(test(ConstexprFixedCapacityDeque<int, 10>()));
+#endif
     return 0;
 }

libcxx/test/std/language.support/support.limits/support.limits.general/iterator.version.pass.cpp

 
 # ifndef __cpp_lib_array_constexpr
 #   error "__cpp_lib_array_constexpr should be defined in c++20"
 # endif
 # if __cpp_lib_array_constexpr != 201811L
 #   error "__cpp_lib_array_constexpr should have the value 201811L in c++20"
 # endif
 
-# if !defined(_LIBCPP_VERSION)
-#   ifndef __cpp_lib_constexpr_iterator
-#     error "__cpp_lib_constexpr_iterator should be defined in c++20"
-#   endif
-#   if __cpp_lib_constexpr_iterator != 201811L
-#     error "__cpp_lib_constexpr_iterator should have the value 201811L in c++20"
-#   endif
-# else // _LIBCPP_VERSION
-#   ifdef __cpp_lib_constexpr_iterator
-#     error "__cpp_lib_constexpr_iterator should not be defined because it is unimplemented in libc++!"
-#   endif
-# endif
+# ifndef __cpp_lib_constexpr_iterator
+#   error "__cpp_lib_constexpr_iterator should be defined in c++20"
+# endif
+# if __cpp_lib_constexpr_iterator != 201811L
+#   error "__cpp_lib_constexpr_iterator should have the value 201811L in c++20"
+# endif
 
 # ifndef __cpp_lib_make_reverse_iterator
 #   error "__cpp_lib_make_reverse_iterator should be defined in c++20"
 # endif
 # if __cpp_lib_make_reverse_iterator != 201402L
 #   error "__cpp_lib_make_reverse_iterator should have the value 201402L in c++20"
 # endif
 

 
 # ifndef __cpp_lib_array_constexpr
 #   error "__cpp_lib_array_constexpr should be defined in c++2b"
 # endif
 # if __cpp_lib_array_constexpr != 201811L
 #   error "__cpp_lib_array_constexpr should have the value 201811L in c++2b"
 # endif
 
-# if !defined(_LIBCPP_VERSION)
-#   ifndef __cpp_lib_constexpr_iterator
-#     error "__cpp_lib_constexpr_iterator should be defined in c++2b"
-#   endif
-#   if __cpp_lib_constexpr_iterator != 201811L
-#     error "__cpp_lib_constexpr_iterator should have the value 201811L in c++2b"
-#   endif
-# else // _LIBCPP_VERSION
-#   ifdef __cpp_lib_constexpr_iterator
-#     error "__cpp_lib_constexpr_iterator should not be defined because it is unimplemented in libc++!"
-#   endif
-# endif
+# ifndef __cpp_lib_constexpr_iterator
+#   error "__cpp_lib_constexpr_iterator should be defined in c++2b"
+# endif
+# if __cpp_lib_constexpr_iterator != 201811L
+#   error "__cpp_lib_constexpr_iterator should have the value 201811L in c++2b"
+# endif
 
 # ifndef __cpp_lib_make_reverse_iterator
 #   error "__cpp_lib_make_reverse_iterator should be defined in c++2b"
 # endif
 # if __cpp_lib_make_reverse_iterator != 201402L
 #   error "__cpp_lib_make_reverse_iterator should have the value 201402L in c++2b"
 # endif
 

libcxx/test/std/language.support/support.limits/support.limits.general/string.version.pass.cpp

 
 // <string>
 
 // Test the feature test macros defined by <string>
 
 /*  Constant                                      Value
     __cpp_lib_allocator_traits_is_always_equal    201411L [C++17]
     __cpp_lib_char8_t                             201811L [C++20]
-    __cpp_lib_constexpr_string                    201907L [C++20]
+    __cpp_lib_constexpr_string                    201811L [C++20]
     __cpp_lib_erase_if                            202002L [C++20]
     __cpp_lib_nonmember_container_access          201411L [C++17]
     __cpp_lib_starts_ends_with                    201711L [C++20]
     __cpp_lib_string_contains                     202011L [C++2b]
     __cpp_lib_string_udls                         201304L [C++14]
     __cpp_lib_string_view                         201606L [C++17]
                                                   201803L [C++20]
 */

 #     error "__cpp_lib_char8_t should have the value 201811L in c++20"
 #   endif
 # else
 #   ifdef __cpp_lib_char8_t
 #     error "__cpp_lib_char8_t should not be defined when defined(__cpp_char8_t) is not defined!"
 #   endif
 # endif
 
-# if !defined(_LIBCPP_VERSION)
-#   ifndef __cpp_lib_constexpr_string
-#     error "__cpp_lib_constexpr_string should be defined in c++20"
-#   endif
-#   if __cpp_lib_constexpr_string != 201907L
-#     error "__cpp_lib_constexpr_string should have the value 201907L in c++20"
-#   endif
-# else // _LIBCPP_VERSION
-#   ifdef __cpp_lib_constexpr_string
-#     error "__cpp_lib_constexpr_string should not be defined because it is unimplemented in libc++!"
-#   endif
+# ifndef __cpp_lib_constexpr_string
+#   error "__cpp_lib_constexpr_string should be defined in c++20"
+# endif
+# if __cpp_lib_constexpr_string != 201811L
+#   error "__cpp_lib_constexpr_string should have the value 201811L in c++20"
 # endif
 
 # ifndef __cpp_lib_erase_if
 #   error "__cpp_lib_erase_if should be defined in c++20"
 # endif
 # if __cpp_lib_erase_if != 202002L
 #   error "__cpp_lib_erase_if should have the value 202002L in c++20"
 # endif

 #     error "__cpp_lib_char8_t should have the value 201811L in c++2b"
 #   endif
 # else
 #   ifdef __cpp_lib_char8_t
 #     error "__cpp_lib_char8_t should not be defined when defined(__cpp_char8_t) is not defined!"
 #   endif
 # endif
 
-# if !defined(_LIBCPP_VERSION)
-#   ifndef __cpp_lib_constexpr_string
-#     error "__cpp_lib_constexpr_string should be defined in c++2b"
-#   endif
-#   if __cpp_lib_constexpr_string != 201907L
-#     error "__cpp_lib_constexpr_string should have the value 201907L in c++2b"
-#   endif
-# else // _LIBCPP_VERSION
-#   ifdef __cpp_lib_constexpr_string
-#     error "__cpp_lib_constexpr_string should not be defined because it is unimplemented in libc++!"
-#   endif
+# ifndef __cpp_lib_constexpr_string
+#   error "__cpp_lib_constexpr_string should be defined in c++2b"
+# endif
+# if __cpp_lib_constexpr_string != 201811L
+#   error "__cpp_lib_constexpr_string should have the value 201811L in c++2b"
 # endif
 
 # ifndef __cpp_lib_erase_if
 #   error "__cpp_lib_erase_if should be defined in c++2b"
 # endif
 # if __cpp_lib_erase_if != 202002L
 #   error "__cpp_lib_erase_if should have the value 202002L in c++2b"
 # endif

libcxx/test/std/language.support/support.limits/support.limits.general/string_view.version.pass.cpp

 #     error "__cpp_lib_char8_t should have the value 201811L in c++20"
 #   endif
 # else
 #   ifdef __cpp_lib_char8_t
 #     error "__cpp_lib_char8_t should not be defined when defined(__cpp_char8_t) is not defined!"
 #   endif
 # endif
 
-# if !defined(_LIBCPP_VERSION)
-#   ifndef __cpp_lib_constexpr_string_view
-#     error "__cpp_lib_constexpr_string_view should be defined in c++20"
-#   endif
-#   if __cpp_lib_constexpr_string_view != 201811L
-#     error "__cpp_lib_constexpr_string_view should have the value 201811L in c++20"
-#   endif
-# else // _LIBCPP_VERSION
-#   ifdef __cpp_lib_constexpr_string_view
-#     error "__cpp_lib_constexpr_string_view should not be defined because it is unimplemented in libc++!"
-#   endif
-# endif
+# ifndef __cpp_lib_constexpr_string_view
+#   error "__cpp_lib_constexpr_string_view should be defined in c++20"
+# endif
+# if __cpp_lib_constexpr_string_view != 201811L
+#   error "__cpp_lib_constexpr_string_view should have the value 201811L in c++20"
+# endif
 
 # ifndef __cpp_lib_starts_ends_with
 #   error "__cpp_lib_starts_ends_with should be defined in c++20"
 # endif
 # if __cpp_lib_starts_ends_with != 201711L
 #   error "__cpp_lib_starts_ends_with should have the value 201711L in c++20"
 # endif
 

 #     error "__cpp_lib_char8_t should have the value 201811L in c++2b"
 #   endif
 # else
 #   ifdef __cpp_lib_char8_t
 #     error "__cpp_lib_char8_t should not be defined when defined(__cpp_char8_t) is not defined!"
 #   endif
 # endif
 
-# if !defined(_LIBCPP_VERSION)
-#   ifndef __cpp_lib_constexpr_string_view
-#     error "__cpp_lib_constexpr_string_view should be defined in c++2b"
-#   endif
-#   if __cpp_lib_constexpr_string_view != 201811L
-#     error "__cpp_lib_constexpr_string_view should have the value 201811L in c++2b"
-#   endif
-# else // _LIBCPP_VERSION
-#   ifdef __cpp_lib_constexpr_string_view
-#     error "__cpp_lib_constexpr_string_view should not be defined because it is unimplemented in libc++!"
-#   endif
-# endif
+# ifndef __cpp_lib_constexpr_string_view
+#   error "__cpp_lib_constexpr_string_view should be defined in c++2b"
+# endif
+# if __cpp_lib_constexpr_string_view != 201811L
+#   error "__cpp_lib_constexpr_string_view should have the value 201811L in c++2b"
+# endif
 
 # ifndef __cpp_lib_starts_ends_with
 #   error "__cpp_lib_starts_ends_with should be defined in c++2b"
 # endif
 # if __cpp_lib_starts_ends_with != 201711L
 #   error "__cpp_lib_starts_ends_with should have the value 201711L in c++2b"
 # endif
 

libcxx/test/std/language.support/support.limits/support.limits.general/tuple.version.pass.cpp

 
 # ifndef __cpp_lib_apply
 #   error "__cpp_lib_apply should be defined in c++20"
 # endif
 # if __cpp_lib_apply != 201603L
 #   error "__cpp_lib_apply should have the value 201603L in c++20"
 # endif
 
-# if !defined(_LIBCPP_VERSION)
-#   ifndef __cpp_lib_constexpr_tuple
-#     error "__cpp_lib_constexpr_tuple should be defined in c++20"
-#   endif
-#   if __cpp_lib_constexpr_tuple != 201811L
-#     error "__cpp_lib_constexpr_tuple should have the value 201811L in c++20"
-#   endif
-# else // _LIBCPP_VERSION
-#   ifdef __cpp_lib_constexpr_tuple
-#     error "__cpp_lib_constexpr_tuple should not be defined because it is unimplemented in libc++!"
-#   endif
-# endif
+# ifndef __cpp_lib_constexpr_tuple
+#   error "__cpp_lib_constexpr_tuple should be defined in c++20"
+# endif
+# if __cpp_lib_constexpr_tuple != 201811L
+#   error "__cpp_lib_constexpr_tuple should have the value 201811L in c++20"
+# endif
 
 # ifndef __cpp_lib_make_from_tuple
 #   error "__cpp_lib_make_from_tuple should be defined in c++20"
 # endif
 # if __cpp_lib_make_from_tuple != 201606L
 #   error "__cpp_lib_make_from_tuple should have the value 201606L in c++20"
 # endif
 

 
 # ifndef __cpp_lib_apply
 #   error "__cpp_lib_apply should be defined in c++2b"
 # endif
 # if __cpp_lib_apply != 201603L
 #   error "__cpp_lib_apply should have the value 201603L in c++2b"
 # endif
 
-# if !defined(_LIBCPP_VERSION)
-#   ifndef __cpp_lib_constexpr_tuple
-#     error "__cpp_lib_constexpr_tuple should be defined in c++2b"
-#   endif
-#   if __cpp_lib_constexpr_tuple != 201811L
-#     error "__cpp_lib_constexpr_tuple should have the value 201811L in c++2b"
-#   endif
-# else // _LIBCPP_VERSION
-#   ifdef __cpp_lib_constexpr_tuple
-#     error "__cpp_lib_constexpr_tuple should not be defined because it is unimplemented in libc++!"
-#   endif
-# endif
+# ifndef __cpp_lib_constexpr_tuple
+#   error "__cpp_lib_constexpr_tuple should be defined in c++2b"
+# endif
+# if __cpp_lib_constexpr_tuple != 201811L
+#   error "__cpp_lib_constexpr_tuple should have the value 201811L in c++2b"
+# endif
 
 # ifndef __cpp_lib_make_from_tuple
 #   error "__cpp_lib_make_from_tuple should be defined in c++2b"
 # endif
 # if __cpp_lib_make_from_tuple != 201606L
 #   error "__cpp_lib_make_from_tuple should have the value 201606L in c++2b"
 # endif
 

libcxx/test/std/language.support/support.limits/support.limits.general/version.version.pass.cpp

/*  Constant                                       Value
     __cpp_lib_concepts                             202002L [C++20]
     __cpp_lib_constexpr_algorithms                 201806L [C++20]
     __cpp_lib_constexpr_complex                    201711L [C++20]
     __cpp_lib_constexpr_dynamic_alloc              201907L [C++20]
     __cpp_lib_constexpr_functional                 201907L [C++20]
     __cpp_lib_constexpr_iterator                   201811L [C++20]
     __cpp_lib_constexpr_memory                     201811L [C++20]
     __cpp_lib_constexpr_numeric                    201911L [C++20]
-    __cpp_lib_constexpr_string                     201907L [C++20]
+    __cpp_lib_constexpr_string                     201811L [C++20]
     __cpp_lib_constexpr_string_view                201811L [C++20]
     __cpp_lib_constexpr_tuple                      201811L [C++20]
     __cpp_lib_constexpr_utility                    201811L [C++20]
     __cpp_lib_constexpr_vector                     201907L [C++20]
     __cpp_lib_coroutine                            201902L [C++20]
     __cpp_lib_destroying_delete                    201806L [C++20]
     __cpp_lib_enable_shared_from_this              201603L [C++17]
     __cpp_lib_endian                               201907L [C++20]

 
 # ifndef __cpp_lib_constexpr_functional
 #   error "__cpp_lib_constexpr_functional should be defined in c++20"
 # endif
 # if __cpp_lib_constexpr_functional != 201907L
 #   error "__cpp_lib_constexpr_functional should have the value 201907L in c++20"
 # endif
 
-# if !defined(_LIBCPP_VERSION)
-#   ifndef __cpp_lib_constexpr_iterator
-#     error "__cpp_lib_constexpr_iterator should be defined in c++20"
-#   endif
-#   if __cpp_lib_constexpr_iterator != 201811L
-#     error "__cpp_lib_constexpr_iterator should have the value 201811L in c++20"
-#   endif
-# else // _LIBCPP_VERSION
-#   ifdef __cpp_lib_constexpr_iterator
-#     error "__cpp_lib_constexpr_iterator should not be defined because it is unimplemented in libc++!"
-#   endif
-# endif
+# ifndef __cpp_lib_constexpr_iterator
+#   error "__cpp_lib_constexpr_iterator should be defined in c++20"
+# endif
+# if __cpp_lib_constexpr_iterator != 201811L
+#   error "__cpp_lib_constexpr_iterator should have the value 201811L in c++20"
+# endif
 
 # ifndef __cpp_lib_constexpr_memory
 #   error "__cpp_lib_constexpr_memory should be defined in c++20"
 # endif
 # if __cpp_lib_constexpr_memory != 201811L
 #   error "__cpp_lib_constexpr_memory should have the value 201811L in c++20"
 # endif
 
 # ifndef __cpp_lib_constexpr_numeric
 #   error "__cpp_lib_constexpr_numeric should be defined in c++20"
 # endif
 # if __cpp_lib_constexpr_numeric != 201911L
 #   error "__cpp_lib_constexpr_numeric should have the value 201911L in c++20"
 # endif
 
-# if !defined(_LIBCPP_VERSION)
-#   ifndef __cpp_lib_constexpr_string
-#     error "__cpp_lib_constexpr_string should be defined in c++20"
-#   endif
-#   if __cpp_lib_constexpr_string != 201907L
-#     error "__cpp_lib_constexpr_string should have the value 201907L in c++20"
-#   endif
-# else // _LIBCPP_VERSION
-#   ifdef __cpp_lib_constexpr_string
-#     error "__cpp_lib_constexpr_string should not be defined because it is unimplemented in libc++!"
-#   endif
+# ifndef __cpp_lib_constexpr_string
+#   error "__cpp_lib_constexpr_string should be defined in c++20"
+# endif
+# if __cpp_lib_constexpr_string != 201811L
+#   error "__cpp_lib_constexpr_string should have the value 201811L in c++20"
 # endif
 
-# if !defined(_LIBCPP_VERSION)
-#   ifndef __cpp_lib_constexpr_string_view
-#     error "__cpp_lib_constexpr_string_view should be defined in c++20"
-#   endif
-#   if __cpp_lib_constexpr_string_view != 201811L
-#     error "__cpp_lib_constexpr_string_view should have the value 201811L in c++20"
-#   endif
-# else // _LIBCPP_VERSION
-#   ifdef __cpp_lib_constexpr_string_view
-#     error "__cpp_lib_constexpr_string_view should not be defined because it is unimplemented in libc++!"
-#   endif
-# endif
+# ifndef __cpp_lib_constexpr_string_view
+#   error "__cpp_lib_constexpr_string_view should be defined in c++20"
+# endif
+# if __cpp_lib_constexpr_string_view != 201811L
+#   error "__cpp_lib_constexpr_string_view should have the value 201811L in c++20"
+# endif
 
-# if !defined(_LIBCPP_VERSION)
-#   ifndef __cpp_lib_constexpr_tuple
-#     error "__cpp_lib_constexpr_tuple should be defined in c++20"
-#   endif
-#   if __cpp_lib_constexpr_tuple != 201811L
-#     error "__cpp_lib_constexpr_tuple should have the value 201811L in c++20"
-#   endif
-# else // _LIBCPP_VERSION
-#   ifdef __cpp_lib_constexpr_tuple
-#     error "__cpp_lib_constexpr_tuple should not be defined because it is unimplemented in libc++!"
-#   endif
-# endif
+# ifndef __cpp_lib_constexpr_tuple
+#   error "__cpp_lib_constexpr_tuple should be defined in c++20"
+# endif
+# if __cpp_lib_constexpr_tuple != 201811L
+#   error "__cpp_lib_constexpr_tuple should have the value 201811L in c++20"
+# endif
 
 # ifndef __cpp_lib_constexpr_utility
 #   error "__cpp_lib_constexpr_utility should be defined in c++20"
 # endif
 # if __cpp_lib_constexpr_utility != 201811L
 #   error "__cpp_lib_constexpr_utility should have the value 201811L in c++20"
 # endif
 

 
 # ifndef __cpp_lib_constexpr_functional
 #   error "__cpp_lib_constexpr_functional should be defined in c++2b"
 # endif
 # if __cpp_lib_constexpr_functional != 201907L
 #   error "__cpp_lib_constexpr_functional should have the value 201907L in c++2b"
 # endif
 
-# if !defined(_LIBCPP_VERSION)
-#   ifndef __cpp_lib_constexpr_iterator
-#     error "__cpp_lib_constexpr_iterator should be defined in c++2b"
-#   endif
-#   if __cpp_lib_constexpr_iterator != 201811L
-#     error "__cpp_lib_constexpr_iterator should have the value 201811L in c++2b"
-#   endif
-# else // _LIBCPP_VERSION
-#   ifdef __cpp_lib_constexpr_iterator
-#     error "__cpp_lib_constexpr_iterator should not be defined because it is unimplemented in libc++!"
-#   endif
-# endif
+# ifndef __cpp_lib_constexpr_iterator
+#   error "__cpp_lib_constexpr_iterator should be defined in c++2b"
+# endif
+# if __cpp_lib_constexpr_iterator != 201811L
+#   error "__cpp_lib_constexpr_iterator should have the value 201811L in c++2b"
+# endif
 
 # ifndef __cpp_lib_constexpr_memory
 #   error "__cpp_lib_constexpr_memory should be defined in c++2b"
 # endif
 # if __cpp_lib_constexpr_memory != 201811L
 #   error "__cpp_lib_constexpr_memory should have the value 201811L in c++2b"
 # endif
 
 # ifndef __cpp_lib_constexpr_numeric
 #   error "__cpp_lib_constexpr_numeric should be defined in c++2b"
 # endif
 # if __cpp_lib_constexpr_numeric != 201911L
 #   error "__cpp_lib_constexpr_numeric should have the value 201911L in c++2b"
 # endif
 
-# if !defined(_LIBCPP_VERSION)
-#   ifndef __cpp_lib_constexpr_string
-#     error "__cpp_lib_constexpr_string should be defined in c++2b"
-#   endif
-#   if __cpp_lib_constexpr_string != 201907L
-#     error "__cpp_lib_constexpr_string should have the value 201907L in c++2b"
-#   endif
-# else // _LIBCPP_VERSION
-#   ifdef __cpp_lib_constexpr_string
-#     error "__cpp_lib_constexpr_string should not be defined because it is unimplemented in libc++!"
-#   endif
+# ifndef __cpp_lib_constexpr_string
+#   error "__cpp_lib_constexpr_string should be defined in c++2b"
+# endif
+# if __cpp_lib_constexpr_string != 201811L
+#   error "__cpp_lib_constexpr_string should have the value 201811L in c++2b"
 # endif
 
-# if !defined(_LIBCPP_VERSION)
-#   ifndef __cpp_lib_constexpr_string_view
-#     error "__cpp_lib_constexpr_string_view should be defined in c++2b"
-#   endif
-#   if __cpp_lib_constexpr_string_view != 201811L
-#     error "__cpp_lib_constexpr_string_view should have the value 201811L in c++2b"
-#   endif
-# else // _LIBCPP_VERSION
-#   ifdef __cpp_lib_constexpr_string_view
-#     error "__cpp_lib_constexpr_string_view should not be defined because it is unimplemented in libc++!"
-#   endif
-# endif
+# ifndef __cpp_lib_constexpr_string_view
+#   error "__cpp_lib_constexpr_string_view should be defined in c++2b"
+# endif
+# if __cpp_lib_constexpr_string_view != 201811L
+#   error "__cpp_lib_constexpr_string_view should have the value 201811L in c++2b"
+# endif
 
-# if !defined(_LIBCPP_VERSION)
-#   ifndef __cpp_lib_constexpr_tuple
-#     error "__cpp_lib_constexpr_tuple should be defined in c++2b"
-#   endif
-#   if __cpp_lib_constexpr_tuple != 201811L
-#     error "__cpp_lib_constexpr_tuple should have the value 201811L in c++2b"
-#   endif
-# else // _LIBCPP_VERSION
-#   ifdef __cpp_lib_constexpr_tuple
-#     error "__cpp_lib_constexpr_tuple should not be defined because it is unimplemented in libc++!"
-#   endif
-# endif
+# ifndef __cpp_lib_constexpr_tuple
+#   error "__cpp_lib_constexpr_tuple should be defined in c++2b"
+# endif
+# if __cpp_lib_constexpr_tuple != 201811L
+#   error "__cpp_lib_constexpr_tuple should have the value 201811L in c++2b"
+# endif
 
 # ifndef __cpp_lib_constexpr_utility
 #   error "__cpp_lib_constexpr_utility should be defined in c++2b"
 # endif
 # if __cpp_lib_constexpr_utility != 201811L
 #   error "__cpp_lib_constexpr_utility should have the value 201811L in c++2b"
 # endif
 

libcxx/test/std/strings/string.view/string.view.ops/copy.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: gcc-10
+//     GCC's __builtin_strlen isn't constexpr yet
+
 // <string_view>
 
 // size_type copy(charT* s, size_type n, size_type pos = 0) const;
 
 // Throws: out_of_range if pos > size().
 // Remarks: Let rlen be the smaller of n and size() - pos.
 // Requires: [s, s+rlen) is a valid range.
 // Effects: Equivalent to std::copy_n(begin() + pos, rlen, s).
#endif
             assert ( dest1[i] == dest2[i] );
     }
     delete [] dest1;
     delete [] dest2;
 }
 
 
 template<typename CharT>
 void test ( const CharT *s ) {
     typedef std::basic_string_view<CharT> string_view_t;
 
     string_view_t sv1 ( s );
 
     test1(sv1,  0, 0);
     test1(sv1,  1, 0);
     test1(sv1, 20, 0);
     test1(sv1, sv1.size(), 0);
     test1(sv1, 20, string_view_t::npos);
 
     test1(sv1,   0, 3);
     test1(sv1,   2, 3);
     test1(sv1, 100, 3);
     test1(sv1, 100, string_view_t::npos);
 
     test1(sv1, sv1.size(), string_view_t::npos);
 
     test1(sv1, sv1.size() + 1, 0);
     test1(sv1, sv1.size() + 1, 1);
     test1(sv1, sv1.size() + 1, string_view_t::npos);
+}
 
+template<typename CharT>
+TEST_CONSTEXPR_CXX20 bool test_constexpr_copy(const CharT *abcde, const CharT *ghijk, const CharT *bcdjk)
+{
+    CharT buf[6] = {};
+    std::basic_string_view<CharT> lval(ghijk); lval.copy(buf, 6);
+    std::basic_string_view<CharT>(abcde).copy(buf, 3, 1);
+    assert(std::basic_string_view<CharT>(buf) == bcdjk);
+    return true;
 }
 
 int main(int, char**) {
     test ( "ABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDE" );
     test ( "ABCDE");
     test ( "a" );
     test ( "" );
 
     test ( L"ABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDE" );
     test ( L"ABCDE" );
     test ( L"a" );
     test ( L"" );
 
 #if TEST_STD_VER >= 11
     test ( u"ABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDE" );
     test ( u"ABCDE" );
     test ( u"a" );
     test ( u"" );
 
     test ( U"ABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDEABCDE" );
     test ( U"ABCDE" );
     test ( U"a" );
     test ( U"" );
 #endif
 
+    test_constexpr_copy("ABCDE", "GHIJK", "BCDJK");
+    test_constexpr_copy(L"ABCDE", L"GHIJK", L"BCDJK");
+#if TEST_STD_VER >= 11
+    test_constexpr_copy(u"ABCDE", u"GHIJK", u"BCDJK");
+    test_constexpr_copy(U"ABCDE", U"GHIJK", U"BCDJK");
+#endif
+#if TEST_STD_VER >= 17
+    test_constexpr_copy(u8"ABCDE", u8"GHIJK", u8"BCDJK");
+#endif
+#if TEST_STD_VER >= 20
+    static_assert(test_constexpr_copy("ABCDE", "GHIJK", "BCDJK"));
+    static_assert(test_constexpr_copy(L"ABCDE", L"GHIJK", L"BCDJK"));
+    static_assert(test_constexpr_copy(u"ABCDE", u"GHIJK", u"BCDJK"));
+    static_assert(test_constexpr_copy(U"ABCDE", U"GHIJK", U"BCDJK"));
+    static_assert(test_constexpr_copy(u8"ABCDE", u8"GHIJK", u8"BCDJK"));
+#endif
+
   return 0;
 }

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.assign/const_pair.pass.cpp

struct NothrowCopyAssignable {
     NothrowCopyAssignable& operator=(NothrowCopyAssignable const&) noexcept { return *this; }
 };
 struct PotentiallyThrowingCopyAssignable {
     PotentiallyThrowingCopyAssignable& operator=(PotentiallyThrowingCopyAssignable const&) { return *this; }
 };
 
 #include "test_macros.h"
 
-int main(int, char**)
+TEST_CONSTEXPR_CXX20
+bool test()
 {
     {
         typedef std::pair<long, char> T0;
         typedef std::tuple<long long, short> T1;
         T0 t0(2, 'a');
         T1 t1;
         t1 = t0;
         assert(std::get<0>(t1) == 2);
         assert(std::get<1>(t1) == short('a'));
     }
+    return true;
+}
+
+int main(int, char**)
+{
+    test();
+#if TEST_STD_VER >= 20
+    static_assert(test());
+#endif
+
     {
         // test that the implicitly generated copy assignment operator
         // is properly deleted
         using T = std::tuple<int, int>;
         using P = std::tuple<std::unique_ptr<int>, std::unique_ptr<int>>;
         static_assert(!std::is_assignable<T&, const P &>::value, "");
     }
     {

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.assign/convert_copy.pass.cpp

 // UNSUPPORTED: c++03
 
 #include <tuple>
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 
-struct B
-{
+struct B {
     int id_;
 
-    explicit B(int i = 0) : id_(i) {}
+    constexpr explicit B(int i = 0) : id_(i) {}
 };
 
-struct D
-    : B
-{
-    explicit D(int i = 0) : B(i) {}
+struct D : B {
+    constexpr explicit D(int i = 0) : B(i) {}
 };
 
 struct NonAssignable {
     NonAssignable& operator=(NonAssignable const&) = delete;
     NonAssignable& operator=(NonAssignable&&) = delete;
 };
 
-struct NothrowCopyAssignable
-{
+struct NothrowCopyAssignable {
     NothrowCopyAssignable& operator=(NothrowCopyAssignable const&) noexcept { return *this; }
 };
 
-struct PotentiallyThrowingCopyAssignable
-{
+struct PotentiallyThrowingCopyAssignable {
     PotentiallyThrowingCopyAssignable& operator=(PotentiallyThrowingCopyAssignable const&) { return *this; }
 };
 
-int main(int, char**)
+TEST_CONSTEXPR_CXX20
+bool test()
 {
     {
         typedef std::tuple<long> T0;
         typedef std::tuple<long long> T1;
         T0 t0(2);
         T1 t1;
         t1 = t0;
         assert(std::get<0>(t1) == 2);
bool test()
         int x = 42;
         int y = 43;
         std::tuple<int&&> t(std::move(x));
         std::tuple<int&> t2(y);
         t = t2;
         assert(std::get<0>(t) == 43);
         assert(&std::get<0>(t) == &x);
     }
+    return true;
+}
+
+int main(int, char**)
+{
+    test();
+#if TEST_STD_VER >= 20
+    static_assert(test());
+#endif
+
     {
         using T = std::tuple<int, NonAssignable>;
         using U = std::tuple<NonAssignable, int>;
         static_assert(!std::is_assignable<T&, U const&>::value, "");
         static_assert(!std::is_assignable<U&, T const&>::value, "");
     }
     {
         typedef std::tuple<NothrowCopyAssignable, long> T0;
         typedef std::tuple<NothrowCopyAssignable, int> T1;
         static_assert(std::is_nothrow_assignable<T0&, T1 const&>::value, "");
     }
     {
         typedef std::tuple<PotentiallyThrowingCopyAssignable, long> T0;
         typedef std::tuple<PotentiallyThrowingCopyAssignable, int> T1;
+        static_assert(std::is_assignable<T0&, T1 const&>::value, "");
         static_assert(!std::is_nothrow_assignable<T0&, T1 const&>::value, "");
     }
 
     return 0;
 }

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.assign/convert_move.pass.cpp

 #include <tuple>
 #include <string>
 #include <memory>
 #include <utility>
 #include <cassert>
 
 #include "test_macros.h"
 
-struct B
-{
+struct B {
     int id_;
-
-    explicit B(int i= 0) : id_(i) {}
-
+    explicit B(int i = 0) : id_(i) {}
     virtual ~B() {}
 };
 
-struct D
-    : B
-{
+struct D : B {
     explicit D(int i) : B(i) {}
 };
 
 struct E {
-  E() = default;
-  E& operator=(int) {
+  constexpr E() = default;
+  TEST_CONSTEXPR_CXX14 E& operator=(int) {
       return *this;
   }
 };
 
 struct NothrowMoveAssignable {
     NothrowMoveAssignable& operator=(NothrowMoveAssignable&&) noexcept { return *this; }
 };
 
TrackMove& operator=(TrackMove&& other) {
         other.moved_from = true;
         return *this;
     }
 
     int value;
     bool moved_from;
 };
 
-int main(int, char**)
+TEST_CONSTEXPR_CXX20
+bool test()
 {
     {
         typedef std::tuple<long> T0;
         typedef std::tuple<long long> T1;
         T0 t0(2);
         T1 t1;
         t1 = std::move(t0);
         assert(std::get<0>(t1) == 2);
     }
     {
         typedef std::tuple<long, char> T0;
         typedef std::tuple<long long, int> T1;
         T0 t0(2, 'a');
         T1 t1;
         t1 = std::move(t0);
         assert(std::get<0>(t1) == 2);
         assert(std::get<1>(t1) == int('a'));
     }
     {
+        // Test that tuple evaluates correctly applies an lvalue reference
+        // before evaluating is_assignable (i.e. 'is_assignable<int&, int&&>')
+        // instead of evaluating 'is_assignable<int&&, int&&>' which is false.
+        int x = 42;
+        int y = 43;
+        std::tuple<int&&, E> t(std::move(x), E{});
+        std::tuple<int&&, int> t2(std::move(y), 44);
+        t = std::move(t2);
+        assert(std::get<0>(t) == 43);
+        assert(&std::get<0>(t) == &x);
+    }
+
+    return true;
+}
+
+int main(int, char**)
+{
+    test();
+#if TEST_STD_VER >= 20
+    static_assert(test());
+#endif
+
+    {
         typedef std::tuple<long, char, D> T0;
         typedef std::tuple<long long, int, B> T1;
         T0 t0(2, 'a', D(3));
         T1 t1;
         t1 = std::move(t0);
         assert(std::get<0>(t1) == 2);
         assert(std::get<1>(t1) == int('a'));
         assert(std::get<2>(t1).id_ == 3);
#endif
         typedef std::tuple<long long, int, std::unique_ptr<B>> T1;
         T0 t0(2, 'a', std::unique_ptr<D>(new D(3)));
         T1 t1;
         t1 = std::move(t0);
         assert(std::get<0>(t1) == 2);
         assert(std::get<1>(t1) == int('a'));
         assert(std::get<2>(t1)->id_ == 3);
     }
-    {
-        // Test that tuple evaluates correctly applies an lvalue reference
-        // before evaluating is_assignable (i.e. 'is_assignable<int&, int&&>')
-        // instead of evaluating 'is_assignable<int&&, int&&>' which is false.
-        int x = 42;
-        int y = 43;
-        std::tuple<int&&, E> t(std::move(x), E{});
-        std::tuple<int&&, int> t2(std::move(y), 44);
-        t = std::move(t2);
-        assert(std::get<0>(t) == 43);
-        assert(&std::get<0>(t) == &x);
-    }
+
     {
         using T = std::tuple<int, NonAssignable>;
         using U = std::tuple<NonAssignable, int>;
         static_assert(!std::is_assignable<T&, U&&>::value, "");
         static_assert(!std::is_assignable<U&, T&&>::value, "");
     }
     {
         typedef std::tuple<NothrowMoveAssignable, long> T0;
         typedef std::tuple<NothrowMoveAssignable, int> T1;
         static_assert(std::is_nothrow_assignable<T0&, T1&&>::value, "");
     }
     {
         typedef std::tuple<PotentiallyThrowingMoveAssignable, long> T0;
         typedef std::tuple<PotentiallyThrowingMoveAssignable, int> T1;
+        static_assert(std::is_assignable<T0&, T1&&>::value, "");
         static_assert(!std::is_nothrow_assignable<T0&, T1&&>::value, "");
     }
     {
         // We assign through the reference and don't move out of the incoming ref,
         // so this doesn't work (but would if the type were CopyAssignable).
         {
             using T1 = std::tuple<MoveAssignable&, long>;
             using T2 = std::tuple<MoveAssignable&, int>;

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.assign/copy.pass.cpp

 struct PotentiallyThrowingCopyAssignable {
   PotentiallyThrowingCopyAssignable& operator=(PotentiallyThrowingCopyAssignable const&) { return *this; }
 };
 
 struct CopyAssignableInt {
   CopyAssignableInt& operator=(int&) { return *this; }
 };
 
-int main(int, char**)
+TEST_CONSTEXPR_CXX20
+bool test()
 {
     {
         typedef std::tuple<> T;
         T t0;
         T t;
         t = t0;
     }
     {
         typedef std::tuple<int> T;
         T t0(2);
         T t;
         t = t0;
         assert(std::get<0>(t) == 2);
     }
     {
         typedef std::tuple<int, char> T;
         T t0(2, 'a');
         T t;
         t = t0;
         assert(std::get<0>(t) == 2);
         assert(std::get<1>(t) == 'a');
     }
     {
-        typedef std::tuple<int, char, std::string> T;
-        const T t0(2, 'a', "some text");
-        T t;
-        t = t0;
-        assert(std::get<0>(t) == 2);
-        assert(std::get<1>(t) == 'a');
-        assert(std::get<2>(t) == "some text");
-    }
-    {
         // test reference assignment.
         using T = std::tuple<int&, int&&>;
         int x = 42;
         int y = 100;
         int x2 = -1;
         int y2 = 500;
         T t(x, std::move(y));
         T t2(x2, std::move(y2));
         t = t2;
         assert(std::get<0>(t) == x2);
         assert(&std::get<0>(t) == &x);
         assert(std::get<1>(t) == y2);
         assert(&std::get<1>(t) == &y);
     }
+
+    return true;
+}
+
+int main(int, char**)
+{
+    test();
+#if TEST_STD_VER >= 20
+    static_assert(test());
+#endif
+
+    {
+        // cannot be constexpr because of std::string
+        typedef std::tuple<int, char, std::string> T;
+        const T t0(2, 'a', "some text");
+        T t;
+        t = t0;
+        assert(std::get<0>(t) == 2);
+        assert(std::get<1>(t) == 'a');
+        assert(std::get<2>(t) == "some text");
+    }
     {
         // test that the implicitly generated copy assignment operator
         // is properly deleted
         using T = std::tuple<std::unique_ptr<int>>;
         static_assert(!std::is_copy_assignable<T>::value, "");
     }
     {
         using T = std::tuple<int, NonAssignable>;
         static_assert(!std::is_copy_assignable<T>::value, "");
     }
     {
         using T = std::tuple<int, CopyAssignable>;
         static_assert(std::is_copy_assignable<T>::value, "");
     }
     {
         using T = std::tuple<int, MoveAssignable>;
         static_assert(!std::is_copy_assignable<T>::value, "");
#endif
         static_assert(!std::is_assignable<T&, P&>::value, "");
     }
     {
         using T = std::tuple<NothrowCopyAssignable, int>;
         static_assert(std::is_nothrow_copy_assignable<T>::value, "");
     }
     {
         using T = std::tuple<PotentiallyThrowingCopyAssignable, int>;
+        static_assert(std::is_copy_assignable<T>::value, "");
         static_assert(!std::is_nothrow_copy_assignable<T>::value, "");
     }
 
     return 0;
 }

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.assign/move.pass.cpp

struct CountAssign {
   static void reset() { copied = moved = 0; }
   CountAssign() = default;
   CountAssign& operator=(CountAssign const&) { ++copied; return *this; }
   CountAssign& operator=(CountAssign&&) { ++moved; return *this; }
 };
 int CountAssign::copied = 0;
 int CountAssign::moved = 0;
 
-int main(int, char**)
+TEST_CONSTEXPR_CXX20
+bool test()
 {
     {
         typedef std::tuple<> T;
         T t0;
         T t;
         t = std::move(t0);
     }
     {
bool test()
         T t(x, std::move(y));
         T t2(x2, std::move(y2));
         t = std::move(t2);
         assert(std::get<0>(t) == x2);
         assert(&std::get<0>(t) == &x);
         assert(std::get<1>(t) == y2);
         assert(&std::get<1>(t) == &y);
     }
+    return true;
+}
+
+int main(int, char**)
+{
+    test();
+#if TEST_STD_VER >= 20
+    static_assert(test());
+#endif
+
     {
         // test that the implicitly generated move assignment operator
         // is properly deleted
         using T = std::tuple<std::unique_ptr<int>>;
         static_assert(std::is_move_assignable<T>::value, "");
         static_assert(!std::is_copy_assignable<T>::value, "");
     }
     {
         using T = std::tuple<int, NonAssignable>;
         static_assert(!std::is_move_assignable<T>::value, "");
     }
     {
         using T = std::tuple<int, MoveAssignable>;
         static_assert(std::is_move_assignable<T>::value, "");
     }
     {
         // The move should decay to a copy.
         CountAssign::reset();
         using T = std::tuple<CountAssign, CopyAssignable>;
         static_assert(std::is_move_assignable<T>::value, "");
         T t1;
         T t2;
         t1 = std::move(t2);
         assert(CountAssign::copied == 1);

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.creation/make_tuple.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <tuple>
 
 // template <class... Types> class tuple;
 
 // template<class... Types>
 //   tuple<VTypes...> make_tuple(Types&&... t);
 
 // UNSUPPORTED: c++03
 
 #include <tuple>
 #include <functional>
 #include <cassert>
 
 #include "test_macros.h"
 
-int main(int, char**)
-{
-    {
-        int i = 0;
-        float j = 0;
-        std::tuple<int, int&, float&> t = std::make_tuple(1, std::ref(i),
-                                                          std::ref(j));
-        assert(std::get<0>(t) == 1);
-        assert(std::get<1>(t) == 0);
-        assert(std::get<2>(t) == 0);
-        i = 2;
-        j = 3.5;
-        assert(std::get<0>(t) == 1);
-        assert(std::get<1>(t) == 2);
-        assert(std::get<2>(t) == 3.5);
-        std::get<1>(t) = 0;
-        std::get<2>(t) = 0;
-        assert(i == 0);
-        assert(j == 0);
-    }
+TEST_CONSTEXPR_CXX20
+bool test()
+    std::tuple<int, int&, float&> t =
+        std::make_tuple(1, std::ref(i), std::ref(j));
+
+    return true;
+
+int main(int, char**)
+{
+    test();
+#if TEST_STD_VER >= 20
+    static_assert(test());
+#endif
+
 #if TEST_STD_VER > 11
     {
         constexpr auto t1 = std::make_tuple(0, 1, 3.14);
         constexpr int i1 = std::get<1>(t1);
         constexpr double d1 = std::get<2>(t1);
         static_assert (i1 == 1, "" );
         static_assert (d1 == 3.14, "" );
     }
 #endif
 
     return 0;
 }

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.creation/tie.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <tuple>
 
 // template <class... Types> class tuple;
 
 // template<class... Types>
 //   tuple<Types&...> tie(Types&... t);
 
 // UNSUPPORTED: c++03
 
 #include <tuple>
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 
-#if TEST_STD_VER > 11
-constexpr bool test_tie_constexpr() {
+TEST_CONSTEXPR_CXX14
+bool test_tie()
+{
     {
         int i = 42;
         double f = 1.1;
         using ExpectT = std::tuple<int&, decltype(std::ignore)&, double&>;
         auto res = std::tie(i, std::ignore, f);
         static_assert(std::is_same<ExpectT, decltype(res)>::value, "");
         assert(&std::get<0>(res) == &i);
         assert(&std::get<1>(res) == &std::ignore);
         assert(&std::get<2>(res) == &f);
-        // FIXME: If/when tuple gets constexpr assignment
-        //res = std::make_tuple(101, nullptr, -1.0);
+
+#if TEST_STD_VER >= 20
+        res = std::make_tuple(101, nullptr, -1.0);
+        assert(i == 101);
+        assert(f == -1.0);
+#endif
     }
     return true;
 }
-#endif
 
 int main(int, char**)
 {
+    test_tie();
+#if TEST_STD_VER >= 14
+    static_assert(test_tie(), "");
+#endif
+
     {
         int i = 0;
         std::string s;
         std::tie(i, std::ignore, s) = std::make_tuple(42, 3.14, "C++");
         assert(i == 42);
         assert(s == "C++");
     }
-#if TEST_STD_VER > 11
-    {
-        static constexpr int i = 42;
-        static constexpr double f = 1.1;
-        constexpr std::tuple<const int &, const double &> t = std::tie(i, f);
-        static_assert ( std::get<0>(t) == 42, "" );
-        static_assert ( std::get<1>(t) == 1.1, "" );
-    }
-    {
-        static_assert(test_tie_constexpr(), "");
-    }
-#endif
 
     return 0;
 }

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.swap/member_swap.pass.cpp

 // UNSUPPORTED: c++03
 
 #include <tuple>
 #include <cassert>
 
 #include "test_macros.h"
 #include "MoveOnly.h"
 
-int main(int, char**)
+TEST_CONSTEXPR_CXX20
+bool test()
 {
     {
         typedef std::tuple<> T;
         T t0;
         T t1;
         t0.swap(t1);
     }
     {
bool test()
         t0.swap(t1);
         assert(std::get<0>(t0) == 3);
         assert(std::get<1>(t0) == 4);
         assert(std::get<2>(t0) == 5);
         assert(std::get<0>(t1) == 0);
         assert(std::get<1>(t1) == 1);
         assert(std::get<2>(t1) == 2);
     }
+    return true;
+}
+
+int main(int, char**)
+{
+    test();
+#if TEST_STD_VER >= 20
+    static_assert(test());
+#endif
 
     return 0;
 }

libcxx/test/std/utilities/utility/pairs/pair.piecewise/piecewise_construct.pass.cpp

 
 #include "test_macros.h"
 
 class A
 {
     int i_;
     char c_;
 public:
-    A(int i, char c) : i_(i), c_(c) {}
-    int get_i() const {return i_;}
-    char get_c() const {return c_;}
+    constexpr A(int i, char c) : i_(i), c_(c) {}
+    constexpr int get_i() const {return i_;}
+    constexpr char get_c() const {return c_;}
 };
 
 class B
 {
     double d_;
     unsigned u1_;
     unsigned u2_;
 public:
-    B(double d, unsigned u1, unsigned u2) : d_(d), u1_(u1), u2_(u2) {}
-    double get_d() const {return d_;}
-    unsigned get_u1() const {return u1_;}
-    unsigned get_u2() const {return u2_;}
+    constexpr explicit B(double d, unsigned u1, unsigned u2) : d_(d), u1_(u1), u2_(u2) {}
+    constexpr double get_d() const {return d_;}
+    constexpr unsigned get_u1() const {return u1_;}
+    constexpr unsigned get_u2() const {return u2_;}
 };
 
-int main(int, char**)
+TEST_CONSTEXPR_CXX20
+bool test()
 {
     std::pair<A, B> p(std::piecewise_construct,
                       std::make_tuple(4, 'a'),
                       std::make_tuple(3.5, 6u, 2u));
     assert(p.first.get_i() == 4);
     assert(p.first.get_c() == 'a');
     assert(p.second.get_d() == 3.5);
     assert(p.second.get_u1() == 6u);
     assert(p.second.get_u2() == 2u);
 
+    return true;
+}
+
+int main(int, char**)
+{
+    test();
+#if TEST_STD_VER >= 20
+    static_assert(test());
+#endif
+
     return 0;
 }

libcxx/test/support/test_constexpr_container.h

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+#ifndef SUPPORT_TEST_CONSTEXPR_CONTAINER_H
+#define SUPPORT_TEST_CONSTEXPR_CONTAINER_H
+
+// A dummy container with enough constexpr support to test the standard
+// insert iterators, such as `back_insert_iterator`.
+
+#include <algorithm>
+#include <cassert>
+#include <utility>
+
+#include "test_macros.h"
+
+#if TEST_STD_VER >= 14
+
+template<class T, int N>
+class ConstexprFixedCapacityDeque {
+    T data_[N];
+    int size_ = 0;
+public:
+    using value_type = T;
+    using iterator = T *;
+    using const_iterator = T const *;
+
+    constexpr ConstexprFixedCapacityDeque() = default;
+    constexpr iterator begin() { return data_; }
+    constexpr iterator end() { return data_ + size_; }
+    constexpr const_iterator begin() const { return data_; }
+    constexpr const_iterator end() const { return data_ + size_; }
+    constexpr size_t size() const { return size_; }
+    constexpr const T& front() const { assert(size_ >= 1); return data_[0]; }
+    constexpr const T& back() const { assert(size_ >= 1); return data_[size_-1]; }
+
+    constexpr iterator insert(const_iterator pos, T t) {
+        int i = (pos - data_);
+        if (i != size_) {
+            std::move_backward(data_ + i, data_ + size_, data_ + size_ + 1);
+        }
+        data_[i] = std::move(t);
+        size_ += 1;
+        return data_ + i;
+    }
+
+    constexpr void push_back(T t) { insert(end(), std::move(t)); }
+    constexpr void push_front(T t) { insert(begin(), std::move(t)); }
+};
+
+#endif // TEST_STD_VER >= 14
+
+#endif // SUPPORT_TEST_CONSTEXPR_CONTAINER_H

libcxx/utils/generate_feature_test_macro_components.py

feature_test_macros = [ add_version_header(x) for x in [
   }, {
     "name": "__cpp_lib_constexpr_functional",
     "values": { "c++20": 201907 },
     "headers": ["functional"],
   }, {
     "name": "__cpp_lib_constexpr_iterator",
     "values": { "c++20": 201811 },
     "headers": ["iterator"],
-    "unimplemented": True,
   }, {
     "name": "__cpp_lib_constexpr_memory",
     "values": { "c++20": 201811 },
     "headers": ["memory"],
   }, {
     "name": "__cpp_lib_constexpr_numeric",
     "values": { "c++20": 201911 },
     "headers": ["numeric"],
   }, {
     "name": "__cpp_lib_constexpr_string",
-    "values": { "c++20": 201907 },
+    "values": { "c++20": 201811 },  # because P1032R1 is implemented; but should become 201907 after P0980R1
     "headers": ["string"],
-    "unimplemented": True,
   }, {
     "name": "__cpp_lib_constexpr_string_view",
     "values": { "c++20": 201811 },
     "headers": ["string_view"],
-    "unimplemented": True,
   }, {
     "name": "__cpp_lib_constexpr_tuple",
     "values": { "c++20": 201811 },
     "headers": ["tuple"],
-    "unimplemented": True,
   }, {
     "name": "__cpp_lib_constexpr_utility",
     "values": { "c++20": 201811 },
     "headers": ["utility"],
   }, {
     "name": "__cpp_lib_constexpr_vector",
     "values": { "c++20": 201907 },
     "headers": ["vector"],