user interface and documentation, and update __cplusplus for C++20.
WG21 considers the C++20 standard to be finished (even though it still
has some more steps to pass through in the ISO process).
The old flag names are accepted for compatibility, as usual, and we
still have lots of references to C++2a in comments and identifiers;
those can be cleaned up separately.
``__has_cpp_attribute``
-----------------------
-This function-like macro is available in C++2a by default, and is provided as an
+This function-like macro is available in C++20 by default, and is provided as an
extension in earlier language standards. It takes a single argument that is the
name of a double-square-bracket-style attribute. The argument can either be a
single identifier or a scoped identifier. If the attribute is supported, a
def note_constexpr_invalid_cast : Note<
"%select{reinterpret_cast|dynamic_cast|cast that performs the conversions of"
" a reinterpret_cast|cast from %1}0 is not allowed in a constant expression"
- "%select{| in C++ standards before C++2a||}0">;
+ "%select{| in C++ standards before C++20||}0">;
def note_constexpr_invalid_downcast : Note<
"cannot cast object of dynamic type %0 to type %1">;
def note_constexpr_overflow : Note<
"control reached end of constexpr function">;
def note_constexpr_virtual_call : Note<
"cannot evaluate call to virtual function in a constant expression "
- "in C++ standards before C++2a">;
+ "in C++ standards before C++20">;
def note_constexpr_pure_virtual_call : Note<
"pure virtual function %q0 called">;
def note_constexpr_polymorphic_unknown_dynamic_type : Note<
"initializer of %0 is not a constant expression">;
def note_constexpr_typeid_polymorphic : Note<
"typeid applied to expression of polymorphic type %0 is "
- "not allowed in a constant expression in C++ standards before C++2a">;
+ "not allowed in a constant expression in C++ standards before C++20">;
def note_constexpr_void_comparison : Note<
"comparison between unequal pointers to void has unspecified result">;
def note_constexpr_temporary_here : Note<"temporary created here">;
def warn_cxx20_compat_consteval : Warning<
"'consteval' specifier is incompatible with C++ standards before C++20">,
- InGroup<CXX2aCompat>, DefaultIgnore;
+ InGroup<CXX20Compat>, DefaultIgnore;
}
def err_fe_invalid_exception_model
: Error<"invalid exception model '%0' for target '%1'">;
def warn_fe_concepts_ts_flag : Warning<
- "-fconcepts-ts is deprecated - use '-std=c++2a' for Concepts support">,
+ "-fconcepts-ts is deprecated - use '-std=c++20' for Concepts support">,
InGroup<Deprecated>;
def warn_fe_serialized_diag_merge_failure : Warning<
def err_module_build_requires_fmodules : Error<
"module compilation requires '-fmodules'">;
def err_module_interface_requires_cpp_modules : Error<
- "module interface compilation requires '-std=c++2a' or '-fmodules-ts'">;
+ "module interface compilation requires '-std=c++20' or '-fmodules-ts'">;
def err_header_module_requires_modules : Error<
- "header module compilation requires '-fmodules', '-std=c++2a', or "
+ "header module compilation requires '-fmodules', '-std=c++20', or "
"'-fmodules-ts'">;
def warn_module_config_mismatch : Warning<
"module file %0 cannot be loaded due to a configuration mismatch with the current "
DeprecatedWritableStr]>,
DiagCategory<"Deprecations">;
-def CXX2aDesignator : DiagGroup<"c++2a-designator">;
+def CXX20Designator : DiagGroup<"c++20-designator">;
// Allow -Wno-c99-designator to be used to turn off all warnings on valid C99
-// designators (including the warning controlled by -Wc++2a-designator).
-def C99Designator : DiagGroup<"c99-designator", [CXX2aDesignator]>;
+// designators (including the warning controlled by -Wc++20-designator).
+def C99Designator : DiagGroup<"c99-designator", [CXX20Designator]>;
def GNUDesignator : DiagGroup<"gnu-designator">;
def DtorName : DiagGroup<"dtor-name">;
def CXXPre17Compat : DiagGroup<"c++98-c++11-c++14-compat">;
def CXXPre17CompatPedantic : DiagGroup<"c++98-c++11-c++14-compat-pedantic",
[CXXPre17Compat]>;
-def CXXPre2aCompat : DiagGroup<"c++98-c++11-c++14-c++17-compat">;
-def CXXPre2aCompatPedantic : DiagGroup<"c++98-c++11-c++14-c++17-compat-pedantic",
- [CXXPre2aCompat]>;
+def CXXPre20Compat : DiagGroup<"c++98-c++11-c++14-c++17-compat">;
+def CXXPre20CompatPedantic : DiagGroup<"c++98-c++11-c++14-c++17-compat-pedantic",
+ [CXXPre20Compat]>;
def CXX98CompatBindToTemporaryCopy :
DiagGroup<"c++98-compat-bind-to-temporary-copy">;
CXX98CompatUnnamedTypeTemplateArgs,
CXXPre14Compat,
CXXPre17Compat,
- CXXPre2aCompat]>;
+ CXXPre20Compat]>;
// Warnings for C++11 features which are Extensions in C++98 mode.
def CXX98CompatPedantic : DiagGroup<"c++98-compat-pedantic",
[CXX98Compat,
CXX98CompatExtraSemi,
CXXPre14CompatPedantic,
CXXPre17CompatPedantic,
- CXXPre2aCompatPedantic]>;
+ CXXPre20CompatPedantic]>;
def CXX11Narrowing : DiagGroup<"c++11-narrowing">;
CXX11CompatDeprecatedWritableStr,
CXXPre14Compat,
CXXPre17Compat,
- CXXPre2aCompat]>;
+ CXXPre20Compat]>;
def : DiagGroup<"c++0x-compat", [CXX11Compat]>;
def CXX11CompatPedantic : DiagGroup<"c++11-compat-pedantic",
[CXX11Compat,
CXXPre14CompatPedantic,
CXXPre17CompatPedantic,
- CXXPre2aCompatPedantic]>;
+ CXXPre20CompatPedantic]>;
def CXX14Compat : DiagGroup<"c++14-compat", [CXXPre17Compat,
- CXXPre2aCompat]>;
+ CXXPre20Compat]>;
def CXX14CompatPedantic : DiagGroup<"c++14-compat-pedantic",
[CXX14Compat,
CXXPre17CompatPedantic,
- CXXPre2aCompatPedantic]>;
+ CXXPre20CompatPedantic]>;
def CXX17Compat : DiagGroup<"c++17-compat", [DeprecatedRegister,
DeprecatedIncrementBool,
CXX17CompatMangling,
- CXXPre2aCompat]>;
+ CXXPre20Compat]>;
def CXX17CompatPedantic : DiagGroup<"c++17-compat-pedantic",
[CXX17Compat,
- CXXPre2aCompatPedantic]>;
+ CXXPre20CompatPedantic]>;
def : DiagGroup<"c++1z-compat", [CXX17Compat]>;
-def CXX2aCompat : DiagGroup<"c++2a-compat">;
-def CXX2aCompatPedantic : DiagGroup<"c++2a-compat-pedantic",
- [CXX2aCompat]>;
+def CXX20Compat : DiagGroup<"c++20-compat">;
+def CXX20CompatPedantic : DiagGroup<"c++20-compat-pedantic",
+ [CXX20Compat]>;
+def : DiagGroup<"c++2a-compat", [CXX20Compat]>;
+def : DiagGroup<"c++2a-compat-pedantic", [CXX20CompatPedantic]>;
def ExitTimeDestructors : DiagGroup<"exit-time-destructors">;
def FlexibleArrayExtensions : DiagGroup<"flexible-array-extensions">;
// earlier C++ versions.
def CXX17 : DiagGroup<"c++17-extensions">;
-// A warning group for warnings about using C++2a features as extensions in
+// A warning group for warnings about using C++20 features as extensions in
// earlier C++ versions.
-def CXX2a : DiagGroup<"c++2a-extensions", [CXX2aDesignator]>;
+def CXX20 : DiagGroup<"c++20-extensions", [CXX20Designator]>;
def : DiagGroup<"c++0x-extensions", [CXX11]>;
def : DiagGroup<"c++1y-extensions", [CXX14]>;
def : DiagGroup<"c++1z-extensions", [CXX17]>;
+def : DiagGroup<"c++2a-extensions", [CXX20]>;
def DelegatingCtorCycles :
DiagGroup<"delegating-ctor-cycles">;
InGroup<CXX98Compat>, DefaultIgnore;
def warn_cxx17_compat_spaceship : Warning<
- "'<=>' operator is incompatible with C++ standards before C++2a">,
- InGroup<CXXPre2aCompat>, DefaultIgnore;
+ "'<=>' operator is incompatible with C++ standards before C++20">,
+ InGroup<CXXPre20Compat>, DefaultIgnore;
def warn_cxx2a_compat_spaceship : Warning<
- "'<=>' is a single token in C++2a; "
+ "'<=>' is a single token in C++20; "
"add a space to avoid a change in behavior">,
- InGroup<CXX2aCompat>;
+ InGroup<CXX20Compat>;
// Trigraphs.
def trigraph_ignored : Warning<"trigraph ignored">, InGroup<Trigraphs>;
def warn_cxx11_keyword : Warning<"'%0' is a keyword in C++11">,
InGroup<CXX11Compat>, DefaultIgnore;
-def warn_cxx2a_keyword : Warning<"'%0' is a keyword in C++2a">,
- InGroup<CXX2aCompat>, DefaultIgnore;
+def warn_cxx2a_keyword : Warning<"'%0' is a keyword in C++20">,
+ InGroup<CXX20Compat>, DefaultIgnore;
def ext_unterminated_char_or_string : ExtWarn<
"missing terminating %select{'|'\"'}0 character">, InGroup<InvalidPPToken>;
"nested namespace definition is incompatible with C++ standards before C++17">,
InGroup<CXXPre17Compat>, DefaultIgnore;
def ext_inline_nested_namespace_definition : ExtWarn<
- "inline nested namespace definition is a C++2a extension">, InGroup<CXX2a>;
+ "inline nested namespace definition is a C++20 extension">, InGroup<CXX20>;
def warn_cxx17_compat_inline_nested_namespace_definition : Warning<
"inline nested namespace definition is incompatible with C++ standards before"
- " C++2a">, InGroup<CXXPre2aCompat>, DefaultIgnore;
+ " C++20">, InGroup<CXXPre20Compat>, DefaultIgnore;
def err_inline_nested_namespace_definition : Error<
"nested namespace definition cannot be 'inline'">;
def err_expected_semi_after_attribute_list : Error<
"%select{if|switch}0 initialization statements are incompatible with "
"C++ standards before C++17">, DefaultIgnore, InGroup<CXXPre17Compat>;
def ext_for_range_init_stmt : ExtWarn<
- "range-based for loop initialization statements are a C++2a extension">,
- InGroup<CXX2a>;
+ "range-based for loop initialization statements are a C++20 extension">,
+ InGroup<CXX20>;
def warn_cxx17_compat_for_range_init_stmt : Warning<
"range-based for loop initialization statements are incompatible with "
- "C++ standards before C++2a">, DefaultIgnore, InGroup<CXXPre2aCompat>;
+ "C++ standards before C++20">, DefaultIgnore, InGroup<CXXPre20Compat>;
def warn_empty_init_statement : Warning<
"empty initialization statement of '%select{if|switch|range-based for}0' "
"has no effect">, InGroup<EmptyInitStatement>, DefaultIgnore;
"property declaration cannot have an in-class initializer">;
def warn_cxx2a_compat_explicit_bool : Warning<
- "this expression will be parsed as explicit(bool) in C++2a">,
- InGroup<CXX2aCompat>, DefaultIgnore;
+ "this expression will be parsed as explicit(bool) in C++20">,
+ InGroup<CXX20Compat>, DefaultIgnore;
def warn_cxx17_compat_explicit_bool : Warning<
- "explicit(bool) is incompatible with C++ standards before C++2a">,
- InGroup<CXXPre2aCompat>, DefaultIgnore;
-def ext_explicit_bool : ExtWarn<"explicit(bool) is a C++2a extension">,
- InGroup<CXX2a>;
+ "explicit(bool) is incompatible with C++ standards before C++20">,
+ InGroup<CXXPre20Compat>, DefaultIgnore;
+def ext_explicit_bool : ExtWarn<"explicit(bool) is a C++20 extension">,
+ InGroup<CXX20>;
/// C++ Templates
def err_expected_template : Error<"expected template">;
"in-class initialization of non-static data members is incompatible with C++98">,
InGroup<CXX98Compat>, DefaultIgnore;
def ext_bitfield_member_init: ExtWarn<
- "default member initializer for bit-field is a C++2a extension">,
- InGroup<CXX2a>;
+ "default member initializer for bit-field is a C++20 extension">,
+ InGroup<CXX20>;
def warn_cxx17_compat_bitfield_member_init: Warning<
"default member initializer for bit-field is incompatible with "
- "C++ standards before C++2a">, InGroup<CXXPre2aCompat>, DefaultIgnore;
+ "C++ standards before C++20">, InGroup<CXXPre20Compat>, DefaultIgnore;
def err_incomplete_array_member_init: Error<
"array bound cannot be deduced from an in-class initializer">;
def ext_constexpr_on_lambda_cxx17 : ExtWarn<
"'constexpr' on lambda expressions is a C++17 extension">, InGroup<CXX17>;
-// C++2a template lambdas
+// C++20 template lambdas
def ext_lambda_template_parameter_list: ExtWarn<
- "explicit template parameter list for lambdas is a C++2a extension">,
- InGroup<CXX2a>;
+ "explicit template parameter list for lambdas is a C++20 extension">,
+ InGroup<CXX20>;
def warn_cxx17_compat_lambda_template_parameter_list: Warning<
"explicit template parameter list for lambdas is incompatible with "
- "C++ standards before C++2a">, InGroup<CXXPre2aCompat>, DefaultIgnore;
+ "C++ standards before C++20">, InGroup<CXXPre20Compat>, DefaultIgnore;
def err_lambda_template_parameter_list_empty : Error<
"lambda template parameter list cannot be empty">;
def err_concept_definition_not_identifier : Error<
"name defined in concept definition must be an identifier">;
def ext_concept_legacy_bool_keyword : ExtWarn<
- "ISO C++2a does not permit the 'bool' keyword after 'concept'">,
+ "ISO C++20 does not permit the 'bool' keyword after 'concept'">,
InGroup<DiagGroup<"concepts-ts-compat">>;
def err_placeholder_expected_auto_or_decltype_auto : Error<
"expected 'auto' or 'decltype(auto)' after concept name">;
// C++20 designated initializers
def ext_cxx_designated_init : Extension<
- "designated initializers are a C++20 extension">, InGroup<CXX2aDesignator>;
+ "designated initializers are a C++20 extension">, InGroup<CXX20Designator>;
def warn_cxx17_compat_designated_init : Warning<
"designated initializers are incompatible with C++ standards before C++20">,
- InGroup<CXXPre2aCompatPedantic>, DefaultIgnore;
+ InGroup<CXXPre20CompatPedantic>, DefaultIgnore;
def ext_designated_init_mixed : ExtWarn<
"mixture of designated and non-designated initializers in the same "
"initializer list is a C99 extension">, InGroup<C99Designator>;
"%plural{1:'%1'|:with '%1' specifiers}0">;
def ext_decomp_decl_spec : ExtWarn<
"decomposition declaration declared "
- "%plural{1:'%1'|:with '%1' specifiers}0 is a C++2a extension">,
- InGroup<CXX2a>;
+ "%plural{1:'%1'|:with '%1' specifiers}0 is a C++20 extension">,
+ InGroup<CXX20>;
def warn_cxx17_compat_decomp_decl_spec : Warning<
"decomposition declaration declared "
"%plural{1:'%1'|:with '%1' specifiers}0 "
- "is incompatible with C++ standards before C++2a">,
- InGroup<CXXPre2aCompat>, DefaultIgnore;
+ "is incompatible with C++ standards before C++20">,
+ InGroup<CXXPre20Compat>, DefaultIgnore;
def err_decomp_decl_type : Error<
"decomposition declaration cannot be declared with type %0; "
"declared type must be 'auto' or reference to 'auto'">;
"list">;
def warn_cxx2a_compat_aggregate_init_with_ctors : Warning<
"aggregate initialization of type %0 with user-declared constructors "
- "is incompatible with C++2a">, DefaultIgnore, InGroup<CXX2aCompat>;
+ "is incompatible with C++20">, DefaultIgnore, InGroup<CXX20Compat>;
def err_reference_bind_to_bitfield : Error<
"%select{non-const|volatile}0 reference cannot bind to "
def err_constexpr_virtual : Error<"virtual function cannot be constexpr">;
def warn_cxx17_compat_constexpr_virtual : Warning<
"virtual constexpr functions are incompatible with "
- "C++ standards before C++2a">, InGroup<CXXPre2aCompat>, DefaultIgnore;
+ "C++ standards before C++20">, InGroup<CXXPre20Compat>, DefaultIgnore;
def err_constexpr_virtual_base : Error<
"constexpr %select{member function|constructor}0 not allowed in "
"%select{struct|interface|class}1 with virtual base "
InGroup<CXXPre14Compat>, DefaultIgnore;
def ext_constexpr_body_invalid_stmt_cxx2a : ExtWarn<
"use of this statement in a constexpr %select{function|constructor}0 "
- "is a C++2a extension">, InGroup<CXX2a>;
+ "is a C++20 extension">, InGroup<CXX20>;
def warn_cxx17_compat_constexpr_body_invalid_stmt : Warning<
"use of this statement in a constexpr %select{function|constructor}0 "
- "is incompatible with C++ standards before C++2a">,
- InGroup<CXXPre2aCompat>, DefaultIgnore;
+ "is incompatible with C++ standards before C++20">,
+ InGroup<CXXPre20Compat>, DefaultIgnore;
def ext_constexpr_type_definition : ExtWarn<
"type definition in a constexpr %select{function|constructor}0 "
"is a C++14 extension">, InGroup<CXX14>;
"%select{function|constructor}0">;
def ext_constexpr_local_var_no_init : ExtWarn<
"uninitialized variable in a constexpr %select{function|constructor}0 "
- "is a C++20 extension">, InGroup<CXX2a>;
+ "is a C++20 extension">, InGroup<CXX20>;
def warn_cxx17_compat_constexpr_local_var_no_init : Warning<
"uninitialized variable in a constexpr %select{function|constructor}0 "
"is incompatible with C++ standards before C++20">,
- InGroup<CXXPre2aCompat>, DefaultIgnore;
+ InGroup<CXXPre20Compat>, DefaultIgnore;
def ext_constexpr_function_never_constant_expr : ExtWarn<
"%select{constexpr|consteval}1 %select{function|constructor}0 never produces a "
"constant expression">, InGroup<DiagGroup<"invalid-constexpr">>, DefaultError;
def note_constexpr_body_previous_return : Note<
"previous return statement is here">;
-// C++2a function try blocks in constexpr
+// C++20 function try blocks in constexpr
def ext_constexpr_function_try_block_cxx2a : ExtWarn<
"function try block in constexpr %select{function|constructor}0 is "
- "a C++2a extension">, InGroup<CXX2a>;
+ "a C++20 extension">, InGroup<CXX20>;
def warn_cxx17_compat_constexpr_function_try_block : Warning<
"function try block in constexpr %select{function|constructor}0 is "
- "incompatible with C++ standards before C++2a">,
- InGroup<CXXPre2aCompat>, DefaultIgnore;
+ "incompatible with C++ standards before C++20">,
+ InGroup<CXXPre20Compat>, DefaultIgnore;
def ext_constexpr_union_ctor_no_init : ExtWarn<
"constexpr union constructor that does not initialize any member "
- "is a C++20 extension">, InGroup<CXX2a>;
+ "is a C++20 extension">, InGroup<CXX20>;
def warn_cxx17_compat_constexpr_union_ctor_no_init : Warning<
"constexpr union constructor that does not initialize any member "
"is incompatible with C++ standards before C++20">,
- InGroup<CXXPre2aCompat>, DefaultIgnore;
+ InGroup<CXXPre20Compat>, DefaultIgnore;
def ext_constexpr_ctor_missing_init : ExtWarn<
"constexpr constructor that does not initialize all members "
- "is a C++20 extension">, InGroup<CXX2a>;
+ "is a C++20 extension">, InGroup<CXX20>;
def warn_cxx17_compat_constexpr_ctor_missing_init : Warning<
"constexpr constructor that does not initialize all members "
"is incompatible with C++ standards before C++20">,
- InGroup<CXXPre2aCompat>, DefaultIgnore;
+ InGroup<CXXPre20Compat>, DefaultIgnore;
def note_constexpr_ctor_missing_init : Note<
"member not initialized by constructor">;
def note_non_literal_no_constexpr_ctors : Note<
InGroup<CXX98Compat>, DefaultIgnore;
def warn_cxx17_compat_unicode_type : Warning<
"'char8_t' type specifier is incompatible with C++ standards before C++20">,
- InGroup<CXXPre2aCompat>, DefaultIgnore;
+ InGroup<CXXPre20Compat>, DefaultIgnore;
// __make_integer_seq
def err_integer_sequence_negative_length : Error<
def warn_cxx17_compat_adl_only_template_id : Warning<
"use of function template name with no prior function template "
"declaration in function call with explicit template arguments "
- "is incompatible with C++ standards before C++2a">,
- InGroup<CXXPre2aCompat>, DefaultIgnore;
+ "is incompatible with C++ standards before C++20">,
+ InGroup<CXXPre20Compat>, DefaultIgnore;
def ext_adl_only_template_id : ExtWarn<
"use of function template name with no prior declaration in function call "
- "with explicit template arguments is a C++2a extension">, InGroup<CXX2a>;
+ "with explicit template arguments is a C++20 extension">, InGroup<CXX20>;
// C++ Template Argument Lists
def err_template_missing_args : Error<
"pointer-to-member function type %0 can only be called on an "
"%select{rvalue|lvalue}1">;
def ext_pointer_to_const_ref_member_on_rvalue : Extension<
- "invoking a pointer to a 'const &' member function on an rvalue is a C++2a extension">,
- InGroup<CXX2a>, SFINAEFailure;
+ "invoking a pointer to a 'const &' member function on an rvalue is a C++20 extension">,
+ InGroup<CXX20>, SFINAEFailure;
def warn_cxx17_compat_pointer_to_const_ref_member_on_rvalue : Warning<
"invoking a pointer to a 'const &' member function on an rvalue is "
- "incompatible with C++ standards before C++2a">,
- InGroup<CXXPre2aCompatPedantic>, DefaultIgnore;
+ "incompatible with C++ standards before C++20">,
+ InGroup<CXXPre20CompatPedantic>, DefaultIgnore;
def ext_ms_deref_template_argument: ExtWarn<
"non-type template argument containing a dereference operation is a "
"Microsoft extension">, InGroup<MicrosoftTemplate>;
"UTF-8 string literal%select{ is not permitted by '-fchar8_t'|}0">;
def warn_cxx2a_compat_utf8_string : Warning<
"type of UTF-8 string literal will change from array of const char to "
- "array of const char8_t in C++2a">, InGroup<CXX2aCompat>, DefaultIgnore;
+ "array of const char8_t in C++20">, InGroup<CXX20Compat>, DefaultIgnore;
def note_cxx2a_compat_utf8_string_remove_u8 : Note<
"remove 'u8' prefix to avoid a change of behavior; "
"Clang encodes unprefixed narrow string literals as UTF-8">;
"cannot deduce type for lambda capture %0 from initializer list">;
def warn_cxx17_compat_init_capture_pack : Warning<
"initialized lambda capture packs are incompatible with C++ standards "
- "before C++2a">, InGroup<CXXPre2aCompat>, DefaultIgnore;
+ "before C++20">, InGroup<CXXPre20Compat>, DefaultIgnore;
def ext_init_capture_pack : ExtWarn<
- "initialized lambda pack captures are a C++2a extension">, InGroup<CXX2a>;
+ "initialized lambda pack captures are a C++20 extension">, InGroup<CXX20>;
// C++14 generic lambdas.
def warn_cxx11_compat_generic_lambda : Warning<
def err_parameter_shadow_capture : Error<
"a lambda parameter cannot shadow an explicitly captured entity">;
- // C++2a [=, this] captures.
+ // C++20 [=, this] captures.
def warn_cxx17_compat_equals_this_lambda_capture : Warning<
"explicit capture of 'this' with a capture default of '=' is incompatible "
- "with C++ standards before C++2a">, InGroup<CXXPre2aCompat>, DefaultIgnore;
+ "with C++ standards before C++20">, InGroup<CXXPre20Compat>, DefaultIgnore;
def ext_equals_this_lambda_capture_cxx2a : ExtWarn<
"explicit capture of 'this' with a capture default of '=' "
- "is a C++2a extension">, InGroup<CXX2a>;
+ "is a C++20 extension">, InGroup<CXX20>;
def warn_deprecated_this_capture : Warning<
"implicit capture of 'this' with a capture default of '=' is deprecated">,
InGroup<DeprecatedThisCapture>, DefaultIgnore;
def note_deprecated_this_capture : Note<
"add an explicit capture of 'this' to capture '*this' by reference">;
- // C++2a default constructible / assignable lambdas.
+ // C++20 default constructible / assignable lambdas.
def warn_cxx17_compat_lambda_def_ctor_assign : Warning<
"%select{default construction|assignment}0 of lambda is incompatible with "
- "C++ standards before C++2a">, InGroup<CXXPre2aCompat>, DefaultIgnore;
+ "C++ standards before C++20">, InGroup<CXXPre20Compat>, DefaultIgnore;
}
def err_return_in_captured_stmt : Error<
def ext_cxx17_attr : Extension<
"use of the %0 attribute is a C++17 extension">, InGroup<CXX17>;
def ext_cxx2a_attr : Extension<
- "use of the %0 attribute is a C++2a extension">, InGroup<CXX2a>;
+ "use of the %0 attribute is a C++20 extension">, InGroup<CXX20>;
def warn_unused_comparison : Warning<
"%select{equality|inequality|relational|three-way}0 comparison result unused">,
// C++20 constinit and require_constant_initialization attribute
def warn_cxx20_compat_constinit : Warning<
"'constinit' specifier is incompatible with C++ standards before C++20">,
- InGroup<CXX2aCompat>, DefaultIgnore;
+ InGroup<CXX20Compat>, DefaultIgnore;
def err_constinit_local_variable : Error<
"local variable cannot be declared 'constinit'">;
def err_require_constant_init_failed : Error<
def warn_cxx17_compat_defaulted_method_type_mismatch : Warning<
"explicitly defaulting this %sub{select_special_member_kind}0 with a type "
"different from the implicit type is incompatible with C++ standards before "
- "C++2a">, InGroup<CXXPre2aCompat>, DefaultIgnore;
+ "C++20">, InGroup<CXXPre20Compat>, DefaultIgnore;
def warn_vbase_moved_multiple_times : Warning<
"defaulted move assignment operator of %0 will move assign virtual base "
"class %1 multiple times">, InGroup<DiagGroup<"multiple-move-vbase">>;
"%select{<ERROR>|equality|three-way|equality|relational}0 comparison "
"operator">;
def ext_defaulted_comparison : ExtWarn<
- "defaulted comparison operators are a C++20 extension">, InGroup<CXX2a>;
+ "defaulted comparison operators are a C++20 extension">, InGroup<CXX20>;
def warn_cxx17_compat_defaulted_comparison : Warning<
"defaulted comparison operators are incompatible with C++ standards "
- "before C++20">, InGroup<CXXPre2aCompat>, DefaultIgnore;
+ "before C++20">, InGroup<CXXPre20Compat>, DefaultIgnore;
def err_defaulted_comparison_template : Error<
"comparison operator template cannot be defaulted">;
def err_defaulted_comparison_out_of_class : Error<
Digraphs | HexFloat | GNUMode)
LANGSTANDARD_ALIAS_DEPR(gnucxx17, "gnu++1z")
-LANGSTANDARD(cxx2a, "c++2a",
- CXX, "Working draft for ISO C++ 2020",
+LANGSTANDARD(cxx20, "c++20",
+ CXX, "ISO C++ 2020 DIS",
LineComment | CPlusPlus | CPlusPlus11 | CPlusPlus14 | CPlusPlus17 |
CPlusPlus2a | Digraphs | HexFloat)
+LANGSTANDARD_ALIAS_DEPR(cxx20, "c++2a")
-LANGSTANDARD(gnucxx2a, "gnu++2a",
- CXX, "Working draft for ISO C++ 2020 with GNU extensions",
+LANGSTANDARD(gnucxx20, "gnu++20",
+ CXX, "ISO C++ 2020 DIS with GNU extensions",
LineComment | CPlusPlus | CPlusPlus11 | CPlusPlus14 | CPlusPlus17 |
CPlusPlus2a | Digraphs | HexFloat | GNUMode)
+LANGSTANDARD_ALIAS_DEPR(gnucxx20, "gnu++2a")
// OpenCL
LANGSTANDARD(opencl10, "cl1.0",
def DependentCoawaitExpr : StmtNode<Expr>;
def CoyieldExpr : StmtNode<CoroutineSuspendExpr>;
-// C++2a Concepts expressions
+// C++20 Concepts expressions
def ConceptSpecializationExpr : StmtNode<Expr>;
def RequiresExpr : StmtNode<Expr>;
const LangOptions &LangOpts,
const FrontendOptions &FEOpts,
MacroBuilder &Builder) {
+ // C++ [cpp.predefined]p1:
+ // The following macro names shall be defined by the implementation:
+
+ // -- __STDC__
+ // [C++] Whether __STDC__ is predefined and if so, what its value is,
+ // are implementation-defined.
+ // (Removed in C++20.)
if (!LangOpts.MSVCCompat && !LangOpts.TraditionalCPP)
Builder.defineMacro("__STDC__");
+ // -- __STDC_HOSTED__
+ // The integer literal 1 if the implementation is a hosted
+ // implementation or the integer literal 0 if it is not.
if (LangOpts.Freestanding)
Builder.defineMacro("__STDC_HOSTED__", "0");
else
Builder.defineMacro("__STDC_HOSTED__");
+ // -- __STDC_VERSION__
+ // [C++] Whether __STDC_VERSION__ is predefined and if so, what its
+ // value is, are implementation-defined.
+ // (Removed in C++20.)
if (!LangOpts.CPlusPlus) {
if (LangOpts.C17)
Builder.defineMacro("__STDC_VERSION__", "201710L");
else if (!LangOpts.GNUMode && LangOpts.Digraphs)
Builder.defineMacro("__STDC_VERSION__", "199409L");
} else {
- // FIXME: Use correct value for C++20.
+ // -- __cplusplus
+ // [C++20] The integer literal 202002L.
if (LangOpts.CPlusPlus2a)
- Builder.defineMacro("__cplusplus", "201707L");
- // C++17 [cpp.predefined]p1:
- // The name __cplusplus is defined to the value 201703L when compiling a
- // C++ translation unit.
+ Builder.defineMacro("__cplusplus", "202002L");
+ // [C++17] The integer literal 201703L.
else if (LangOpts.CPlusPlus17)
Builder.defineMacro("__cplusplus", "201703L");
- // C++1y [cpp.predefined]p1:
- // The name __cplusplus is defined to the value 201402L when compiling a
- // C++ translation unit.
+ // [C++14] The name __cplusplus is defined to the value 201402L when
+ // compiling a C++ translation unit.
else if (LangOpts.CPlusPlus14)
Builder.defineMacro("__cplusplus", "201402L");
- // C++11 [cpp.predefined]p1:
- // The name __cplusplus is defined to the value 201103L when compiling a
- // C++ translation unit.
+ // [C++11] The name __cplusplus is defined to the value 201103L when
+ // compiling a C++ translation unit.
else if (LangOpts.CPlusPlus11)
Builder.defineMacro("__cplusplus", "201103L");
- // C++03 [cpp.predefined]p1:
- // The name __cplusplus is defined to the value 199711L when compiling a
- // C++ translation unit.
+ // [C++03] The name __cplusplus is defined to the value 199711L when
+ // compiling a C++ translation unit.
else
Builder.defineMacro("__cplusplus", "199711L");
- // C++1z [cpp.predefined]p1:
- // An integer literal of type std::size_t whose value is the alignment
- // guaranteed by a call to operator new(std::size_t)
+ // -- __STDCPP_DEFAULT_NEW_ALIGNMENT__
+ // [C++17] An integer literal of type std::size_t whose value is the
+ // alignment guaranteed by a call to operator new(std::size_t)
//
// We provide this in all language modes, since it seems generally useful.
Builder.defineMacro("__STDCPP_DEFAULT_NEW_ALIGNMENT__",
// RUN: %clang_cc1 -fsyntax-only -verify %s
// RUN: %clang_cc1 -std=c++17 -fsyntax-only -verify %s
-// RUN: %clang_cc1 -std=c++2a -fsyntax-only -verify %s
+// RUN: %clang_cc1 -std=c++20 -fsyntax-only -verify %s
typedef int fn;
int x = f<N::A>(N::A());
#if __cplusplus <= 201703L
- // expected-warning@-2 {{C++2a extension}}
+ // expected-warning@-2 {{C++20 extension}}
#endif
int y = g<N::A>(N::A());
#if __cplusplus <= 201703L
-// RUN: %clang_cc1 -fsyntax-only -std=c++2a -verify -Wc++2a-extensions %s
+// RUN: %clang_cc1 -fsyntax-only -std=c++20 -verify -Wc++20-extensions %s
// RUN: %clang_cc1 -fsyntax-only -std=c++17 -verify -Wc++17-extensions %s
-// RUN: %clang_cc1 -fsyntax-only -std=c++11 -verify -DEXT -Wc++17-extensions -Wc++2a-extensions %s
+// RUN: %clang_cc1 -fsyntax-only -std=c++11 -verify -DEXT -Wc++17-extensions -Wc++20-extensions %s
struct [[nodiscard]] S {};
S get_s();
[[nodiscard("conflicting reason")]] int conflicting_reason();
[[nodiscard("special reason")]] int conflicting_reason();
-void cxx2a_use() {
+void cxx20_use() {
get_reason(); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute: reason}}
get_later_reason(); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute: later reason}}
another_reason(); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute: another reason}}
// expected-warning@12 {{use of the 'nodiscard' attribute is a C++17 extension}}
// expected-warning@13 {{use of the 'nodiscard' attribute is a C++17 extension}}
// expected-warning@29 {{use of the 'nodiscard' attribute is a C++17 extension}}
-// expected-warning@65 {{use of the 'nodiscard' attribute is a C++2a extension}}
-// expected-warning@67 {{use of the 'nodiscard' attribute is a C++2a extension}}
-// expected-warning@71 {{use of the 'nodiscard' attribute is a C++2a extension}}
-// expected-warning@73 {{use of the 'nodiscard' attribute is a C++2a extension}}
-// expected-warning@74 {{use of the 'nodiscard' attribute is a C++2a extension}}
-// expected-warning@84 {{use of the 'nodiscard' attribute is a C++2a extension}}
+// expected-warning@65 {{use of the 'nodiscard' attribute is a C++20 extension}}
+// expected-warning@67 {{use of the 'nodiscard' attribute is a C++20 extension}}
+// expected-warning@71 {{use of the 'nodiscard' attribute is a C++20 extension}}
+// expected-warning@73 {{use of the 'nodiscard' attribute is a C++20 extension}}
+// expected-warning@74 {{use of the 'nodiscard' attribute is a C++20 extension}}
+// expected-warning@84 {{use of the 'nodiscard' attribute is a C++20 extension}}
// expected-warning@86 {{use of the 'nodiscard' attribute is a C++17 extension}}
-// expected-warning@87 {{use of the 'nodiscard' attribute is a C++2a extension}}
+// expected-warning@87 {{use of the 'nodiscard' attribute is a C++20 extension}}
// expected-warning@91 {{use of the 'nodiscard' attribute is a C++17 extension}}
-// expected-warning@92 {{use of the 'nodiscard' attribute is a C++2a extension}}
-// expected-warning@95 {{use of the 'nodiscard' attribute is a C++2a extension}}
+// expected-warning@92 {{use of the 'nodiscard' attribute is a C++20 extension}}
+// expected-warning@95 {{use of the 'nodiscard' attribute is a C++20 extension}}
#endif
-// RUN: %clang_cc1 -verify -fcxx-exceptions -triple=x86_64-linux-gnu -std=c++11 -Werror=c++1y-extensions -Werror=c++2a-extensions %s
-// RUN: %clang_cc1 -verify -fcxx-exceptions -triple=x86_64-linux-gnu -std=c++1y -DCXX1Y -Werror=c++2a-extensions %s
-// RUN: %clang_cc1 -verify -fcxx-exceptions -triple=x86_64-linux-gnu -std=c++2a -DCXX1Y -DCXX2A %s
+// RUN: %clang_cc1 -verify -fcxx-exceptions -triple=x86_64-linux-gnu -std=c++11 -Werror=c++14-extensions -Werror=c++20-extensions %s
+// RUN: %clang_cc1 -verify -fcxx-exceptions -triple=x86_64-linux-gnu -std=c++14 -DCXX14 -Werror=c++20-extensions %s
+// RUN: %clang_cc1 -verify -fcxx-exceptions -triple=x86_64-linux-gnu -std=c++20 -DCXX14 -DCXX20 %s
namespace N {
typedef char C;
// - its return type shall be a literal type;
constexpr NonLiteral NonLiteralReturn() const { return {}; } // expected-error {{constexpr function's return type 'NonLiteral' is not a literal type}}
constexpr void VoidReturn() const { return; }
-#ifndef CXX1Y
+#ifndef CXX14
// expected-error@-2 {{constexpr function's return type 'void' is not a literal type}}
#endif
constexpr ~T();
-#ifndef CXX2A
+#ifndef CXX20
// expected-error@-2 {{destructor cannot be declared constexpr}}
#endif
typedef NonLiteral F() const;
// don't have a literal return type. Defaulted assignment operators can't be
// constexpr since they can't be const.
constexpr T &operator=(const T&) = default;
-#ifndef CXX1Y
+#ifndef CXX14
// expected-error@-2 {{an explicitly-defaulted copy assignment operator may not have 'const', 'constexpr' or 'volatile' qualifiers}}
// expected-warning@-3 {{C++14}}
#else
};
constexpr int T::OutOfLineVirtual() const { return 0; }
-#ifdef CXX1Y
+#ifdef CXX14
struct T2 {
int n = 0;
constexpr T2 &operator=(const T2&) = default; // ok
};
struct T3 {
constexpr T3 &operator=(const T3&) const = default;
-#ifndef CXX2A
+#ifndef CXX20
// expected-error@-2 {{an explicitly-defaulted copy assignment operator may not have 'const' or 'volatile' qualifiers}}
#else
// expected-warning@-4 {{explicitly defaulted copy assignment operator is implicitly deleted}}
return sizeof(K) + sizeof(C) + sizeof(K);
}
-// or a compound-statement that does not contain [CXX1Y]
-constexpr int DisallowedStmtsCXX1Y_1(bool b) {
+// or a compound-statement that does not contain [C++14]
+constexpr int DisallowedStmtsCXX14_1(bool b) {
// - an asm-definition
if (b)
asm("int3");
-#if !defined(CXX2A)
- // expected-error@-2 {{use of this statement in a constexpr function is a C++2a extension}}
+#if !defined(CXX20)
+ // expected-error@-2 {{use of this statement in a constexpr function is a C++20 extension}}
#endif
return 0;
}
-constexpr int DisallowedStmtsCXX1Y_2() {
+constexpr int DisallowedStmtsCXX14_2() {
// - a goto statement
goto x; // expected-error {{statement not allowed in constexpr function}}
x:
return 0;
}
-constexpr int DisallowedStmtsCXX1Y_2_1() {
+constexpr int DisallowedStmtsCXX14_2_1() {
try {
return 0;
} catch (...) {
merp: goto merp; // expected-error {{statement not allowed in constexpr function}}
}
}
-constexpr int DisallowedStmtsCXX1Y_3() {
+constexpr int DisallowedStmtsCXX14_3() {
// - a try-block,
try {} catch (...) {}
-#if !defined(CXX2A)
- // expected-error@-2 {{use of this statement in a constexpr function is a C++2a extension}}
+#if !defined(CXX20)
+ // expected-error@-2 {{use of this statement in a constexpr function is a C++20 extension}}
#endif
return 0;
}
-constexpr int DisallowedStmtsCXX1Y_4() {
+constexpr int DisallowedStmtsCXX14_4() {
// - a definition of a variable of non-literal type
NonLiteral nl; // expected-error {{variable of non-literal type 'NonLiteral' cannot be defined in a constexpr function}}
return 0;
}
-constexpr int DisallowedStmtsCXX1Y_5() {
+constexpr int DisallowedStmtsCXX14_5() {
// - a definition of a variable of static storage duration
static constexpr int n = 123; // expected-error {{static variable not permitted in a constexpr function}}
return n;
}
-constexpr int DisallowedStmtsCXX1Y_6() {
+constexpr int DisallowedStmtsCXX14_6() {
// - a definition of a variable of thread storage duration
thread_local constexpr int n = 123; // expected-error {{thread_local variable not permitted in a constexpr function}}
return n;
}
-constexpr int DisallowedStmtsCXX1Y_7() {
+constexpr int DisallowedStmtsCXX14_7() {
// - a definition of a variable for which no initialization is performed
int n;
-#ifndef CXX2A
+#ifndef CXX20
// expected-error@-2 {{uninitialized variable in a constexpr function}}
#endif
return 0;
constexpr int ForStmt() {
for (int n = 0; n < 10; ++n)
-#ifndef CXX1Y
+#ifndef CXX14
// expected-error@-2 {{statement not allowed in constexpr function}}
#endif
return 0;
}
constexpr int VarDecl() {
int a = 0;
-#ifndef CXX1Y
+#ifndef CXX14
// expected-error@-2 {{variable declaration in a constexpr function is a C++14 extension}}
#endif
return 0;
}
constexpr int ConstexprVarDecl() {
constexpr int a = 0;
-#ifndef CXX1Y
+#ifndef CXX14
// expected-error@-2 {{variable declaration in a constexpr function is a C++14 extension}}
#endif
return 0;
}
constexpr int VarWithCtorDecl() {
Literal a;
-#ifndef CXX1Y
+#ifndef CXX14
// expected-error@-2 {{variable declaration in a constexpr function is a C++14 extension}}
#endif
return 0;
NonLiteral nl;
constexpr NonLiteral &ExternNonLiteralVarDecl() {
extern NonLiteral nl;
-#ifndef CXX1Y
+#ifndef CXX14
// expected-error@-2 {{variable declaration in a constexpr function is a C++14 extension}}
#endif
return nl;
static_assert(&ExternNonLiteralVarDecl() == &nl, "");
constexpr int FuncDecl() {
constexpr int ForwardDecl(int);
-#ifndef CXX1Y
+#ifndef CXX14
// expected-error@-2 {{use of this statement in a constexpr function is a C++14 extension}}
#endif
return ForwardDecl(42);
}
constexpr int ClassDecl1() {
typedef struct { } S1;
-#ifndef CXX1Y
+#ifndef CXX14
// expected-error@-2 {{type definition in a constexpr function is a C++14 extension}}
#endif
return 0;
}
constexpr int ClassDecl2() {
using S2 = struct { };
-#ifndef CXX1Y
+#ifndef CXX14
// expected-error@-2 {{type definition in a constexpr function is a C++14 extension}}
#endif
return 0;
}
constexpr int ClassDecl3() {
struct S3 { };
-#ifndef CXX1Y
+#ifndef CXX14
// expected-error@-2 {{type definition in a constexpr function is a C++14 extension}}
#endif
return 0;
constexpr int MultiReturn() {
return 0;
return 0;
-#ifndef CXX1Y
+#ifndef CXX14
// expected-error@-2 {{multiple return statements in constexpr function}}
// expected-note@-4 {{return statement}}
#endif
}
constexpr int abs(int x) {
if (x < 0)
-#ifndef CXX1Y
+#ifndef CXX14
// expected-error@-2 {{C++14}}
#endif
x = -x;
}
constexpr int uninit() {
int a;
-#ifndef CXX2A
+#ifndef CXX20
// expected-error@-2 {{uninitialized}}
#endif
return a;
constexpr int prev(int x) {
return --x;
}
-#ifndef CXX1Y
+#ifndef CXX14
// expected-error@-4 {{never produces a constant expression}}
// expected-note@-4 {{subexpression}}
#endif
while (--n > 0) r *= x;
return r;
}
-#ifndef CXX1Y
+#ifndef CXX14
// expected-error@-5 {{C++14}}
// expected-error@-5 {{statement not allowed}}
#endif
-// RUN: %clang_cc1 -verify -std=c++11 -fcxx-exceptions -Werror=c++1y-extensions -Werror=c++2a-extensions %s
-// RUN: %clang_cc1 -verify -std=c++1y -fcxx-exceptions -DCXX1Y -Werror=c++2a-extensions %s
-// RUN: %clang_cc1 -verify -std=c++2a -fcxx-exceptions -DCXX1Y -DCXX2A %s
+// RUN: %clang_cc1 -verify -std=c++11 -fcxx-exceptions -Werror=c++14-extensions -Werror=c++20-extensions %s
+// RUN: %clang_cc1 -verify -std=c++14 -fcxx-exceptions -DCXX14 -Werror=c++20-extensions %s
+// RUN: %clang_cc1 -verify -std=c++20 -fcxx-exceptions -DCXX14 -DCXX2A %s
namespace N {
typedef char C;
constexpr U()
try
#ifndef CXX2A
- // expected-error@-2 {{function try block in constexpr constructor is a C++2a extension}}
+ // expected-error@-2 {{function try block in constexpr constructor is a C++20 extension}}
#endif
: u() {
-#ifndef CXX1Y
+#ifndef CXX14
// expected-error@-2 {{use of this statement in a constexpr constructor is a C++14 extension}}
#endif
} catch (...) {
constexpr V(int(&)[1]) {
for (int n = 0; n < 10; ++n)
/**/;
-#ifndef CXX1Y
+#ifndef CXX14
// expected-error@-3 {{statement not allowed in constexpr constructor}}
#endif
}
constexpr V(int(&)[2]) {
constexpr int a = 0;
-#ifndef CXX1Y
+#ifndef CXX14
// expected-error@-2 {{variable declaration in a constexpr constructor is a C++14 extension}}
#endif
}
constexpr V(int(&)[3]) {
constexpr int ForwardDecl(int);
-#ifndef CXX1Y
+#ifndef CXX14
// expected-error@-2 {{use of this statement in a constexpr constructor is a C++14 extension}}
#endif
}
constexpr V(int(&)[4]) {
typedef struct { } S1;
-#ifndef CXX1Y
+#ifndef CXX14
// expected-error@-2 {{type definition in a constexpr constructor is a C++14 extension}}
#endif
}
constexpr V(int(&)[5]) {
using S2 = struct { };
-#ifndef CXX1Y
+#ifndef CXX14
// expected-error@-2 {{type definition in a constexpr constructor is a C++14 extension}}
#endif
}
constexpr V(int(&)[6]) {
struct S3 { };
-#ifndef CXX1Y
+#ifndef CXX14
// expected-error@-2 {{type definition in a constexpr constructor is a C++14 extension}}
#endif
}
constexpr V(int(&)[7]) {
return;
-#ifndef CXX1Y
+#ifndef CXX14
// expected-error@-2 {{use of this statement in a constexpr constructor is a C++14 extension}}
#endif
}
-// RUN: %clang_cc1 -verify=expected,pre2a %s -std=c++11
-// RUN: %clang_cc1 -verify=expected,pre2a %s -std=c++17
-// RUN: %clang_cc1 -verify=expected %s -std=c++2a
+// RUN: %clang_cc1 -verify=expected,pre20 %s -std=c++11
+// RUN: %clang_cc1 -verify=expected,pre20 %s -std=c++17
+// RUN: %clang_cc1 -verify=expected %s -std=c++20
// A function that is explicitly defaulted shall
struct A {
- // -- be a special member function [C++2a: or a comparison operator function],
+ // -- be a special member function [C++20: or a comparison operator function],
A(int) = default;
#if __cplusplus <= 201703L
// expected-error@-2 {{only special member functions may be defaulted}}
A(A) = default; // expected-error {{must pass its first argument by reference}}
void f(A) = default; // expected-error-re {{only special member functions{{( and comparison operators)?}} may be defaulted}}
- bool operator==(const A&) const = default; // pre2a-warning {{defaulted comparison operators are a C++20 extension}}
- bool operator!=(const A&) const = default; // pre2a-warning {{defaulted comparison operators are a C++20 extension}}
- bool operator<(const A&) const = default; // pre2a-error {{only special member functions may be defaulted}}
- bool operator>(const A&) const = default; // pre2a-error {{only special member functions may be defaulted}}
- bool operator<=(const A&) const = default; // pre2a-error {{only special member functions may be defaulted}}
- bool operator>=(const A&) const = default; // pre2a-error {{only special member functions may be defaulted}}
- bool operator<=>(const A&) const = default; // pre2a-error 1+{{}} pre2a-warning {{'<=>' is a single token in C++2a}}
+ bool operator==(const A&) const = default; // pre20-warning {{defaulted comparison operators are a C++20 extension}}
+ bool operator!=(const A&) const = default; // pre20-warning {{defaulted comparison operators are a C++20 extension}}
+ bool operator<(const A&) const = default; // pre20-error {{only special member functions may be defaulted}}
+ bool operator>(const A&) const = default; // pre20-error {{only special member functions may be defaulted}}
+ bool operator<=(const A&) const = default; // pre20-error {{only special member functions may be defaulted}}
+ bool operator>=(const A&) const = default; // pre20-error {{only special member functions may be defaulted}}
+ bool operator<=>(const A&) const = default; // pre20-error 1+{{}} pre20-warning {{'<=>' is a single token in C++20}}
A operator+(const A&) const = default; // expected-error-re {{only special member functions{{( and comparison operators)?}} may be defaulted}}
// RUN: %clang_cc1 -std=c++11 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
// RUN: %clang_cc1 -std=c++14 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
// RUN: %clang_cc1 -std=c++17 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
-// RUN: %clang_cc1 -std=c++2a %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
+// RUN: %clang_cc1 -std=c++20 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
// PR13819 -- __SIZE_TYPE__ is incompatible.
typedef __SIZE_TYPE__ size_t; // expected-error 0-1 {{extension}}
template <class T> void g(T t); // expected-note {{candidate}}
}
void h(A::B b) {
- f<3>(b); // expected-error 0-1{{C++2a extension}} expected-error {{no matching}}
- g<3>(b); // expected-error 0-1{{C++2a extension}}
+ f<3>(b); // expected-error 0-1{{C++20 extension}} expected-error {{no matching}}
+ g<3>(b); // expected-error 0-1{{C++20 extension}}
A::f<3>(b); // expected-error {{no matching}}
A::g<3>(b);
C::f<3>(b); // expected-error {{no matching}}
// RUN: %clang_cc1 -std=c++11 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors -fno-spell-checking
// RUN: %clang_cc1 -std=c++14 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors -fno-spell-checking
// RUN: %clang_cc1 -std=c++17 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors -fno-spell-checking
-// RUN: %clang_cc1 -std=c++2a %s -verify -fexceptions -fcxx-exceptions -pedantic-errors -fno-spell-checking
+// RUN: %clang_cc1 -std=c++20 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors -fno-spell-checking
namespace std {
struct type_info {};
constexpr C(NonLiteral, int) {} // expected-error {{not a literal type}}
constexpr C() try {} catch (...) {}
#if __cplusplus <= 201703L
- // expected-error@-2 {{function try block in constexpr constructor is a C++2a extension}}
+ // expected-error@-2 {{function try block in constexpr constructor is a C++20 extension}}
#endif
#if __cplusplus < 201402L
// expected-error@-5 {{use of this statement in a constexpr constructor is a C++14 extension}}
// This is valid in C++20.
g<int>(a);
#if __cplusplus <= 201703L
- // expected-error@-2 {{C++2a extension}}
+ // expected-error@-2 {{C++20 extension}}
#endif
// This is not.
-// RUN: %clang_cc1 -std=c++11 %s -verify -Wno-c++1y-extensions
+// RUN: %clang_cc1 -std=c++11 %s -verify -Wno-c++14-extensions
class X0 {
void explicit_capture() {
(void)[this, this] () {}; // expected-error {{'this' can appear only once}}
(void)[=, foo] () {}; // expected-error {{'&' must precede a capture when}}
(void)[=, &foo] () {};
- (void)[=, this] () {}; // expected-warning {{C++2a extension}}
+ (void)[=, this] () {}; // expected-warning {{C++20 extension}}
(void)[&, foo] () {};
(void)[&, &foo] () {}; // expected-error {{'&' cannot precede a capture when}}
(void)[&, this] () {};
void S2::f(int i) {
(void)[&, i]{ };
(void)[&, &i]{ }; // expected-error{{'&' cannot precede a capture when the capture default is '&'}}
- (void)[=, this]{ }; // expected-warning{{C++2a extension}}
+ (void)[=, this]{ }; // expected-warning{{C++20 extension}}
(void)[=]{ this->g(i); };
(void)[i, i]{ }; // expected-error{{'i' can appear only once in a capture list}}
(void)[i(0), i(1)]{ }; // expected-error{{'i' can appear only once in a capture list}}
// CHECK-NEXT: note: use 'gnu++14' for 'ISO C++ 2014 with amendments and GNU extensions' standard
// CHECK-NEXT: note: use 'c++17' for 'ISO C++ 2017 with amendments' standard
// CHECK-NEXT: note: use 'gnu++17' for 'ISO C++ 2017 with amendments and GNU extensions' standard
-// CHECK-NEXT: note: use 'c++2a' for 'Working draft for ISO C++ 2020' standard
-// CHECK-NEXT: note: use 'gnu++2a' for 'Working draft for ISO C++ 2020 with GNU extensions' standard
+// CHECK-NEXT: note: use 'c++20' for 'ISO C++ 2020 DIS' standard
+// CHECK-NEXT: note: use 'gnu++20' for 'ISO C++ 2020 DIS with GNU extensions' standard
// CUDA-NEXT: note: use 'cuda' for 'NVIDIA CUDA(tm)' standard
// Make sure that no other output is present.
// RUN: %clang_cc1 -std=c++17 %s -verify
-// RUN: %clang_cc1 -std=c++2a %s -verify
-// RUN: %clang_cc1 -std=c++2a %s -verify -Wc++17-compat -DCOMPAT
+// RUN: %clang_cc1 -std=c++20 %s -verify
+// RUN: %clang_cc1 -std=c++20 %s -verify -Wc++17-compat -DCOMPAT
//
// RUN: %clang_cc1 -std=c++17 %s -E -o - | FileCheck %s --check-prefix=CXX17
-// RUN: %clang_cc1 -std=c++2a %s -E -o - | FileCheck %s --check-prefix=CXX20
+// RUN: %clang_cc1 -std=c++20 %s -E -o - | FileCheck %s --check-prefix=CXX20
namespace N {
#if __cplusplus > 201703L
void operator<=>(A, A);
#ifdef COMPAT
-// expected-warning@-2 {{'<=>' operator is incompatible with C++ standards before C++2a}}
+// expected-warning@-2 {{'<=>' operator is incompatible with C++ standards before C++20}}
#endif
#endif
template<auto> struct X {};
X<operator<=>
#if __cplusplus <= 201703L
- // expected-warning@-2 {{'<=>' is a single token in C++2a; add a space to avoid a change in behavior}}
+ // expected-warning@-2 {{'<=>' is a single token in C++20; add a space to avoid a change in behavior}}
#else
>
#endif
#ifdef COMPAT
-// expected-warning@-7 {{'<=>' operator is incompatible with C++ standards before C++2a}}
+// expected-warning@-7 {{'<=>' operator is incompatible with C++ standards before C++20}}
#endif
x;
}
-// RUN: %clang_cc1 %s -verify -fsyntax-only -Wc++2a-compat -std=c++17
+// RUN: %clang_cc1 %s -verify -fsyntax-only -Wc++20-compat -std=c++17
#define concept constexpr bool
template<typename T>
concept x = 0;
#undef concept
-int co_await = 0; // expected-warning {{'co_await' is a keyword in C++2a}}
-int co_return = 0; // expected-warning {{'co_return' is a keyword in C++2a}}
-int co_yield = 0; // expected-warning {{'co_yield' is a keyword in C++2a}}
-int char8_t = 0; // expected-warning {{'char8_t' is a keyword in C++2a}}
-int concept = 0; // expected-warning {{'concept' is a keyword in C++2a}}
-int requires = 0; // expected-warning {{'requires' is a keyword in C++2a}}
-int consteval = 0; // expected-warning {{'consteval' is a keyword in C++2a}}
-int constinit = 0; // expected-warning {{'constinit' is a keyword in C++2a}}
+int co_await = 0; // expected-warning {{'co_await' is a keyword in C++20}}
+int co_return = 0; // expected-warning {{'co_return' is a keyword in C++20}}
+int co_yield = 0; // expected-warning {{'co_yield' is a keyword in C++20}}
+int char8_t = 0; // expected-warning {{'char8_t' is a keyword in C++20}}
+int concept = 0; // expected-warning {{'concept' is a keyword in C++20}}
+int requires = 0; // expected-warning {{'requires' is a keyword in C++20}}
+int consteval = 0; // expected-warning {{'consteval' is a keyword in C++20}}
+int constinit = 0; // expected-warning {{'constinit' is a keyword in C++20}}
-// RUN: %clang_cc1 -std=c++1z %s -verify -fcxx-exceptions
-// RUN: not %clang_cc1 -std=c++1z %s -emit-llvm-only -fcxx-exceptions
+// RUN: %clang_cc1 -std=c++17 %s -verify -fcxx-exceptions
+// RUN: not %clang_cc1 -std=c++17 %s -emit-llvm-only -fcxx-exceptions
struct S { int a, b, c; };
struct S { int n; } s;
void f() {
// storage-class-specifiers
- static auto &[a] = n; // expected-warning {{declared 'static' is a C++2a extension}}
- thread_local auto &[b] = n; // expected-warning {{declared 'thread_local' is a C++2a extension}}
+ static auto &[a] = n; // expected-warning {{declared 'static' is a C++20 extension}}
+ thread_local auto &[b] = n; // expected-warning {{declared 'thread_local' is a C++20 extension}}
extern auto &[c] = n; // expected-error {{cannot be declared 'extern'}} expected-error {{cannot have an initializer}}
struct S {
mutable auto &[d] = n; // expected-error {{not permitted in this context}}
}
static constexpr inline thread_local auto &[j1] = n; // expected-error {{cannot be declared with 'constexpr inline' specifiers}}
- static thread_local auto &[j2] = n; // expected-warning {{declared with 'static thread_local' specifiers is a C++2a extension}}
+ static thread_local auto &[j2] = n; // expected-warning {{declared with 'static thread_local' specifiers is a C++20 extension}}
inline auto &[k] = n; // expected-error {{cannot be declared 'inline'}}
// Support parsing of concepts
-// RUN: %clang_cc1 -std=c++2a -verify %s
+// RUN: %clang_cc1 -std=c++20 -verify %s
template<typename T> concept C1 = true; // expected-note 2{{previous}}
template<typename T> concept C1 = true; // expected-error{{redefinition}}
// expected-note@-2{{'word' declared here}}
template<typename T> concept bool C7 = true;
-// expected-warning@-1{{ISO C++2a does not permit the 'bool' keyword after 'concept'}}
+// expected-warning@-1{{ISO C++20 does not permit the 'bool' keyword after 'concept'}}
template<> concept C8 = false;
// expected-error@-1{{concept template parameter list must have at least one parameter; explicit specialization of concepts is not allowed}}
// RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++14
// RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++17
-// RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++2a -Wc++17-compat
+// RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++20 -Wc++17-compat
namespace inline foo1::foo2::foo3 { // expected-error {{expected identifier or '{'}} expected-error {{use of undeclared identifier 'foo1'}}
}
#if __cplusplus <= 201402L
// expected-warning@+7 {{nested namespace definition is a C++17 extension; define each namespace separately}}
-// expected-warning@+6 {{inline nested namespace definition is a C++2a extension}}
+// expected-warning@+6 {{inline nested namespace definition is a C++20 extension}}
#elif __cplusplus <= 201703L
-// expected-warning@+4 {{inline nested namespace definition is a C++2a extension}}
+// expected-warning@+4 {{inline nested namespace definition is a C++20 extension}}
#else
-// expected-warning@+2 {{inline nested namespace definition is incompatible with C++ standards before C++2a}}
+// expected-warning@+2 {{inline nested namespace definition is incompatible with C++ standards before C++20}}
#endif
namespace valid1::valid2::inline valid3::inline valid4::valid5 {}
// expected-note@-1 2 {{previous definition is here}}
#if __cplusplus <= 201402L
// expected-warning@+7 {{nested namespace definition is a C++17 extension; define each namespace separately}}
-// expected-warning@+6 {{inline nested namespace definition is a C++2a extension}}
+// expected-warning@+6 {{inline nested namespace definition is a C++20 extension}}
#elif __cplusplus <= 201703L
-// expected-warning@+4 {{inline nested namespace definition is a C++2a extension}}
+// expected-warning@+4 {{inline nested namespace definition is a C++20 extension}}
#else
-// expected-warning@+2 {{inline nested namespace definition is incompatible with C++ standards before C++2a}}
+// expected-warning@+2 {{inline nested namespace definition is incompatible with C++ standards before C++20}}
#endif
namespace valid1::valid2::inline valid3::inline valid4::valid5 {}
// expected-note@-1 2 {{previous definition is here}}
-// RUN: %clang_cc1 -std=c++17 -verify=cxx17 -Wc++2a-compat %s
-// RUN: %clang_cc1 -std=c++2a -verify=cxx2a -Wc++17-compat %s
+// RUN: %clang_cc1 -std=c++17 -verify=cxx17 -Wc++20-compat %s
+// RUN: %clang_cc1 -std=c++20 -verify=cxx20 -Wc++17-compat %s
namespace disambig {
// Cases that are valid in C++17 and before, ill-formed in C++20, and that we
// should not treat as explicit(bool) as an extension.
-struct A { // cxx2a-note +{{}}
+struct A { // cxx20-note +{{}}
constexpr A() {}
constexpr operator bool() { return true; }
constexpr explicit (A)(int); // #1
// cxx17-warning@#1 {{will be parsed as explicit(bool)}}
- // cxx2a-error@#1 +{{}} cxx2a-note@#1 +{{}}
- // cxx2a-warning@#1 {{incompatible with C++ standards before C++2a}}
+ // cxx20-error@#1 +{{}} cxx20-note@#1 +{{}}
+ // cxx20-warning@#1 {{incompatible with C++ standards before C++20}}
// This is ill-formed (via a DR change), and shouldn't be recognized as a
// constructor (the function declarator cannot be parenthesized in a
// FIXME: Produce an ExtWarn for this.
constexpr explicit (A(float)); // #1b
// cxx17-warning@#1b {{will be parsed as explicit(bool)}}
- // cxx2a-error@#1b +{{}}
- // cxx2a-warning@#1b {{incompatible with C++ standards before C++2a}}
+ // cxx20-error@#1b +{{}}
+ // cxx20-warning@#1b {{incompatible with C++ standards before C++20}}
explicit (operator int)(); // #2
// cxx17-warning@#2 {{will be parsed as explicit(bool)}}
- // cxx2a-error@#2 +{{}}
- // cxx2a-warning@#2 {{incompatible with C++ standards before C++2a}}
+ // cxx20-error@#2 +{{}}
+ // cxx20-warning@#2 {{incompatible with C++ standards before C++20}}
explicit (A::operator float)(); // #2b
// cxx17-warning@#2b {{will be parsed as explicit(bool)}}
// cxx17-error@#2b {{extra qualification on member}}
- // cxx2a-error@#2b +{{}}
- // cxx2a-warning@#2b {{incompatible with C++ standards before C++2a}}
+ // cxx20-error@#2b +{{}}
+ // cxx20-warning@#2b {{incompatible with C++ standards before C++20}}
};
constexpr bool operator+(A) { return true; }
struct B {
// Looks like a constructor, but not the constructor of B.
explicit (A()) B(); // #3
- // cxx17-warning@#3 {{C++2a extension}}
- // cxx2a-warning@#3 {{incompatible with C++ standards before C++2a}}
+ // cxx17-warning@#3 {{C++20 extension}}
+ // cxx20-warning@#3 {{incompatible with C++ standards before C++20}}
// Looks like a 'constructor' of C. Actually a constructor of B.
explicit (C)(B)(A); // #4
- // cxx17-warning@#4 {{C++2a extension}}
- // cxx2a-warning@#4 {{incompatible with C++ standards before C++2a}}
+ // cxx17-warning@#4 {{C++20 extension}}
+ // cxx20-warning@#4 {{incompatible with C++ standards before C++20}}
explicit (operator+(A())) operator int(); // #5
// cxx17-error@#5 {{requires a type specifier}} cxx17-error@#5 {{expected ';'}}
// cxx17-warning@#5 {{will be parsed as explicit(bool)}}
- // cxx2a-warning@#5 {{incompatible with C++ standards before C++2a}}
+ // cxx20-warning@#5 {{incompatible with C++ standards before C++20}}
};
}
// BLOCKS:#define __block __attribute__((__blocks__(byref)))
//
//
+// RUN: %clang_cc1 -x c++ -fgnuc-version=4.2.1 -std=c++20 -E -dM < /dev/null | FileCheck -match-full-lines -check-prefix CXX2A %s
// RUN: %clang_cc1 -x c++ -fgnuc-version=4.2.1 -std=c++2a -E -dM < /dev/null | FileCheck -match-full-lines -check-prefix CXX2A %s
//
// CXX2A:#define __GNUG__ 4
// CXX2A:#define __GXX_EXPERIMENTAL_CXX0X__ 1
// CXX2A:#define __GXX_RTTI 1
// CXX2A:#define __GXX_WEAK__ 1
-// CXX2A:#define __cplusplus 201707L
+// CXX2A:#define __cplusplus 202002L
// CXX2A:#define __private_extern__ extern
//
+// RUN: %clang_cc1 -x c++ -fgnuc-version=4.2.1 -std=c++17 -E -dM < /dev/null | FileCheck -match-full-lines -check-prefix CXX1Z %s
// RUN: %clang_cc1 -x c++ -fgnuc-version=4.2.1 -std=c++1z -E -dM < /dev/null | FileCheck -match-full-lines -check-prefix CXX1Z %s
//
// CXX1Z:#define __GNUG__ 4
// CXX1Z:#define __private_extern__ extern
//
//
+// RUN: %clang_cc1 -x c++ -fgnuc-version=4.2.1 -std=c++14 -E -dM < /dev/null | FileCheck -match-full-lines -check-prefix CXX1Y %s
// RUN: %clang_cc1 -x c++ -fgnuc-version=4.2.1 -std=c++1y -E -dM < /dev/null | FileCheck -match-full-lines -check-prefix CXX1Y %s
//
// CXX1Y:#define __GNUG__ 4
// RUN: %clang_cc1 -ffreestanding -E -dM < /dev/null | FileCheck -match-full-lines -check-prefix FREESTANDING %s
// FREESTANDING:#define __STDC_HOSTED__ 0
//
+// RUN: %clang_cc1 -x c++ -fgnuc-version=4.2.1 -std=gnu++20 -E -dM < /dev/null | FileCheck -match-full-lines -check-prefix GXX2A %s
// RUN: %clang_cc1 -x c++ -fgnuc-version=4.2.1 -std=gnu++2a -E -dM < /dev/null | FileCheck -match-full-lines -check-prefix GXX2A %s
//
// GXX2A:#define __GNUG__ 4
// GXX2A:#define __GXX_WEAK__ 1
-// GXX2A:#define __cplusplus 201707L
+// GXX2A:#define __cplusplus 202002L
// GXX2A:#define __private_extern__ extern
//
//
+// RUN: %clang_cc1 -x c++ -fgnuc-version=4.2.1 -std=gnu++17 -E -dM < /dev/null | FileCheck -match-full-lines -check-prefix GXX1Z %s
// RUN: %clang_cc1 -x c++ -fgnuc-version=4.2.1 -std=gnu++1z -E -dM < /dev/null | FileCheck -match-full-lines -check-prefix GXX1Z %s
//
// GXX1Z:#define __GNUG__ 4
// GXX1Z:#define __private_extern__ extern
//
//
+// RUN: %clang_cc1 -x c++ -fgnuc-version=4.2.1 -std=gnu++14 -E -dM < /dev/null | FileCheck -match-full-lines -check-prefix GXX1Y %s
// RUN: %clang_cc1 -x c++ -fgnuc-version=4.2.1 -std=gnu++1y -E -dM < /dev/null | FileCheck -match-full-lines -check-prefix GXX1Y %s
//
// GXX1Y:#define __GNUG__ 4
// RUN: %clang_cc1 -fsyntax-only -std=c++17 -pedantic -verify %s
-// RUN: %clang_cc1 -fsyntax-only -std=c++2a -Wc++17-compat-pedantic -verify %s -Wno-defaulted-function-deleted
+// RUN: %clang_cc1 -fsyntax-only -std=c++20 -Wc++17-compat-pedantic -verify %s -Wno-defaulted-function-deleted
struct A {};
int (A::*pa)() const&;
int use_pa = (A().*pa)();
#if __cplusplus <= 201703L
- // expected-warning@-2 {{invoking a pointer to a 'const &' member function on an rvalue is a C++2a extension}}
+ // expected-warning@-2 {{invoking a pointer to a 'const &' member function on an rvalue is a C++20 extension}}
#else
- // expected-warning@-4 {{invoking a pointer to a 'const &' member function on an rvalue is incompatible with C++ standards before C++2a}}
+ // expected-warning@-4 {{invoking a pointer to a 'const &' member function on an rvalue is incompatible with C++ standards before C++20}}
#endif
struct B {
void b() {
(void) [=, this] {};
#if __cplusplus <= 201703L
- // expected-warning@-2 {{explicit capture of 'this' with a capture default of '=' is a C++2a extension}}
+ // expected-warning@-2 {{explicit capture of 'this' with a capture default of '=' is a C++20 extension}}
#else
- // expected-warning@-4 {{explicit capture of 'this' with a capture default of '=' is incompatible with C++ standards before C++2a}}
+ // expected-warning@-4 {{explicit capture of 'this' with a capture default of '=' is incompatible with C++ standards before C++20}}
#endif
}
int n : 5 = 0;
#if __cplusplus <= 201703L
- // expected-warning@-2 {{default member initializer for bit-field is a C++2a extension}}
+ // expected-warning@-2 {{default member initializer for bit-field is a C++20 extension}}
#else
- // expected-warning@-4 {{default member initializer for bit-field is incompatible with C++ standards before C++2a}}
+ // expected-warning@-4 {{default member initializer for bit-field is incompatible with C++ standards before C++20}}
#endif
};
#if __cplusplus <= 201703L
// expected-error@-2 {{no matching constructor}} expected-note@-3 2{{candidate}}
#else
- // expected-warning@-4 {{default construction of lambda is incompatible with C++ standards before C++2a}}
+ // expected-warning@-4 {{default construction of lambda is incompatible with C++ standards before C++20}}
#endif
void copy_lambda() { Lambda = Lambda; }
#if __cplusplus <= 201703L
// expected-error@-2 {{deleted}} expected-note@-10 {{lambda}}
#else
- // expected-warning@-4 {{assignment of lambda is incompatible with C++ standards before C++2a}}
+ // expected-warning@-4 {{assignment of lambda is incompatible with C++ standards before C++20}}
#endif
struct DefaultDeleteWrongTypeBase {
#if __cplusplus <= 201703L
// expected-error@-2 {{a member or base requires it to be non-const}}
#else
- // expected-warning@-4 {{explicitly defaulting this copy constructor with a type different from the implicit type is incompatible with C++ standards before C++2a}}
+ // expected-warning@-4 {{explicitly defaulting this copy constructor with a type different from the implicit type is incompatible with C++ standards before C++20}}
#endif
};
void ForRangeInit() {
for (int arr[3] = {1, 2, 3}; int n : arr) {}
#if __cplusplus <= 201703L
- // expected-warning@-2 {{range-based for loop initialization statements are a C++2a extension}}
+ // expected-warning@-2 {{range-based for loop initialization statements are a C++20 extension}}
#else
- // expected-warning@-4 {{range-based for loop initialization statements are incompatible with C++ standards before C++2a}}
+ // expected-warning@-4 {{range-based for loop initialization statements are incompatible with C++ standards before C++20}}
#endif
}
#if __cplusplus <= 201703L
// expected-error@-2 {{virtual function cannot be constexpr}}
#else
- // expected-warning@-4 {{virtual constexpr functions are incompatible with C++ standards before C++2a}}
+ // expected-warning@-4 {{virtual constexpr functions are incompatible with C++ standards before C++20}}
#endif
};
struct C { int x, y, z; };
static auto [cx, cy, cz] = C();
#if __cplusplus <= 201703L
- // expected-warning@-2 {{decomposition declaration declared 'static' is a C++2a extension}}
+ // expected-warning@-2 {{decomposition declaration declared 'static' is a C++20 extension}}
#else
- // expected-warning@-4 {{decomposition declaration declared 'static' is incompatible with C++ standards before C++2a}}
+ // expected-warning@-4 {{decomposition declaration declared 'static' is incompatible with C++ standards before C++20}}
#endif
void f() {
static thread_local auto [cx, cy, cz] = C();
#if __cplusplus <= 201703L
- // expected-warning@-2 {{decomposition declaration declared with 'static thread_local' specifiers is a C++2a extension}}
+ // expected-warning@-2 {{decomposition declaration declared with 'static thread_local' specifiers is a C++20 extension}}
#else
- // expected-warning@-4 {{decomposition declaration declared with 'static thread_local' specifiers is incompatible with C++ standards before C++2a}}
+ // expected-warning@-4 {{decomposition declaration declared with 'static thread_local' specifiers is incompatible with C++ standards before C++20}}
#endif
}
#if __cplusplus <= 201703L
// expected-error@-2 {{'operator<=' cannot be the name of a variable or data member}} expected-error@-2 0+{{}} expected-warning@-2 {{}}
#else
- // expected-warning@-4 {{'<=>' operator is incompatible with C++ standards before C++2a}}
+ // expected-warning@-4 {{'<=>' operator is incompatible with C++ standards before C++20}}
#endif
bool operator<(const DefaultedComparisons&) const = default;
bool operator<=(const DefaultedComparisons&) const = default;
// RUN: %clang_cc1 -std=c++1z -verify -fsyntax-only -fblocks %s -fcxx-exceptions
-// RUN: %clang_cc1 -std=c++2a -verify -fsyntax-only -fblocks %s -fcxx-exceptions
+// RUN: %clang_cc1 -std=c++20 -verify -fsyntax-only -fblocks %s -fcxx-exceptions
// RUN: %clang_cc1 -std=c++1z -verify -fsyntax-only -fblocks -fdelayed-template-parsing %s -fcxx-exceptions
// RUN: %clang_cc1 -std=c++14 -verify -fsyntax-only -fblocks %s -DCPP14_AND_EARLIER -fcxx-exceptions
namespace ns2 {
auto L = [](int I) constexpr { if (I == 5) asm("non-constexpr"); };
#if __cpp_constexpr < 201907L
- //expected-warning@-2{{use of this statement in a constexpr function is a C++2a extension}}
+ //expected-warning@-2{{use of this statement in a constexpr function is a C++20 extension}}
#endif
} // end ns1
-// RUN: %clang_cc1 -std=c++1z -verify %s
+// RUN: %clang_cc1 -std=c++17 -verify %s
void use_from_own_init() {
auto [a] = a; // expected-error {{binding 'a' cannot appear in the initializer of its own decomposition declaration}}
struct PR37352 {
int n;
- void f() { static auto [a] = *this; } // expected-warning {{C++2a extension}}
+ void f() { static auto [a] = *this; } // expected-warning {{C++20 extension}}
};
namespace instantiate_template {
-// RUN: %clang_cc1 -fsyntax-only -std=c++17 -Wc++2a-compat-pedantic -verify %s
-// RUN: %clang_cc1 -fsyntax-only -std=c++2a -pedantic -verify %s
+// RUN: %clang_cc1 -fsyntax-only -std=c++17 -Wc++20-compat-pedantic -verify %s
+// RUN: %clang_cc1 -fsyntax-only -std=c++20 -pedantic -verify %s
struct A { // expected-note 0+{{candidate}}
A() = default; // expected-note 0+{{candidate}}
};
A a1 = {1, 2};
#if __cplusplus <= 201703L
- // expected-warning@-2 {{aggregate initialization of type 'A' with user-declared constructors is incompatible with C++2a}}
+ // expected-warning@-2 {{aggregate initialization of type 'A' with user-declared constructors is incompatible with C++20}}
#else
// expected-error@-4 {{no matching constructor}}
#endif
B b1 = {{}, {}}; // ok
B b2 = {1, 2, 3, 4};
#if __cplusplus <= 201703L
- // expected-warning@-2 2{{aggregate initialization of type 'A' with user-declared constructors is incompatible with C++2a}}
+ // expected-warning@-2 2{{aggregate initialization of type 'A' with user-declared constructors is incompatible with C++20}}
#else
// expected-error@-4 2{{no viable conversion from 'int' to 'A'}}
#endif
explicit(C)(int);
};
#if __cplusplus <= 201703L
-// expected-warning@-3 {{this expression will be parsed as explicit(bool) in C++2a}}
+// expected-warning@-3 {{this expression will be parsed as explicit(bool) in C++20}}
#if defined(__cpp_conditional_explicit)
#error "the feature test macro __cpp_conditional_explicit isn't correct"
#endif
auto l = []() consteval {};
int consteval();
#if __cplusplus <= 201703L
-// expected-warning@-3 {{'consteval' is a keyword in C++2a}}
+// expected-warning@-3 {{'consteval' is a keyword in C++20}}
// expected-error@-4 {{expected body of lambda expression}}
#else
// expected-error@-5 {{expected unqualified-id}}
-#endif
\ No newline at end of file
+#endif
-// RUN: %clang_cc1 -std=c++2a %s -verify=cxx20,expected,pedantic,override,reorder -pedantic-errors
-// RUN: %clang_cc1 -std=c++17 %s -verify=expected,pedantic,override,reorder -Wno-c++2a-designator -pedantic-errors
-// RUN: %clang_cc1 -std=c++2a %s -verify=cxx20,expected,pedantic -Werror=c99-designator -Wno-reorder-init-list -Wno-initializer-overrides
-// RUN: %clang_cc1 -std=c++2a %s -verify=cxx20,expected,reorder -Wno-c99-designator -Werror=reorder-init-list -Wno-initializer-overrides
-// RUN: %clang_cc1 -std=c++2a %s -verify=cxx20,expected,override -Wno-c99-designator -Wno-reorder-init-list -Werror=initializer-overrides
-// RUN: %clang_cc1 -std=c++2a %s -verify=cxx20,expected -Wno-c99-designator -Wno-reorder-init-list -Wno-initializer-overrides
+// RUN: %clang_cc1 -std=c++20 %s -verify=cxx20,expected,pedantic,override,reorder -pedantic-errors
+// RUN: %clang_cc1 -std=c++17 %s -verify=expected,pedantic,override,reorder -Wno-c++20-designator -pedantic-errors
+// RUN: %clang_cc1 -std=c++20 %s -verify=cxx20,expected,pedantic -Werror=c99-designator -Wno-reorder-init-list -Wno-initializer-overrides
+// RUN: %clang_cc1 -std=c++20 %s -verify=cxx20,expected,reorder -Wno-c99-designator -Werror=reorder-init-list -Wno-initializer-overrides
+// RUN: %clang_cc1 -std=c++20 %s -verify=cxx20,expected,override -Wno-c99-designator -Wno-reorder-init-list -Werror=initializer-overrides
+// RUN: %clang_cc1 -std=c++20 %s -verify=cxx20,expected -Wno-c99-designator -Wno-reorder-init-list -Wno-initializer-overrides
namespace class_with_ctor {
// RUN: %clang_cc1 -fsyntax-only -fcxx-exceptions -verify -std=c++11 -Wall %s
struct Bitfield {
- int n : 3 = 7; // expected-warning {{C++2a extension}} expected-warning {{changes value from 7 to -1}}
+ int n : 3 = 7; // expected-warning {{C++20 extension}} expected-warning {{changes value from 7 to -1}}
};
int a;
</p>
</details>
-<h2 id="cxx20">C++2a implementation status</h2>
+<h2 id="cxx20">C++20 implementation status</h2>
-<p>Clang has <b>experimental</b> support for some proposed features of
-the C++ standard following C++17, provisionally named C++2a.
-Note that support for these features may change or be removed without notice,
-as the draft C++2a standard evolves.
+<p>Clang has support for some of the features of the
+ISO C++ 2020 Draft International Standard.
-<p>You can use Clang in C++2a mode with the <code>-std=c++2a</code> option.</p>
+<p>You can use Clang in C++20 mode with the <code>-std=c++20</code> option
+(use <code>-std=c++2a</code> in Clang 10 and earlier).</p>
<details open>
<summary>List of features and minimum Clang version with support</summary>
<table width="689" border="1" cellspacing="0">
<tr>
<th>Language Feature</th>
- <th>C++2a Proposal</th>
+ <th>C++20 Proposal</th>
<th>Available in Clang?</th>
</tr>
<!-- Toronto 2017 papers -->
<p>
<span id="p0482">(11): Prior to Clang 8, this feature is not enabled by
-<tt>-std=c++2a</tt>, but can be enabled with <tt>-fchar8_t</tt>.
+<tt>-std=c++20</tt>, but can be enabled with <tt>-fchar8_t</tt>.
</span>
</p>
</details>
<td class="full" align="center">Clang 5</td>
</tr>
<tr>
- <td><tt>-std=c++2a<br>-stdlib=libc++</tt></td>
+ <td><tt>-std=c++20<br>-stdlib=libc++</tt></td>
<td class="na" align="center">Superseded by <a href="#p0912">P0912R5</a></td>
</tr>
<tr>
projects / platform / upstream / llvm.git / commitdiff