This is an archive of the discontinued LLVM Phabricator instance.

Differential D149553

[clang] Use -std=c++23 instead of -std=c++2b
ClosedPublic

Authored by Mordante on Apr 30 2023, 9:21 AM.

Details

Reviewers
aaron.ballman
njames93
jdoerfert
Group Reviewers
Restricted Project
Commits
rGba15d186e5ce: [clang] Use -std=c++23 instead of -std=c++2b
Summary

During the ISO C++ Committee meeting plenary session the C++23 Standard
has been voted as technical complete.

This updates the reference to c++2b to c++23 and updates the __cplusplus
macro.

Drive-by fixes c++1z -> c++17 and c++2a -> c++20 when seen.

Diff Detail

Event Timeline

Mordante created this revision.Apr 30 2023, 9:21 AM
Herald added a reviewer: njames93. · View Herald TranscriptApr 30 2023, 9:21 AM
Herald added a project: Restricted Project. · View Herald Transcript
Herald added subscribers: carlosgalvezp, ChuanqiXu, jdoerfert and 2 others. · View Herald Transcript
Mordante requested review of this revision.Apr 30 2023, 9:21 AM
Herald added a reviewer: jdoerfert. · View Herald TranscriptApr 30 2023, 9:21 AM
Herald added projects: Restricted Project, Restricted Project, Restricted Project. · View Herald Transcript
Herald added a reviewer: Restricted Project. · View Herald Transcript
Herald added subscribers: cfe-commits, libcxx-commits, jplehr and 2 others. · View Herald Transcript
Harbormaster completed remote builds in B229142: Diff 518335.Apr 30 2023, 10:27 AM
philnik added a subscriber: philnik.Apr 30 2023, 11:01 AM
philnik added inline comments.
libcxx/test/tools/clang_tidy_checks/uglify_attributes.cpp
46 ↗(On Diff #518335)

You probably want to #ifdef this based on Clang 16/17.

Mordante added inline comments.Apr 30 2023, 11:32 AM
libcxx/test/tools/clang_tidy_checks/uglify_attributes.cpp
46 ↗(On Diff #518335)

Yeah I noticed that when I uploaded the diff and the CI started the libc++ CI instead of Clang.

For now I'll undo this hunk and will do that in a different patch. That way I can test with the Clang CI.

Mordante updated this revision to Diff 518343.Apr 30 2023, 11:32 AM

Removes libc++ changes.

Harbormaster failed remote builds in B229148: Diff 518343!Apr 30 2023, 11:32 AM
Mordante mentioned this in D149554: [libc++][test] Selects proper C++23 field..Apr 30 2023, 12:25 PM
aaron.ballman added a comment.May 1 2023, 12:20 PM

Thank you for working on this! The Clang changes are mostly all good, but I think we should hold off on changing the value of __cplusplus for the moment as it's not set in stone in the standard yet (I thought it was though, so I'm checking with the editor).

clang/lib/Driver/ToolChains/Clang.cpp
6641–6642

Good catch!

clang/lib/Frontend/InitPreprocessor.cpp
457

I think this might still be premature. I noticed that the draft C++ standard does not have this value set yet: https://github.com/cplusplus/draft/blob/main/source/config.tex#L6

I've emailed the editor to find out if that's a mistake (I am pretty sure we're sending this off to PDTS at some point shortly).

Mordante added a comment.May 2 2023, 9:43 AM
In D149553#4310478, @aaron.ballman wrote:

Thank you for working on this! The Clang changes are mostly all good, but I think we should hold off on changing the value of __cplusplus for the moment as it's not set in stone in the standard yet (I thought it was though, so I'm checking with the editor).

I noticed the same and I was wondering whether I should contact the editor. I noticed some approved papers also have not been merged yet. (These papers are still open issues in the paper repository.)

I'll wait a few days to see whether the draft gets updated otherwise I revert the macro change.

I would be very surprised if the macro gets a different value, that's why I already bumped it.

aaron.ballman added a comment.May 2 2023, 11:45 AM
In D149553#4312788, @Mordante wrote:
In D149553#4310478, @aaron.ballman wrote:

Thank you for working on this! The Clang changes are mostly all good, but I think we should hold off on changing the value of __cplusplus for the moment as it's not set in stone in the standard yet (I thought it was though, so I'm checking with the editor).

I noticed the same and I was wondering whether I should contact the editor. I noticed some approved papers also have not been merged yet. (These papers are still open issues in the paper repository.)

I'll wait a few days to see whether the draft gets updated otherwise I revert the macro change.

I would be very surprised if the macro gets a different value, that's why I already bumped it.

I heard back from the editor yesterday and he said that the macro would be replaced with an appropriate value for the DIS, and that he hopes to ensure that value is published in the next meeting mailing (which would be roughly May 15). So I think we can either wait until that mailing comes out and see if it has a concrete value to land these changes, or we can land everything but the macro value changes and deal with that in a follow up (this might be easier due to rebasing woes given how large this patch is).

ldionne added a subscriber: ldionne.May 2 2023, 2:38 PM

Thanks for doing this! No objection, will let Aaron give the thumbs up.

clang/test/Parser/cxx2b-label.cpp
1

We could also consider renaming those files.

Mordante updated this revision to Diff 519113.May 3 2023, 9:21 AM

Addresses review comments.

Harbormaster failed remote builds in B229716: Diff 519113!May 3 2023, 9:21 AM
Mordante marked 3 inline comments as done.May 3 2023, 9:26 AM
In D149553#4313211, @aaron.ballman wrote:
In D149553#4312788, @Mordante wrote:
In D149553#4310478, @aaron.ballman wrote:

Thank you for working on this! The Clang changes are mostly all good, but I think we should hold off on changing the value of __cplusplus for the moment as it's not set in stone in the standard yet (I thought it was though, so I'm checking with the editor).

I noticed the same and I was wondering whether I should contact the editor. I noticed some approved papers also have not been merged yet. (These papers are still open issues in the paper repository.)

I'll wait a few days to see whether the draft gets updated otherwise I revert the macro change.

I would be very surprised if the macro gets a different value, that's why I already bumped it.

I heard back from the editor yesterday and he said that the macro would be replaced with an appropriate value for the DIS, and that he hopes to ensure that value is published in the next meeting mailing (which would be roughly May 15). So I think we can either wait until that mailing comes out and see if it has a concrete value to land these changes, or we can land everything but the macro value changes and deal with that in a follow up (this might be easier due to rebasing woes given how large this patch is).

Yes I created a new patch for that part. That patch is a lot easier to rebase than this one.

clang/lib/Frontend/InitPreprocessor.cpp
457

I've reverted this and similar parts. They are now in D149761. I will update that patch once editor made a release with the updated __cplusplus macro.

clang/test/Parser/cxx2b-label.cpp
1

I could do that but rather in a follow-up there are still files named like clang/test/Parser/cxx0x-lambda-expressions.cpp too. I'm not sure how much the Clang devs want to remove these code names.

aaron.ballman accepted this revision.May 3 2023, 9:48 AM

LGTM! I did not spot any other concerns beyond the macro value one. Thank you for working on this!

aaron.ballman mentioned this in D146090: [Clang] Updating handling of defaulted comparison operators to reflect changes from P2448R2.May 3 2023, 12:44 PM
Mordante updated this revision to Diff 519500.May 4 2023, 8:03 AM
Mordante marked 2 inline comments as done.

Rebased and trigger CI.

Harbormaster completed remote builds in B229987: Diff 519500.May 4 2023, 8:35 AM
Mordante updated this revision to Diff 519510.May 4 2023, 8:42 AM

CI fixes.

Harbormaster completed remote builds in B229996: Diff 519510.May 4 2023, 10:19 AM
This revision was not accepted when it landed; it landed in state Needs Review.May 4 2023, 10:20 AM
This revision was landed with ongoing or failed builds.
Closed by commit rGba15d186e5ce: [clang] Use -std=c++23 instead of -std=c++2b (authored by Mordante). · Explain Why
This revision was automatically updated to reflect the committed changes.
Mordante added a commit: rGba15d186e5ce: [clang] Use -std=c++23 instead of -std=c++2b.
Mordante mentioned this in rGcc3be76bea66: [libc++][test] Selects proper C++23 field..May 4 2023, 10:51 AM
hliao mentioned this in rGb323b407f76d: [clang] Fix build after https://reviews.llvm.org/D149553.May 4 2023, 11:25 AM
Mordante mentioned this in D150063: [clang] Restores some -std=c++2b tests..May 7 2023, 6:01 AM
Mordante mentioned this in rGfd556368a1a8: [clang] Restores some -std=c++2b tests..May 12 2023, 8:45 AM
Mordante mentioned this in D150450: Add C++26 compile flags..May 15 2023, 8:10 AM

Revision Contents

PathSize
clang-tools-extra/
clang-tidy/
readability/
2 lines
clangd/
index/
4 lines
clang/
docs/
CommandGuide/
8 lines
6 lines
4 lines
include/
clang/
Basic/
12 lines
30 lines
28 lines
42 lines
28 lines
2 lines
6 lines
14 lines
Lex/
2 lines
Sema/
2 lines
lib/
AST/
2 lines
Basic/
2 lines
Targets/
3 lines
Driver/
5 lines
ToolChains/
6 lines
Frontend/
10 lines
Headers/
2 lines
Lex/
8 lines
4 lines
20 lines
8 lines
Parse/
2 lines
6 lines
10 lines
6 lines
Sema/
2 lines
20 lines
10 lines
8 lines
2 lines
4 lines
8 lines
2 lines
test/
AST/
Interp/
4 lines
2 lines
6 lines
CXX/
class/
class.init/
class.copy.elision/
44 lines
dcl.dcl/
dcl.spec/
dcl.constexpr/
12 lines
18 lines
22 lines
dcl.type/
dcl.spec.auto/
6 lines
dcl.type.auto.deduct/
2 lines
drs/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
20 lines
2 lines
2 lines
2 lines
2 lines
expr/
expr.post/
expr.type.conv/
4 lines
expr.prim/
expr.prim.lambda/
8 lines
expr.unary/
expr.new/
2 lines
over/
over.match/
over.match.best/
over.best.ics/
6 lines
over.oper/
12 lines
special/
class.copy/
2 lines
stmt.stmt/
stmt.select/
stmt.if/
2 lines
temp/
temp.decls/
temp.mem/
6 lines
temp.variadic/
2 lines
CodeGenCXX/
2 lines
4 lines
4 lines
CoverageMapping/
2 lines
2 lines
Driver/
2 lines
2 lines
4 lines
4 lines
FixIt/
4 lines
Lexer/
40 lines
4 lines
2 lines
Modules/
2 lines
4 lines
OpenMP/
24 lines
Parser/
6 lines
20 lines
4 lines
12 lines
6 lines
8 lines
14 lines
20 lines
2 lines
24 lines
8 lines
Preprocessor/
32 lines
4 lines
4 lines
2 lines
46 lines
14 lines
Sema/
4 lines
2 lines
SemaCXX/
2 lines
26 lines
20 lines
76 lines
2 lines
14 lines
2 lines
2 lines
2 lines
2 lines
2 lines
6 lines
2 lines
40 lines
22 lines
2 lines
2 lines
4 lines
2 lines
2 lines
8 lines
70 lines
SemaObjCXX/
32 lines
SemaOpenCLCXX/
2 lines
SemaTemplate/
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
www/
2 lines
14 lines

Diff 519553

clang-tools-extra/clang-tidy/readability/RedundantStringCStrCheck.cpp

Show First 20 Lines • Show All 72 Lines • ▼ Show 20 Lines
RedundantStringCStrCheck::RedundantStringCStrCheck(StringRef Name, RedundantStringCStrCheck::RedundantStringCStrCheck(StringRef Name,
ClangTidyContext *Context) ClangTidyContext *Context)
: ClangTidyCheck(Name, Context), : ClangTidyCheck(Name, Context),
StringParameterFunctions(utils::options::parseStringList( StringParameterFunctions(utils::options::parseStringList(
Options.get("StringParameterFunctions", ""))) { Options.get("StringParameterFunctions", ""))) {
if (getLangOpts().CPlusPlus20) if (getLangOpts().CPlusPlus20)
StringParameterFunctions.push_back("::std::format"); StringParameterFunctions.push_back("::std::format");
if (getLangOpts().CPlusPlus2b) if (getLangOpts().CPlusPlus23)
StringParameterFunctions.push_back("::std::print"); StringParameterFunctions.push_back("::std::print");
} }
void RedundantStringCStrCheck::registerMatchers( void RedundantStringCStrCheck::registerMatchers(
ast_matchers::MatchFinder *Finder) { ast_matchers::MatchFinder *Finder) {
// Match expressions of type 'string' or 'string*'. // Match expressions of type 'string' or 'string*'.
const auto StringDecl = type(hasUnqualifiedDesugaredType(recordType( const auto StringDecl = type(hasUnqualifiedDesugaredType(recordType(
hasDeclaration(cxxRecordDecl(hasName("::std::basic_string")))))); hasDeclaration(cxxRecordDecl(hasName("::std::basic_string"))))));
▲ Show 20 Lines • Show All 141 Lines • Show Last 20 Lines

clang-tools-extra/clangd/index/StdLib.cpp

Show First 20 Lines • Show All 41 Lines • ▼ Show 20 Linesllvm::StringLiteral mandatoryHeader(Lang L) {
case CXX: case CXX:
return "vector"; return "vector";
} }
llvm_unreachable("unhandled Lang"); llvm_unreachable("unhandled Lang");
} }
LangStandard::Kind standardFromOpts(const LangOptions &LO) { LangStandard::Kind standardFromOpts(const LangOptions &LO) {
if (LO.CPlusPlus) { if (LO.CPlusPlus) {
if (LO.CPlusPlus2b) if (LO.CPlusPlus23)
return LangStandard::lang_cxx2b; return LangStandard::lang_cxx23;
if (LO.CPlusPlus20) if (LO.CPlusPlus20)
return LangStandard::lang_cxx20; return LangStandard::lang_cxx20;
if (LO.CPlusPlus17) if (LO.CPlusPlus17)
return LangStandard::lang_cxx17; return LangStandard::lang_cxx17;
if (LO.CPlusPlus14) if (LO.CPlusPlus14)
return LangStandard::lang_cxx14; return LangStandard::lang_cxx14;
if (LO.CPlusPlus11) if (LO.CPlusPlus11)
return LangStandard::lang_cxx11; return LangStandard::lang_cxx11;
▲ Show 20 Lines • Show All 295 Lines • Show Last 20 Lines

clang/docs/CommandGuide/clang.rst

Show First 20 Lines • Show All 187 Lines • ▼ Show 20 Lines Supported values for the C++ language are:
| ``c++20`` | ``c++20``
ISO C++ 2020 with amendments ISO C++ 2020 with amendments
| ``gnu++20`` | ``gnu++20``
ISO C++ 2020 with amendments and GNU extensions ISO C++ 2020 with amendments and GNU extensions
| ``c++2b`` | ``c++23``
Working draft for ISO C++ 2023 ISO C++ 2023 with amendments
| ``gnu++2b`` | ``gnu++23``
Working draft for ISO C++ 2023 with GNU extensions ISO C++ 2023 with amendments and GNU extensions
The default C++ language standard is ``gnu++17``. The default C++ language standard is ``gnu++17``.
Supported values for the OpenCL language are: Supported values for the OpenCL language are:
| ``cl1.0`` | ``cl1.0``
OpenCL 1.0 OpenCL 1.0
▲ Show 20 Lines • Show All 506 Lines • Show Last 20 Lines

clang/docs/ReleaseNotes.rst

Show First 20 Lines • Show All 87 Lines • ▼ Show 20 Lines
- Downgraded use of a reserved identifier in a module export declaration from - Downgraded use of a reserved identifier in a module export declaration from
an error to a warning under the ``-Wreserved-module-identifier`` warning an error to a warning under the ``-Wreserved-module-identifier`` warning
group. This warning is enabled by default. This addresses `#61446 group. This warning is enabled by default. This addresses `#61446
<https://github.com/llvm/llvm-project/issues/61446>`_ and allows easier <https://github.com/llvm/llvm-project/issues/61446>`_ and allows easier
building of standard modules. This diagnostic may be strengthened into an building of standard modules. This diagnostic may be strengthened into an
error again in the future once there is a less fragile way to mark a module error again in the future once there is a less fragile way to mark a module
as being part of the implementation rather than a user module. as being part of the implementation rather than a user module.
C++2b Feature Support C++23 Feature Support
^^^^^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^
- Implemented `P2036R3: Change scope of lambda trailing-return-type <https://wg21.link/P2036R3>`_ - Implemented `P2036R3: Change scope of lambda trailing-return-type <https://wg21.link/P2036R3>`_
and `P2579R0 Mitigation strategies for P2036 <https://wg21.link/P2579R0>`_. and `P2579R0 Mitigation strategies for P2036 <https://wg21.link/P2579R0>`_.
These proposals modify how variables captured in lambdas can appear in trailing return type These proposals modify how variables captured in lambdas can appear in trailing return type
expressions and how their types are deduced therein, in all C++ language versions. expressions and how their types are deduced therein, in all C++ language versions.
Resolutions to C++ Defect Reports Resolutions to C++ Defect Reports
▲ Show 20 Lines • Show All 71 Lines • ▼ Show 20 Lines
- A new builtin type trait ``__is_trivially_equaltiy_comparable`` has been added, - A new builtin type trait ``__is_trivially_equaltiy_comparable`` has been added,
which checks whether comparing two instances of a type is equivalent to which checks whether comparing two instances of a type is equivalent to
``memcmp(&lhs, &rhs, sizeof(T)) == 0``. ``memcmp(&lhs, &rhs, sizeof(T)) == 0``.
- Clang now ignores null directives outside of the include guard when deciding - Clang now ignores null directives outside of the include guard when deciding
whether a file can be enabled for the multiple-include optimization. whether a file can be enabled for the multiple-include optimization.
New Compiler Flags New Compiler Flags
------------------ ------------------
- The flag ``-std=c++23`` has been added. This behaves the same as the existing
flag ``-std=c++2b``.
Deprecated Compiler Flags Deprecated Compiler Flags
------------------------- -------------------------
Modified Compiler Flags Modified Compiler Flags
----------------------- -----------------------
Removed Compiler Flags Removed Compiler Flags
▲ Show 20 Lines • Show All 189 Lines • ▼ Show 20 Lines
- Fix crash when evaluating consteval constructor of derived class whose base - Fix crash when evaluating consteval constructor of derived class whose base
has more than one field. has more than one field.
(`#60166 <https://github.com/llvm/llvm-project/issues/60166>`_) (`#60166 <https://github.com/llvm/llvm-project/issues/60166>`_)
- Fix an issue about ``decltype`` in the members of class templates derived from - Fix an issue about ``decltype`` in the members of class templates derived from
templates with related parameters. templates with related parameters.
(`#58674 <https://github.com/llvm/llvm-project/issues/58674>`_) (`#58674 <https://github.com/llvm/llvm-project/issues/58674>`_)
- Fix incorrect deletion of the default constructor of unions in some - Fix incorrect deletion of the default constructor of unions in some
cases. (`#48416 <https://github.com/llvm/llvm-project/issues/48416>`_) cases. (`#48416 <https://github.com/llvm/llvm-project/issues/48416>`_)
- No longer issue a pre-C++2b compatibility warning in ``-pedantic`` mode - No longer issue a pre-C++23 compatibility warning in ``-pedantic`` mode
regading overloaded `operator[]` with more than one parmeter or for static regading overloaded `operator[]` with more than one parmeter or for static
lambdas. (`#61582 <https://github.com/llvm/llvm-project/issues/61582>`_) lambdas. (`#61582 <https://github.com/llvm/llvm-project/issues/61582>`_)
- Stop stripping CV qualifiers from the type of ``this`` when capturing it by value in - Stop stripping CV qualifiers from the type of ``this`` when capturing it by value in
a lambda. a lambda.
(`#50866 <https://github.com/llvm/llvm-project/issues/50866>`_) (`#50866 <https://github.com/llvm/llvm-project/issues/50866>`_)
- Fix ordering of function templates by constraints when they have template - Fix ordering of function templates by constraints when they have template
template parameters with different nested constraints. template parameters with different nested constraints.
- Fix type equivalence comparison between auto types to take constraints into - Fix type equivalence comparison between auto types to take constraints into
▲ Show 20 Lines • Show All 201 Lines • Show Last 20 Lines

clang/docs/StandardCPlusPlusModules.rst

Show First 20 Lines • Show All 428 Lines • ▼ Show 20 Lines.. code-block:: c++
export module M; export module M;
// Use.cpp // Use.cpp
import M; import M;
.. code-block:: console .. code-block:: console
$ clang++ -std=c++20 M.cppm --precompile -o M.pcm $ clang++ -std=c++20 M.cppm --precompile -o M.pcm
$ clang++ -std=c++2b Use.cpp -fprebuilt-module-path=. $ clang++ -std=c++23 Use.cpp -fprebuilt-module-path=.
The compiler would reject the example due to the inconsistent language options. The compiler would reject the example due to the inconsistent language options.
Not all options are language options. Not all options are language options.
For example, the following example is allowed: For example, the following example is allowed:
.. code-block:: console .. code-block:: console
$ clang++ -std=c++20 M.cppm --precompile -o M.pcm $ clang++ -std=c++20 M.cppm --precompile -o M.pcm
▲ Show 20 Lines • Show All 160 Lines • ▼ Show 20 Lines
Known Problems Known Problems
-------------- --------------
The following describes issues in the current implementation of modules. The following describes issues in the current implementation of modules.
Please see https://github.com/llvm/llvm-project/labels/clang%3Amodules for more issues Please see https://github.com/llvm/llvm-project/labels/clang%3Amodules for more issues
or file a new issue if you don't find an existing one. or file a new issue if you don't find an existing one.
If you're going to create a new issue for standard C++ modules, If you're going to create a new issue for standard C++ modules,
please start the title with ``[C++20] [Modules]`` (or ``[C++2b] [Modules]``, etc) please start the title with ``[C++20] [Modules]`` (or ``[C++23] [Modules]``, etc)
and add the label ``clang:modules`` (if you have permissions for that). and add the label ``clang:modules`` (if you have permissions for that).
For higher level support for proposals, you could visit https://clang.llvm.org/cxx_status.html. For higher level support for proposals, you could visit https://clang.llvm.org/cxx_status.html.
Including headers after import is problematic Including headers after import is problematic
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
For example, the following example can be accept: For example, the following example can be accept:
▲ Show 20 Lines • Show All 613 Lines • Show Last 20 Lines

clang/include/clang/Basic/DiagnosticCommonKinds.td

Show First 20 Lines • Show All 204 Lines • ▼ Show 20 Linesdef ext_c99_longlong : Extension<
"'long long' is an extension when C99 mode is not enabled">, "'long long' is an extension when C99 mode is not enabled">,
InGroup<LongLong>; InGroup<LongLong>;
def ext_cxx11_longlong : Extension< def ext_cxx11_longlong : Extension<
"'long long' is a C++11 extension">, "'long long' is a C++11 extension">,
InGroup<CXX11LongLong>; InGroup<CXX11LongLong>;
def warn_cxx98_compat_longlong : Warning< def warn_cxx98_compat_longlong : Warning<
"'long long' is incompatible with C++98">, "'long long' is incompatible with C++98">,
InGroup<CXX98CompatPedantic>, DefaultIgnore; InGroup<CXX98CompatPedantic>, DefaultIgnore;
def ext_cxx2b_size_t_suffix : ExtWarn< def ext_cxx23_size_t_suffix : ExtWarn<
"'size_t' suffix for literals is a C++2b extension">, "'size_t' suffix for literals is a C++23 extension">,
InGroup<CXX2b>; InGroup<CXX23>;
def warn_cxx20_compat_size_t_suffix : Warning< def warn_cxx20_compat_size_t_suffix : Warning<
"'size_t' suffix for literals is incompatible with C++ standards before " "'size_t' suffix for literals is incompatible with C++ standards before "
"C++2b">, InGroup<CXXPre2bCompat>, DefaultIgnore; "C++23">, InGroup<CXXPre23Compat>, DefaultIgnore;
def err_cxx2b_size_t_suffix: Error< def err_cxx23_size_t_suffix: Error<
"'size_t' suffix for literals is a C++2b feature">; "'size_t' suffix for literals is a C++23 feature">;
def err_size_t_literal_too_large: Error< def err_size_t_literal_too_large: Error<
"%select{signed |}0'size_t' literal is out of range of possible " "%select{signed |}0'size_t' literal is out of range of possible "
"%select{signed |}0'size_t' values">; "%select{signed |}0'size_t' values">;
def ext_c2x_bitint_suffix : ExtWarn< def ext_c2x_bitint_suffix : ExtWarn<
"'_BitInt' suffix for literals is a C2x extension">, "'_BitInt' suffix for literals is a C2x extension">,
InGroup<C2x>; InGroup<C2x>;
def warn_c2x_compat_bitint_suffix : Warning< def warn_c2x_compat_bitint_suffix : Warning<
"'_BitInt' suffix for literals is incompatible with C standards before C2x">, "'_BitInt' suffix for literals is incompatible with C standards before C2x">,
▲ Show 20 Lines • Show All 190 Lines • Show Last 20 Lines

clang/include/clang/Basic/DiagnosticGroups.td

Show First 20 Lines • Show All 298 Lines • ▼ Show 20 Lines
def : DiagGroup<"c++98-c++11-c++14-compat-pedantic", def : DiagGroup<"c++98-c++11-c++14-compat-pedantic",
[CXXPre17CompatPedantic]>; [CXXPre17CompatPedantic]>;
def CXXPre20Compat : DiagGroup<"pre-c++20-compat">; def CXXPre20Compat : DiagGroup<"pre-c++20-compat">;
def : DiagGroup<"c++98-c++11-c++14-c++17-compat", [CXXPre20Compat]>; def : DiagGroup<"c++98-c++11-c++14-c++17-compat", [CXXPre20Compat]>;
def CXXPre20CompatPedantic : DiagGroup<"pre-c++20-compat-pedantic", def CXXPre20CompatPedantic : DiagGroup<"pre-c++20-compat-pedantic",
[CXXPre20Compat]>; [CXXPre20Compat]>;
def : DiagGroup<"c++98-c++11-c++14-c++17-compat-pedantic", def : DiagGroup<"c++98-c++11-c++14-c++17-compat-pedantic",
[CXXPre20CompatPedantic]>; [CXXPre20CompatPedantic]>;
def CXXPre2bCompat : DiagGroup<"pre-c++2b-compat">; def CXXPre23Compat : DiagGroup<"pre-c++23-compat">;
def CXXPre2bCompatPedantic : def CXXPre23CompatPedantic :
DiagGroup<"pre-c++2b-compat-pedantic", [CXXPre2bCompat]>; DiagGroup<"pre-c++23-compat-pedantic", [CXXPre23Compat]>;
def CXX98CompatBindToTemporaryCopy : def CXX98CompatBindToTemporaryCopy :
DiagGroup<"c++98-compat-bind-to-temporary-copy">; DiagGroup<"c++98-compat-bind-to-temporary-copy">;
def CXX98CompatLocalTypeTemplateArgs : def CXX98CompatLocalTypeTemplateArgs :
DiagGroup<"c++98-compat-local-type-template-args">; DiagGroup<"c++98-compat-local-type-template-args">;
def CXX98CompatUnnamedTypeTemplateArgs : def CXX98CompatUnnamedTypeTemplateArgs :
DiagGroup<"c++98-compat-unnamed-type-template-args">; DiagGroup<"c++98-compat-unnamed-type-template-args">;
def CXX98Compat : DiagGroup<"c++98-compat", def CXX98Compat : DiagGroup<"c++98-compat",
[CXX98CompatLocalTypeTemplateArgs, [CXX98CompatLocalTypeTemplateArgs,
CXX98CompatUnnamedTypeTemplateArgs, CXX98CompatUnnamedTypeTemplateArgs,
CXXPre14Compat, CXXPre14Compat,
CXXPre17Compat, CXXPre17Compat,
CXXPre20Compat, CXXPre20Compat,
CXXPre2bCompat]>; CXXPre23Compat]>;
// Warnings for C++11 features which are Extensions in C++98 mode. // Warnings for C++11 features which are Extensions in C++98 mode.
def CXX98CompatPedantic : DiagGroup<"c++98-compat-pedantic", def CXX98CompatPedantic : DiagGroup<"c++98-compat-pedantic",
[CXX98Compat, [CXX98Compat,
CXX98CompatBindToTemporaryCopy, CXX98CompatBindToTemporaryCopy,
CXX98CompatExtraSemi, CXX98CompatExtraSemi,
CXXPre14CompatPedantic, CXXPre14CompatPedantic,
CXXPre17CompatPedantic, CXXPre17CompatPedantic,
CXXPre20CompatPedantic, CXXPre20CompatPedantic,
CXXPre2bCompatPedantic]>; CXXPre23CompatPedantic]>;
def CXX11Narrowing : DiagGroup<"c++11-narrowing">; def CXX11Narrowing : DiagGroup<"c++11-narrowing">;
def CXX11WarnInconsistentOverrideDestructor : def CXX11WarnInconsistentOverrideDestructor :
DiagGroup<"inconsistent-missing-destructor-override">; DiagGroup<"inconsistent-missing-destructor-override">;
def CXX11WarnInconsistentOverrideMethod : def CXX11WarnInconsistentOverrideMethod :
DiagGroup<"inconsistent-missing-override">; DiagGroup<"inconsistent-missing-override">;
def CXX11WarnSuggestOverrideDestructor : DiagGroup<"suggest-destructor-override">; def CXX11WarnSuggestOverrideDestructor : DiagGroup<"suggest-destructor-override">;
Show All 13 Lines
def CXX11Compat : DiagGroup<"c++11-compat", def CXX11Compat : DiagGroup<"c++11-compat",
[CXX11Narrowing, [CXX11Narrowing,
CXX11CompatReservedUserDefinedLiteral, CXX11CompatReservedUserDefinedLiteral,
CXX11CompatDeprecatedWritableStr, CXX11CompatDeprecatedWritableStr,
CXXPre14Compat, CXXPre14Compat,
CXXPre17Compat, CXXPre17Compat,
CXXPre20Compat, CXXPre20Compat,
CXXPre2bCompat]>; CXXPre23Compat]>;
def : DiagGroup<"c++0x-compat", [CXX11Compat]>; def : DiagGroup<"c++0x-compat", [CXX11Compat]>;
def CXX11CompatPedantic : DiagGroup<"c++11-compat-pedantic", def CXX11CompatPedantic : DiagGroup<"c++11-compat-pedantic",
[CXX11Compat, [CXX11Compat,
CXXPre14CompatPedantic, CXXPre14CompatPedantic,
CXXPre17CompatPedantic, CXXPre17CompatPedantic,
CXXPre20CompatPedantic, CXXPre20CompatPedantic,
CXXPre2bCompatPedantic]>; CXXPre23CompatPedantic]>;
def CXX14Compat : DiagGroup<"c++14-compat", [CXXPre17Compat, def CXX14Compat : DiagGroup<"c++14-compat", [CXXPre17Compat,
CXXPre20Compat, CXXPre20Compat,
CXXPre2bCompat]>; CXXPre23Compat]>;
def CXX14CompatPedantic : DiagGroup<"c++14-compat-pedantic", def CXX14CompatPedantic : DiagGroup<"c++14-compat-pedantic",
[CXX14Compat, [CXX14Compat,
CXXPre17CompatPedantic, CXXPre17CompatPedantic,
CXXPre20CompatPedantic, CXXPre20CompatPedantic,
CXXPre2bCompatPedantic]>; CXXPre23CompatPedantic]>;
def CXX17Compat : DiagGroup<"c++17-compat", [DeprecatedRegister, def CXX17Compat : DiagGroup<"c++17-compat", [DeprecatedRegister,
DeprecatedIncrementBool, DeprecatedIncrementBool,
CXX17CompatMangling, CXX17CompatMangling,
CXXPre20Compat, CXXPre20Compat,
CXXPre2bCompat]>; CXXPre23Compat]>;
def CXX17CompatPedantic : DiagGroup<"c++17-compat-pedantic", def CXX17CompatPedantic : DiagGroup<"c++17-compat-pedantic",
[CXX17Compat, [CXX17Compat,
CXXPre20CompatPedantic, CXXPre20CompatPedantic,
CXXPre2bCompatPedantic]>; CXXPre23CompatPedantic]>;
def : DiagGroup<"c++1z-compat", [CXX17Compat]>; def : DiagGroup<"c++1z-compat", [CXX17Compat]>;
def CXX20Compat : DiagGroup<"c++20-compat", [CXXPre2bCompat]>; def CXX20Compat : DiagGroup<"c++20-compat", [CXXPre23Compat]>;
def CXX20CompatPedantic : DiagGroup<"c++20-compat-pedantic", def CXX20CompatPedantic : DiagGroup<"c++20-compat-pedantic",
[CXX20Compat, [CXX20Compat,
CXXPre2bCompatPedantic]>; CXXPre23CompatPedantic]>;
def : DiagGroup<"c++2a-compat", [CXX20Compat]>; def : DiagGroup<"c++2a-compat", [CXX20Compat]>;
def : DiagGroup<"c++2a-compat-pedantic", [CXX20CompatPedantic]>; def : DiagGroup<"c++2a-compat-pedantic", [CXX20CompatPedantic]>;
def ExitTimeDestructors : DiagGroup<"exit-time-destructors">; def ExitTimeDestructors : DiagGroup<"exit-time-destructors">;
def FlexibleArrayExtensions : DiagGroup<"flexible-array-extensions">; def FlexibleArrayExtensions : DiagGroup<"flexible-array-extensions">;
def FourByteMultiChar : DiagGroup<"four-char-constants">; def FourByteMultiChar : DiagGroup<"four-char-constants">;
def GlobalConstructors : DiagGroup<"global-constructors">; def GlobalConstructors : DiagGroup<"global-constructors">;
def BitwiseConditionalParentheses: DiagGroup<"bitwise-conditional-parentheses">; def BitwiseConditionalParentheses: DiagGroup<"bitwise-conditional-parentheses">;
▲ Show 20 Lines • Show All 699 Lines • ▼ Show 20 Lines
// A warning group for warnings about using C++17 features as extensions in // A warning group for warnings about using C++17 features as extensions in
// earlier C++ versions. // earlier C++ versions.
def CXX17 : DiagGroup<"c++17-extensions", [CXX17Attrs]>; def CXX17 : DiagGroup<"c++17-extensions", [CXX17Attrs]>;
// A warning group for warnings about using C++20 features as extensions in // A warning group for warnings about using C++20 features as extensions in
// earlier C++ versions. // earlier C++ versions.
def CXX20 : DiagGroup<"c++20-extensions", [CXX20Designator, CXX20Attrs]>; def CXX20 : DiagGroup<"c++20-extensions", [CXX20Designator, CXX20Attrs]>;
// A warning group for warnings about using C++2b features as extensions in // A warning group for warnings about using C++23 features as extensions in
// earlier C++ versions. // earlier C++ versions.
def CXX2b : DiagGroup<"c++2b-extensions">; def CXX23 : DiagGroup<"c++23-extensions">;
def : DiagGroup<"c++0x-extensions", [CXX11]>; def : DiagGroup<"c++0x-extensions", [CXX11]>;
def : DiagGroup<"c++1y-extensions", [CXX14]>; def : DiagGroup<"c++1y-extensions", [CXX14]>;
def : DiagGroup<"c++1z-extensions", [CXX17]>; def : DiagGroup<"c++1z-extensions", [CXX17]>;
def : DiagGroup<"c++2a-extensions", [CXX20]>; def : DiagGroup<"c++2a-extensions", [CXX20]>;
def DelegatingCtorCycles : def DelegatingCtorCycles :
DiagGroup<"delegating-ctor-cycles">; DiagGroup<"delegating-ctor-cycles">;
▲ Show 20 Lines • Show All 304 Lines • Show Last 20 Lines

clang/include/clang/Basic/DiagnosticLexKinds.td

Show First 20 Lines • Show All 132 Lines • ▼ Show 20 Linesdef warn_utf8_symbol_zero_width : Warning<
"identifier contains Unicode character <U+%0> that is invisible in " "identifier contains Unicode character <U+%0> that is invisible in "
"some environments">, InGroup<DiagGroup<"unicode-zero-width">>; "some environments">, InGroup<DiagGroup<"unicode-zero-width">>;
def ext_mathematical_notation : ExtWarn< def ext_mathematical_notation : ExtWarn<
"mathematical notation character <U+%0> in an identifier is a Clang extension">, "mathematical notation character <U+%0> in an identifier is a Clang extension">,
InGroup<DiagGroup<"mathematical-notation-identifier-extension">>; InGroup<DiagGroup<"mathematical-notation-identifier-extension">>;
def ext_delimited_escape_sequence : Extension< def ext_delimited_escape_sequence : Extension<
"%select{delimited|named}0 escape sequences are a " "%select{delimited|named}0 escape sequences are a "
"%select{Clang|C++2b}1 extension">, "%select{Clang|C++23}1 extension">,
InGroup<DiagGroup<"delimited-escape-sequence-extension">>; InGroup<DiagGroup<"delimited-escape-sequence-extension">>;
def warn_cxx2b_delimited_escape_sequence : Warning< def warn_cxx23_delimited_escape_sequence : Warning<
"%select{delimited|named}0 escape sequences are " "%select{delimited|named}0 escape sequences are "
"incompatible with C++ standards before C++2b">, "incompatible with C++ standards before C++23">,
InGroup<CXXPre2bCompat>, DefaultIgnore; InGroup<CXXPre23Compat>, DefaultIgnore;
def err_delimited_escape_empty : Error< def err_delimited_escape_empty : Error<
"delimited escape sequence cannot be empty">; "delimited escape sequence cannot be empty">;
def err_delimited_escape_missing_brace: Error< def err_delimited_escape_missing_brace: Error<
"expected '{' after '\\%0' escape sequence">; "expected '{' after '\\%0' escape sequence">;
def err_delimited_escape_invalid : Error< def err_delimited_escape_invalid : Error<
"invalid digit '%0' in escape sequence">; "invalid digit '%0' in escape sequence">;
def err_hex_escape_no_digits : Error< def err_hex_escape_no_digits : Error<
▲ Show 20 Lines • Show All 235 Lines • ▼ Show 20 Linesdef ext_pp_include_search_ms : ExtWarn<
"#include resolved using non-portable Microsoft search rules as: %0">, "#include resolved using non-portable Microsoft search rules as: %0">,
InGroup<MicrosoftInclude>; InGroup<MicrosoftInclude>;
def ext_pp_ident_directive : Extension<"#ident is a language extension">; def ext_pp_ident_directive : Extension<"#ident is a language extension">;
def ext_pp_include_next_directive : Extension< def ext_pp_include_next_directive : Extension<
"#include_next is a language extension">, InGroup<GNUIncludeNext>; "#include_next is a language extension">, InGroup<GNUIncludeNext>;
def ext_pp_warning_directive : Extension< def ext_pp_warning_directive : Extension<
"#warning is a %select{C2x|C++2b}0 extension">; "#warning is a %select{C2x|C++23}0 extension">;
def warn_cxx2b_compat_warning_directive : Warning< def warn_cxx23_compat_warning_directive : Warning<
"#warning is incompatible with C++ standards before C++2b">, "#warning is incompatible with C++ standards before C++23">,
InGroup<CXXPre2bCompat>, DefaultIgnore; InGroup<CXXPre23Compat>, DefaultIgnore;
def warn_c2x_compat_warning_directive : Warning< def warn_c2x_compat_warning_directive : Warning<
"#warning is incompatible with C standards before C2x">, "#warning is incompatible with C standards before C2x">,
InGroup<CPre2xCompat>, DefaultIgnore; InGroup<CPre2xCompat>, DefaultIgnore;
def ext_pp_extra_tokens_at_eol : ExtWarn< def ext_pp_extra_tokens_at_eol : ExtWarn<
"extra tokens at end of #%0 directive">, InGroup<ExtraTokens>; "extra tokens at end of #%0 directive">, InGroup<ExtraTokens>;
def ext_pp_comma_expr : Extension<"comma operator in operand of #if">; def ext_pp_comma_expr : Extension<"comma operator in operand of #if">;
▲ Show 20 Lines • Show All 323 Lines • ▼ Show 20 Lines
def warn_c2x_compat_pp_directive : Warning< def warn_c2x_compat_pp_directive : Warning<
"use of a '#%select{<BUG IF SEEN>|elifdef|elifndef}0' directive " "use of a '#%select{<BUG IF SEEN>|elifdef|elifndef}0' directive "
"is incompatible with C standards before C2x">, "is incompatible with C standards before C2x">,
InGroup<CPre2xCompat>, DefaultIgnore; InGroup<CPre2xCompat>, DefaultIgnore;
def ext_c2x_pp_directive : ExtWarn< def ext_c2x_pp_directive : ExtWarn<
"use of a '#%select{<BUG IF SEEN>|elifdef|elifndef}0' directive " "use of a '#%select{<BUG IF SEEN>|elifdef|elifndef}0' directive "
"is a C2x extension">, "is a C2x extension">,
InGroup<C2x>; InGroup<C2x>;
def warn_cxx2b_compat_pp_directive : Warning< def warn_cxx23_compat_pp_directive : Warning<
"use of a '#%select{<BUG IF SEEN>|elifdef|elifndef}0' directive " "use of a '#%select{<BUG IF SEEN>|elifdef|elifndef}0' directive "
"is incompatible with C++ standards before C++2b">, "is incompatible with C++ standards before C++23">,
InGroup<CXXPre2bCompat>, DefaultIgnore; InGroup<CXXPre23Compat>, DefaultIgnore;
def ext_cxx2b_pp_directive : ExtWarn< def ext_cxx23_pp_directive : ExtWarn<
"use of a '#%select{<BUG IF SEEN>|elifdef|elifndef}0' directive " "use of a '#%select{<BUG IF SEEN>|elifdef|elifndef}0' directive "
"is a C++2b extension">, "is a C++23 extension">,
InGroup<CXX2b>; InGroup<CXX23>;
def err_pp_visibility_non_macro : Error<"no macro named %0">; def err_pp_visibility_non_macro : Error<"no macro named %0">;
def err_pp_arc_cf_code_audited_syntax : Error<"expected 'begin' or 'end'">; def err_pp_arc_cf_code_audited_syntax : Error<"expected 'begin' or 'end'">;
def err_pp_double_begin_of_arc_cf_code_audited : Error< def err_pp_double_begin_of_arc_cf_code_audited : Error<
"already inside '#pragma clang arc_cf_code_audited'">; "already inside '#pragma clang arc_cf_code_audited'">;
def err_pp_unmatched_end_of_arc_cf_code_audited : Error< def err_pp_unmatched_end_of_arc_cf_code_audited : Error<
"not currently inside '#pragma clang arc_cf_code_audited'">; "not currently inside '#pragma clang arc_cf_code_audited'">;
▲ Show 20 Lines • Show All 198 Lines • Show Last 20 Lines

clang/include/clang/Basic/DiagnosticParseKinds.td

Show First 20 Lines • Show All 294 Lines • ▼ Show 20 Linesdef note_missing_selector_name : Note<
"introduce a parameter name to make %0 part of the selector">; "introduce a parameter name to make %0 part of the selector">;
def note_force_empty_selector_name : Note< def note_force_empty_selector_name : Note<
"or insert whitespace before ':' to use %0 as parameter name " "or insert whitespace before ':' to use %0 as parameter name "
"and have an empty entry in the selector">; "and have an empty entry in the selector">;
def ext_c_label_end_of_compound_statement : ExtWarn< def ext_c_label_end_of_compound_statement : ExtWarn<
"label at end of compound statement is a C2x extension">, "label at end of compound statement is a C2x extension">,
InGroup<C2x>; InGroup<C2x>;
def ext_cxx_label_end_of_compound_statement : ExtWarn< def ext_cxx_label_end_of_compound_statement : ExtWarn<
"label at end of compound statement is a C++2b extension">, "label at end of compound statement is a C++23 extension">,
InGroup<CXX2b>; InGroup<CXX23>;
def warn_c2x_compat_label_end_of_compound_statement : Warning< def warn_c2x_compat_label_end_of_compound_statement : Warning<
"label at end of compound statement is incompatible with C standards before C2x">, "label at end of compound statement is incompatible with C standards before C2x">,
InGroup<CPre2xCompat>, DefaultIgnore; InGroup<CPre2xCompat>, DefaultIgnore;
def warn_cxx20_compat_label_end_of_compound_statement : Warning< def warn_cxx20_compat_label_end_of_compound_statement : Warning<
"label at end of compound statement is incompatible with C++ standards before C++2b">, "label at end of compound statement is incompatible with C++ standards before C++23">,
InGroup<CXXPre2bCompat>, DefaultIgnore; InGroup<CXXPre23Compat>, DefaultIgnore;
def err_address_of_label_outside_fn : Error< def err_address_of_label_outside_fn : Error<
"use of address-of-label extension outside of a function body">; "use of address-of-label extension outside of a function body">;
def err_asm_operand_wide_string_literal : Error< def err_asm_operand_wide_string_literal : Error<
"cannot use %select{unicode|wide|an empty}0 string literal in 'asm'">; "cannot use %select{unicode|wide|an empty}0 string literal in 'asm'">;
def err_expected_selector_for_method : Error< def err_expected_selector_for_method : Error<
"expected selector for Objective-C method">; "expected selector for Objective-C method">;
def err_expected_property_name : Error<"expected property name">; def err_expected_property_name : Error<"expected property name">;
▲ Show 20 Lines • Show All 242 Lines • ▼ Show 20 Linesdef err_expected_lparen_after_type : Error<
"expected '(' for function-style cast or type construction">; "expected '(' for function-style cast or type construction">;
def err_expected_init_in_condition : Error< def err_expected_init_in_condition : Error<
"variable declaration in condition must have an initializer">; "variable declaration in condition must have an initializer">;
def err_expected_init_in_condition_lparen : Error< def err_expected_init_in_condition_lparen : Error<
"variable declaration in condition cannot have a parenthesized initializer">; "variable declaration in condition cannot have a parenthesized initializer">;
def err_extraneous_rparen_in_condition : Error< def err_extraneous_rparen_in_condition : Error<
"extraneous ')' after condition, expected a statement">; "extraneous ')' after condition, expected a statement">;
def ext_alias_in_init_statement : ExtWarn< def ext_alias_in_init_statement : ExtWarn<
"alias declaration in this context is a C++2b extension">, "alias declaration in this context is a C++23 extension">,
InGroup<CXX2b>; InGroup<CXX23>;
def warn_cxx20_alias_in_init_statement : Warning< def warn_cxx20_alias_in_init_statement : Warning<
"alias declaration in this context is incompatible with C++ standards before C++2b">, "alias declaration in this context is incompatible with C++ standards before C++23">,
DefaultIgnore, InGroup<CXXPre2bCompat>; DefaultIgnore, InGroup<CXXPre23Compat>;
def warn_dangling_else : Warning< def warn_dangling_else : Warning<
"add explicit braces to avoid dangling else">, "add explicit braces to avoid dangling else">,
InGroup<DanglingElse>; InGroup<DanglingElse>;
def err_expected_member_or_base_name : Error< def err_expected_member_or_base_name : Error<
"expected class member or base class name">; "expected class member or base class name">;
def err_expected_lbrace_after_base_specifiers : Error< def err_expected_lbrace_after_base_specifiers : Error<
"expected '{' after base class list">; "expected '{' after base class list">;
def err_missing_end_of_definition : Error< def err_missing_end_of_definition : Error<
▲ Show 20 Lines • Show All 65 Lines • ▼ Show 20 Lines
def err_super_in_using_declaration : Error< def err_super_in_using_declaration : Error<
"'__super' cannot be used with a using declaration">; "'__super' cannot be used with a using declaration">;
def ext_constexpr_if : ExtWarn< def ext_constexpr_if : ExtWarn<
"constexpr if is a C++17 extension">, InGroup<CXX17>; "constexpr if is a C++17 extension">, InGroup<CXX17>;
def warn_cxx14_compat_constexpr_if : Warning< def warn_cxx14_compat_constexpr_if : Warning<
"constexpr if is incompatible with C++ standards before C++17">, "constexpr if is incompatible with C++ standards before C++17">,
DefaultIgnore, InGroup<CXXPre17Compat>; DefaultIgnore, InGroup<CXXPre17Compat>;
def ext_consteval_if : ExtWarn< def ext_consteval_if : ExtWarn<
"consteval if is a C++2b extension">, "consteval if is a C++23 extension">,
InGroup<CXX2b>; InGroup<CXX23>;
def warn_cxx20_compat_consteval_if : Warning< def warn_cxx20_compat_consteval_if : Warning<
"consteval if is incompatible with C++ standards before C++2b">, "consteval if is incompatible with C++ standards before C++23">,
InGroup<CXXPre2bCompat>, DefaultIgnore; InGroup<CXXPre23Compat>, DefaultIgnore;
def ext_init_statement : ExtWarn< def ext_init_statement : ExtWarn<
"'%select{if|switch}0' initialization statements are a C++17 extension">, "'%select{if|switch}0' initialization statements are a C++17 extension">,
InGroup<CXX17>; InGroup<CXX17>;
def warn_cxx14_compat_init_statement : Warning< def warn_cxx14_compat_init_statement : Warning<
"%select{if|switch}0 initialization statements are incompatible with " "%select{if|switch}0 initialization statements are incompatible with "
"C++ standards before C++17">, DefaultIgnore, InGroup<CXXPre17Compat>; "C++ standards before C++17">, DefaultIgnore, InGroup<CXXPre17Compat>;
def ext_for_range_init_stmt : ExtWarn< def ext_for_range_init_stmt : ExtWarn<
▲ Show 20 Lines • Show All 341 Lines • ▼ Show 20 Lines
def err_lambda_capture_misplaced_ellipsis : Error< def err_lambda_capture_misplaced_ellipsis : Error<
"ellipsis in pack %select{|init-}0capture must appear %select{after|before}0 " "ellipsis in pack %select{|init-}0capture must appear %select{after|before}0 "
"the name of the capture">; "the name of the capture">;
def err_lambda_capture_multiple_ellipses : Error< def err_lambda_capture_multiple_ellipses : Error<
"multiple ellipses in pack capture">; "multiple ellipses in pack capture">;
def err_capture_default_first : Error< def err_capture_default_first : Error<
"capture default must be first">; "capture default must be first">;
def ext_decl_attrs_on_lambda : ExtWarn< def ext_decl_attrs_on_lambda : ExtWarn<
"an attribute specifier sequence in this position is a C++2b extension">, "an attribute specifier sequence in this position is a C++23 extension">,
InGroup<CXX2b>; InGroup<CXX23>;
def ext_lambda_missing_parens : ExtWarn< def ext_lambda_missing_parens : ExtWarn<
"lambda without a parameter clause is a C++2b extension">, "lambda without a parameter clause is a C++23 extension">,
InGroup<CXX2b>; InGroup<CXX23>;
def warn_cxx20_compat_decl_attrs_on_lambda : Warning< def warn_cxx20_compat_decl_attrs_on_lambda : Warning<
"an attribute specifier sequence in this position is incompatible with C++ " "an attribute specifier sequence in this position is incompatible with C++ "
"standards before C++2b">, InGroup<CXXPre2bCompat>, DefaultIgnore; "standards before C++23">, InGroup<CXXPre23Compat>, DefaultIgnore;
// C++17 lambda expressions // C++17 lambda expressions
def err_expected_star_this_capture : Error< def err_expected_star_this_capture : Error<
"expected 'this' following '*' in lambda capture list">; "expected 'this' following '*' in lambda capture list">;
// C++17 constexpr lambda expressions // C++17 constexpr lambda expressions
def warn_cxx14_compat_constexpr_on_lambda : Warning< def warn_cxx14_compat_constexpr_on_lambda : Warning<
"constexpr on lambda expressions is incompatible with C++ standards before C++17">, "constexpr on lambda expressions is incompatible with C++ standards before C++17">,
InGroup<CXXPre17Compat>, DefaultIgnore; InGroup<CXXPre17Compat>, DefaultIgnore;
def ext_constexpr_on_lambda_cxx17 : ExtWarn< def ext_constexpr_on_lambda_cxx17 : ExtWarn<
"'constexpr' on lambda expressions is a C++17 extension">, InGroup<CXX17>; "'constexpr' on lambda expressions is a C++17 extension">, InGroup<CXX17>;
// C++20 template lambdas // C++20 template lambdas
def ext_lambda_template_parameter_list: ExtWarn< def ext_lambda_template_parameter_list: ExtWarn<
"explicit template parameter list for lambdas is a C++20 extension">, "explicit template parameter list for lambdas is a C++20 extension">,
InGroup<CXX20>; InGroup<CXX20>;
def warn_cxx17_compat_lambda_template_parameter_list: Warning< def warn_cxx17_compat_lambda_template_parameter_list: Warning<
"explicit template parameter list for lambdas is incompatible with " "explicit template parameter list for lambdas is incompatible with "
"C++ standards before C++20">, InGroup<CXXPre20Compat>, DefaultIgnore; "C++ standards before C++20">, InGroup<CXXPre20Compat>, DefaultIgnore;
def err_lambda_template_parameter_list_empty : Error< def err_lambda_template_parameter_list_empty : Error<
"lambda template parameter list cannot be empty">; "lambda template parameter list cannot be empty">;
// C++2b static lambdas // C++23 static lambdas
def err_static_lambda: ExtWarn< def err_static_lambda: ExtWarn<
"static lambdas are a C++2b extension">, InGroup<CXX2b>; "static lambdas are a C++23 extension">, InGroup<CXX23>;
def warn_cxx20_compat_static_lambda : Warning< def warn_cxx20_compat_static_lambda : Warning<
"static lambdas are incompatible with C++ standards before C++2b">, "static lambdas are incompatible with C++ standards before C++23">,
InGroup<CXXPre2bCompat>, DefaultIgnore; InGroup<CXXPre23Compat>, DefaultIgnore;
def err_static_mutable_lambda : Error< def err_static_mutable_lambda : Error<
"lambda cannot be both mutable and static">; "lambda cannot be both mutable and static">;
def err_static_lambda_captures : Error< def err_static_lambda_captures : Error<
"a static lambda cannot have any captures">; "a static lambda cannot have any captures">;
// Availability attribute // Availability attribute
def err_expected_version : Error< def err_expected_version : Error<
"expected a version of the form 'major[.minor[.subminor]]'">; "expected a version of the form 'major[.minor[.subminor]]'">;
▲ Show 20 Lines • Show All 603 Lines • Show Last 20 Lines

clang/include/clang/Basic/DiagnosticSemaKinds.td

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 2,364 Lines • ▼ Show 20 Linesdef err_auto_var_init_paren_braces : Error<
"%select{parenthesized|nested}0 initializer list">; "%select{parenthesized|nested}0 initializer list">;
def err_auto_new_ctor_multiple_expressions : Error< def err_auto_new_ctor_multiple_expressions : Error<
"new expression for type %0 contains multiple constructor arguments">; "new expression for type %0 contains multiple constructor arguments">;
def err_auto_expr_init_paren_braces : Error< def err_auto_expr_init_paren_braces : Error<
"cannot deduce actual type for %1 from " "cannot deduce actual type for %1 from "
"%select{parenthesized|nested}0 initializer list">; "%select{parenthesized|nested}0 initializer list">;
def warn_cxx20_compat_auto_expr : Warning< def warn_cxx20_compat_auto_expr : Warning<
"'auto' as a functional-style cast is incompatible with C++ standards " "'auto' as a functional-style cast is incompatible with C++ standards "
"before C++2b">, InGroup<CXXPre2bCompat>, DefaultIgnore; "before C++23">, InGroup<CXXPre23Compat>, DefaultIgnore;
def err_auto_missing_trailing_return : Error< def err_auto_missing_trailing_return : Error<
"'auto' return without trailing return type; deduced return types are a " "'auto' return without trailing return type; deduced return types are a "
"C++14 extension">; "C++14 extension">;
def err_deduced_return_type : Error< def err_deduced_return_type : Error<
"deduced return types are a C++14 extension">; "deduced return types are a C++14 extension">;
def err_trailing_return_without_auto : Error< def err_trailing_return_without_auto : Error<
"function with trailing return type must specify return type 'auto', not %0">; "function with trailing return type must specify return type 'auto', not %0">;
def err_trailing_return_in_parens : Error< def err_trailing_return_in_parens : Error<
▲ Show 20 Lines • Show All 340 Lines • ▼ Show 20 Linesdef warn_cxx11_compat_constexpr_body_invalid_stmt : Warning<
InGroup<CXXPre14Compat>, DefaultIgnore; InGroup<CXXPre14Compat>, DefaultIgnore;
def ext_constexpr_body_invalid_stmt_cxx20 : ExtWarn< def ext_constexpr_body_invalid_stmt_cxx20 : ExtWarn<
"use of this statement in a constexpr %select{function|constructor}0 " "use of this statement in a constexpr %select{function|constructor}0 "
"is a C++20 extension">, InGroup<CXX20>; "is a C++20 extension">, InGroup<CXX20>;
def warn_cxx17_compat_constexpr_body_invalid_stmt : Warning< def warn_cxx17_compat_constexpr_body_invalid_stmt : Warning<
"use of this statement in a constexpr %select{function|constructor}0 " "use of this statement in a constexpr %select{function|constructor}0 "
"is incompatible with C++ standards before C++20">, "is incompatible with C++ standards before C++20">,
InGroup<CXXPre20Compat>, DefaultIgnore; InGroup<CXXPre20Compat>, DefaultIgnore;
def ext_constexpr_body_invalid_stmt_cxx2b : ExtWarn< def ext_constexpr_body_invalid_stmt_cxx23 : ExtWarn<
"use of this statement in a constexpr %select{function|constructor}0 " "use of this statement in a constexpr %select{function|constructor}0 "
"is a C++2b extension">, InGroup<CXX2b>; "is a C++23 extension">, InGroup<CXX23>;
def warn_cxx20_compat_constexpr_body_invalid_stmt : Warning< def warn_cxx20_compat_constexpr_body_invalid_stmt : Warning<
"use of this statement in a constexpr %select{function|constructor}0 " "use of this statement in a constexpr %select{function|constructor}0 "
"is incompatible with C++ standards before C++2b">, "is incompatible with C++ standards before C++23">,
InGroup<CXXPre2bCompat>, DefaultIgnore; InGroup<CXXPre23Compat>, DefaultIgnore;
def ext_constexpr_type_definition : ExtWarn< def ext_constexpr_type_definition : ExtWarn<
"type definition in a constexpr %select{function|constructor}0 " "type definition in a constexpr %select{function|constructor}0 "
"is a C++14 extension">, InGroup<CXX14>; "is a C++14 extension">, InGroup<CXX14>;
def warn_cxx11_compat_constexpr_type_definition : Warning< def warn_cxx11_compat_constexpr_type_definition : Warning<
"type definition in a constexpr %select{function|constructor}0 " "type definition in a constexpr %select{function|constructor}0 "
"is incompatible with C++ standards before C++14">, "is incompatible with C++ standards before C++14">,
InGroup<CXXPre14Compat>, DefaultIgnore; InGroup<CXXPre14Compat>, DefaultIgnore;
def err_constexpr_vla : Error< def err_constexpr_vla : Error<
"variably-modified type %0 cannot be used in a constexpr " "variably-modified type %0 cannot be used in a constexpr "
"%select{function|constructor}1">; "%select{function|constructor}1">;
def ext_constexpr_local_var : ExtWarn< def ext_constexpr_local_var : ExtWarn<
"variable declaration in a constexpr %select{function|constructor}0 " "variable declaration in a constexpr %select{function|constructor}0 "
"is a C++14 extension">, InGroup<CXX14>; "is a C++14 extension">, InGroup<CXX14>;
def warn_cxx11_compat_constexpr_local_var : Warning< def warn_cxx11_compat_constexpr_local_var : Warning<
"variable declaration in a constexpr %select{function|constructor}0 " "variable declaration in a constexpr %select{function|constructor}0 "
"is incompatible with C++ standards before C++14">, "is incompatible with C++ standards before C++14">,
InGroup<CXXPre14Compat>, DefaultIgnore; InGroup<CXXPre14Compat>, DefaultIgnore;
def ext_constexpr_static_var : ExtWarn< def ext_constexpr_static_var : ExtWarn<
"definition of a %select{static|thread_local}1 variable " "definition of a %select{static|thread_local}1 variable "
"in a constexpr %select{function|constructor}0 " "in a constexpr %select{function|constructor}0 "
"is a C++2b extension">, InGroup<CXX2b>; "is a C++23 extension">, InGroup<CXX23>;
def warn_cxx20_compat_constexpr_var : Warning< def warn_cxx20_compat_constexpr_var : Warning<
"definition of a %select{static variable|thread_local variable|variable " "definition of a %select{static variable|thread_local variable|variable "
"of non-literal type}1 in a constexpr %select{function|constructor}0 " "of non-literal type}1 in a constexpr %select{function|constructor}0 "
"is incompatible with C++ standards before C++2b">, "is incompatible with C++ standards before C++23">,
InGroup<CXXPre2bCompat>, DefaultIgnore; InGroup<CXXPre23Compat>, DefaultIgnore;
def err_constexpr_local_var_non_literal_type : Error< def err_constexpr_local_var_non_literal_type : Error<
"variable of non-literal type %1 cannot be defined in a constexpr " "variable of non-literal type %1 cannot be defined in a constexpr "
"%select{function|constructor}0 before C++2b">; "%select{function|constructor}0 before C++23">;
def ext_constexpr_local_var_no_init : ExtWarn< def ext_constexpr_local_var_no_init : ExtWarn<
"uninitialized variable in a constexpr %select{function|constructor}0 " "uninitialized variable in a constexpr %select{function|constructor}0 "
"is a C++20 extension">, InGroup<CXX20>; "is a C++20 extension">, InGroup<CXX20>;
def warn_cxx17_compat_constexpr_local_var_no_init : Warning< def warn_cxx17_compat_constexpr_local_var_no_init : Warning<
"uninitialized variable in a constexpr %select{function|constructor}0 " "uninitialized variable in a constexpr %select{function|constructor}0 "
"is incompatible with C++ standards before C++20">, "is incompatible with C++ standards before C++20">,
InGroup<CXXPre20Compat>, DefaultIgnore; InGroup<CXXPre20Compat>, DefaultIgnore;
def ext_constexpr_function_never_constant_expr : ExtWarn< def ext_constexpr_function_never_constant_expr : ExtWarn<
▲ Show 20 Lines • Show All 3,965 Lines • ▼ Show 20 Linesdef err_subscript_nonfragile_interface : Error<
"this architecture and platform">; "this architecture and platform">;
def err_arithmetic_nonfragile_interface : Error< def err_arithmetic_nonfragile_interface : Error<
"arithmetic on pointer to interface %0, which is not a constant size for " "arithmetic on pointer to interface %0, which is not a constant size for "
"this architecture and platform">; "this architecture and platform">;
def warn_deprecated_comma_subscript : Warning< def warn_deprecated_comma_subscript : Warning<
"top-level comma expression in array subscript is deprecated " "top-level comma expression in array subscript is deprecated "
"in C++20 and unsupported in C++2b">, "in C++20 and unsupported in C++23">,
InGroup<DeprecatedCommaSubscript>; InGroup<DeprecatedCommaSubscript>;
def ext_subscript_non_lvalue : Extension< def ext_subscript_non_lvalue : Extension<
"ISO C90 does not allow subscripting non-lvalue array">; "ISO C90 does not allow subscripting non-lvalue array">;
def err_typecheck_subscript_value : Error< def err_typecheck_subscript_value : Error<
"subscripted value is not an array, pointer, or vector">; "subscripted value is not an array, pointer, or vector">;
def err_typecheck_subscript_not_integer : Error< def err_typecheck_subscript_not_integer : Error<
"array subscript is not an integer">; "array subscript is not an integer">;
▲ Show 20 Lines • Show All 2,387 Lines • ▼ Show 20 Lines
// C++ operator overloading // C++ operator overloading
def err_operator_overload_needs_class_or_enum : Error< def err_operator_overload_needs_class_or_enum : Error<
"overloaded %0 must have at least one parameter of class " "overloaded %0 must have at least one parameter of class "
"or enumeration type">; "or enumeration type">;
def err_operator_overload_variadic : Error<"overloaded %0 cannot be variadic">; def err_operator_overload_variadic : Error<"overloaded %0 cannot be variadic">;
def warn_cxx20_compat_operator_overload_static : Warning< def warn_cxx20_compat_operator_overload_static : Warning<
"declaring overloaded %0 as 'static' is incompatible with C++ standards " "declaring overloaded %0 as 'static' is incompatible with C++ standards "
"before C++2b">, InGroup<CXXPre2bCompat>, DefaultIgnore; "before C++23">, InGroup<CXXPre23Compat>, DefaultIgnore;
def ext_operator_overload_static : ExtWarn< def ext_operator_overload_static : ExtWarn<
"declaring overloaded %0 as 'static' is a C++2b extension">, InGroup<CXX2b>; "declaring overloaded %0 as 'static' is a C++23 extension">, InGroup<CXX23>;
def err_operator_overload_static : Error< def err_operator_overload_static : Error<
"overloaded %0 cannot be a static member function">; "overloaded %0 cannot be a static member function">;
def err_operator_overload_default_arg : Error< def err_operator_overload_default_arg : Error<
"parameter of overloaded %0 cannot have a default argument">; "parameter of overloaded %0 cannot have a default argument">;
def ext_subscript_overload : Warning< def ext_subscript_overload : Warning<
"overloaded %0 with %select{no|a defaulted|more than one}1 parameter is a " "overloaded %0 with %select{no|a defaulted|more than one}1 parameter is a "
"C++2b extension">, InGroup<CXXPre2bCompat>, DefaultIgnore; "C++23 extension">, InGroup<CXXPre23Compat>, DefaultIgnore;
def error_subscript_overload : Error< def error_subscript_overload : Error<
"overloaded %0 cannot have %select{no|a defaulted|more than one}1 parameter before C++2b">; "overloaded %0 cannot have %select{no|a defaulted|more than one}1 parameter before C++23">;
def err_operator_overload_must_be : Error< def err_operator_overload_must_be : Error<
"overloaded %0 must be a %select{unary|binary|unary or binary}2 operator " "overloaded %0 must be a %select{unary|binary|unary or binary}2 operator "
"(has %1 parameter%s1)">; "(has %1 parameter%s1)">;
def err_operator_overload_must_be_member : Error< def err_operator_overload_must_be_member : Error<
"overloaded %0 must be a non-static member function">; "overloaded %0 must be a non-static member function">;
def err_operator_overload_post_incdec_must_be_int : Error< def err_operator_overload_post_incdec_must_be_int : Error<
▲ Show 20 Lines • Show All 2,654 Lines • Show Last 20 Lines

clang/include/clang/Basic/LangOptions.def

Show First 20 Lines • Show All 91 Lines • ▼ Show 20 Lines
LANGOPT(MicrosoftExt , 1, 0, "Microsoft C++ extensions") LANGOPT(MicrosoftExt , 1, 0, "Microsoft C++ extensions")
LANGOPT(AsmBlocks , 1, 0, "Microsoft inline asm blocks") LANGOPT(AsmBlocks , 1, 0, "Microsoft inline asm blocks")
LANGOPT(Borland , 1, 0, "Borland extensions") LANGOPT(Borland , 1, 0, "Borland extensions")
LANGOPT(CPlusPlus , 1, 0, "C++") LANGOPT(CPlusPlus , 1, 0, "C++")
LANGOPT(CPlusPlus11 , 1, 0, "C++11") LANGOPT(CPlusPlus11 , 1, 0, "C++11")
LANGOPT(CPlusPlus14 , 1, 0, "C++14") LANGOPT(CPlusPlus14 , 1, 0, "C++14")
LANGOPT(CPlusPlus17 , 1, 0, "C++17") LANGOPT(CPlusPlus17 , 1, 0, "C++17")
LANGOPT(CPlusPlus20 , 1, 0, "C++20") LANGOPT(CPlusPlus20 , 1, 0, "C++20")
LANGOPT(CPlusPlus2b , 1, 0, "C++2b") LANGOPT(CPlusPlus23 , 1, 0, "C++23")
LANGOPT(ObjC , 1, 0, "Objective-C") LANGOPT(ObjC , 1, 0, "Objective-C")
BENIGN_LANGOPT(ObjCDefaultSynthProperties , 1, 0, BENIGN_LANGOPT(ObjCDefaultSynthProperties , 1, 0,
"Objective-C auto-synthesized properties") "Objective-C auto-synthesized properties")
BENIGN_LANGOPT(EncodeExtendedBlockSig , 1, 0, BENIGN_LANGOPT(EncodeExtendedBlockSig , 1, 0,
"Encoding extended block type signature") "Encoding extended block type signature")
BENIGN_LANGOPT(EncodeCXXClassTemplateSpec , 1, 0, BENIGN_LANGOPT(EncodeCXXClassTemplateSpec , 1, 0,
"Fully encode c++ class template specialization") "Fully encode c++ class template specialization")
BENIGN_LANGOPT(ObjCInferRelatedResultType , 1, 1, BENIGN_LANGOPT(ObjCInferRelatedResultType , 1, 1,
▲ Show 20 Lines • Show All 367 Lines • Show Last 20 Lines

clang/include/clang/Basic/LangStandard.h

Show First 20 Lines • Show All 49 Lines • ▼ Show 20 Linesenum LangFeatures {
C11 = (1 << 2), C11 = (1 << 2),
C17 = (1 << 3), C17 = (1 << 3),
C2x = (1 << 4), C2x = (1 << 4),
CPlusPlus = (1 << 5), CPlusPlus = (1 << 5),
CPlusPlus11 = (1 << 6), CPlusPlus11 = (1 << 6),
CPlusPlus14 = (1 << 7), CPlusPlus14 = (1 << 7),
CPlusPlus17 = (1 << 8), CPlusPlus17 = (1 << 8),
CPlusPlus20 = (1 << 9), CPlusPlus20 = (1 << 9),
CPlusPlus2b = (1 << 10), CPlusPlus23 = (1 << 10),
Digraphs = (1 << 11), Digraphs = (1 << 11),
GNUMode = (1 << 12), GNUMode = (1 << 12),
HexFloat = (1 << 13), HexFloat = (1 << 13),
OpenCL = (1 << 14), OpenCL = (1 << 14),
HLSL = (1 << 15) HLSL = (1 << 15)
}; };
/// LangStandard - Information about the properties of a particular language /// LangStandard - Information about the properties of a particular language
▲ Show 20 Lines • Show All 46 Lines • ▼ Show 20 Linespublic:
bool isCPlusPlus14() const { return Flags & CPlusPlus14; } bool isCPlusPlus14() const { return Flags & CPlusPlus14; }
/// isCPlusPlus17 - Language is a C++17 variant (or later). /// isCPlusPlus17 - Language is a C++17 variant (or later).
bool isCPlusPlus17() const { return Flags & CPlusPlus17; } bool isCPlusPlus17() const { return Flags & CPlusPlus17; }
/// isCPlusPlus20 - Language is a C++20 variant (or later). /// isCPlusPlus20 - Language is a C++20 variant (or later).
bool isCPlusPlus20() const { return Flags & CPlusPlus20; } bool isCPlusPlus20() const { return Flags & CPlusPlus20; }
/// isCPlusPlus2b - Language is a post-C++20 variant (or later). /// isCPlusPlus23 - Language is a post-C++23 variant (or later).
bool isCPlusPlus2b() const { return Flags & CPlusPlus2b; } bool isCPlusPlus23() const { return Flags & CPlusPlus23; }
/// hasDigraphs - Language supports digraphs. /// hasDigraphs - Language supports digraphs.
bool hasDigraphs() const { return Flags & Digraphs; } bool hasDigraphs() const { return Flags & Digraphs; }
/// isGNUMode - Language includes GNU extensions. /// isGNUMode - Language includes GNU extensions.
bool isGNUMode() const { return Flags & GNUMode; } bool isGNUMode() const { return Flags & GNUMode; }
/// hasHexFloats - Language supports hexadecimal float constants. /// hasHexFloats - Language supports hexadecimal float constants.
Show All 16 Lines

clang/include/clang/Basic/LangStandards.def

Show First 20 Lines • Show All 145 Lines • ▼ Show 20 Lines
LANGSTANDARD_ALIAS_DEPR(cxx20, "c++2a") LANGSTANDARD_ALIAS_DEPR(cxx20, "c++2a")
LANGSTANDARD(gnucxx20, "gnu++20", LANGSTANDARD(gnucxx20, "gnu++20",
CXX, "ISO C++ 2020 DIS with GNU extensions", CXX, "ISO C++ 2020 DIS with GNU extensions",
LineComment | CPlusPlus | CPlusPlus11 | CPlusPlus14 | CPlusPlus17 | LineComment | CPlusPlus | CPlusPlus11 | CPlusPlus14 | CPlusPlus17 |
CPlusPlus20 | Digraphs | HexFloat | GNUMode) CPlusPlus20 | Digraphs | HexFloat | GNUMode)
LANGSTANDARD_ALIAS_DEPR(gnucxx20, "gnu++2a") LANGSTANDARD_ALIAS_DEPR(gnucxx20, "gnu++2a")
LANGSTANDARD(cxx2b, "c++2b", LANGSTANDARD(cxx23, "c++23",
CXX, "Working draft for ISO C++ 2023 DIS", CXX, "ISO C++ 2023 DIS",
LineComment | CPlusPlus | CPlusPlus11 | CPlusPlus14 | CPlusPlus17 | LineComment | CPlusPlus | CPlusPlus11 | CPlusPlus14 | CPlusPlus17 |
CPlusPlus20 | CPlusPlus2b | Digraphs | HexFloat) CPlusPlus20 | CPlusPlus23 | Digraphs | HexFloat)
LANGSTANDARD_ALIAS_DEPR(cxx23, "c++2b")
LANGSTANDARD(gnucxx2b, "gnu++2b", LANGSTANDARD(gnucxx23, "gnu++23",
CXX, "Working draft for ISO C++ 2023 DIS with GNU extensions", CXX, "ISO C++ 2023 DIS with GNU extensions",
LineComment | CPlusPlus | CPlusPlus11 | CPlusPlus14 | CPlusPlus17 | LineComment | CPlusPlus | CPlusPlus11 | CPlusPlus14 | CPlusPlus17 |
CPlusPlus20 | CPlusPlus2b | Digraphs | HexFloat | GNUMode) CPlusPlus20 | CPlusPlus23 | Digraphs | HexFloat | GNUMode)
LANGSTANDARD_ALIAS_DEPR(gnucxx23, "gnu++2b")
// OpenCL // OpenCL
LANGSTANDARD(opencl10, "cl1.0", LANGSTANDARD(opencl10, "cl1.0",
OpenCL, "OpenCL 1.0", OpenCL, "OpenCL 1.0",
LineComment | C99 | Digraphs | HexFloat | OpenCL) LineComment | C99 | Digraphs | HexFloat | OpenCL)
LANGSTANDARD_ALIAS_DEPR(opencl10, "cl") LANGSTANDARD_ALIAS_DEPR(opencl10, "cl")
LANGSTANDARD(opencl11, "cl1.1", LANGSTANDARD(opencl11, "cl1.1",
▲ Show 20 Lines • Show All 73 Lines • Show Last 20 Lines

clang/include/clang/Lex/LiteralSupport.h

Show First 20 Lines • Show All 57 Lines • ▼ Show 20 Lines
public: public:
NumericLiteralParser(StringRef TokSpelling, SourceLocation TokLoc, NumericLiteralParser(StringRef TokSpelling, SourceLocation TokLoc,
const SourceManager &SM, const LangOptions &LangOpts, const SourceManager &SM, const LangOptions &LangOpts,
const TargetInfo &Target, DiagnosticsEngine &Diags); const TargetInfo &Target, DiagnosticsEngine &Diags);
bool hadError : 1; bool hadError : 1;
bool isUnsigned : 1; bool isUnsigned : 1;
bool isLong : 1; // This is *not* set for long long. bool isLong : 1; // This is *not* set for long long.
bool isLongLong : 1; bool isLongLong : 1;
bool isSizeT : 1; // 1z, 1uz (C++2b) bool isSizeT : 1; // 1z, 1uz (C++23)
bool isHalf : 1; // 1.0h bool isHalf : 1; // 1.0h
bool isFloat : 1; // 1.0f bool isFloat : 1; // 1.0f
bool isImaginary : 1; // 1.0i bool isImaginary : 1; // 1.0i
bool isFloat16 : 1; // 1.0f16 bool isFloat16 : 1; // 1.0f16
bool isFloat128 : 1; // 1.0q bool isFloat128 : 1; // 1.0q
bool isFract : 1; // 1.0hr/r/lr/uhr/ur/ulr bool isFract : 1; // 1.0hr/r/lr/uhr/ur/ulr
bool isAccum : 1; // 1.0hk/k/lk/uhk/uk/ulk bool isAccum : 1; // 1.0hk/k/lk/uhk/uk/ulk
bool isBitInt : 1; // 1wb, 1uwb (C2x) bool isBitInt : 1; // 1wb, 1uwb (C2x)
▲ Show 20 Lines • Show All 223 Lines • Show Last 20 Lines

clang/include/clang/Sema/Sema.h

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 1,364 Lines • ▼ Show 20 Lines bool isConstantEvaluated() const {
return Context == ExpressionEvaluationContext::ConstantEvaluated || return Context == ExpressionEvaluationContext::ConstantEvaluated ||
Context == ExpressionEvaluationContext::ImmediateFunctionContext; Context == ExpressionEvaluationContext::ImmediateFunctionContext;
} }
bool isImmediateFunctionContext() const { bool isImmediateFunctionContext() const {
return Context == ExpressionEvaluationContext::ImmediateFunctionContext || return Context == ExpressionEvaluationContext::ImmediateFunctionContext ||
(Context == ExpressionEvaluationContext::DiscardedStatement && (Context == ExpressionEvaluationContext::DiscardedStatement &&
InImmediateFunctionContext) || InImmediateFunctionContext) ||
// C++2b [expr.const]p14: // C++23 [expr.const]p14:
// An expression or conversion is in an immediate function // An expression or conversion is in an immediate function
// context if it is potentially evaluated and either: // context if it is potentially evaluated and either:
// * its innermost enclosing non-block scope is a function // * its innermost enclosing non-block scope is a function
// parameter scope of an immediate function, or // parameter scope of an immediate function, or
// * its enclosing statement is enclosed by the compound- // * its enclosing statement is enclosed by the compound-
// statement of a consteval if statement. // statement of a consteval if statement.
(Context == ExpressionEvaluationContext::PotentiallyEvaluated && (Context == ExpressionEvaluationContext::PotentiallyEvaluated &&
InImmediateFunctionContext); InImmediateFunctionContext);
▲ Show 20 Lines • Show All 12,645 Lines • Show Last 20 Lines

clang/lib/AST/ExprConstant.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 5,037 Lines • ▼ Show 20 Lines Info.FFDiag(Found->getBeginLoc(),
diag::note_constexpr_stmt_expr_unsupported); diag::note_constexpr_stmt_expr_unsupported);
return ESR_Failed; return ESR_Failed;
} }
llvm_unreachable("Invalid EvalStmtResult!"); llvm_unreachable("Invalid EvalStmtResult!");
} }
static bool CheckLocalVariableDeclaration(EvalInfo &Info, const VarDecl *VD) { static bool CheckLocalVariableDeclaration(EvalInfo &Info, const VarDecl *VD) {
// An expression E is a core constant expression unless the evaluation of E // An expression E is a core constant expression unless the evaluation of E
// would evaluate one of the following: [C++2b] - a control flow that passes // would evaluate one of the following: [C++23] - a control flow that passes
// through a declaration of a variable with static or thread storage duration // through a declaration of a variable with static or thread storage duration
// unless that variable is usable in constant expressions. // unless that variable is usable in constant expressions.
if (VD->isLocalVarDecl() && VD->isStaticLocal() && if (VD->isLocalVarDecl() && VD->isStaticLocal() &&
!VD->isUsableInConstantExpressions(Info.Ctx)) { !VD->isUsableInConstantExpressions(Info.Ctx)) {
Info.CCEDiag(VD->getLocation(), diag::note_constexpr_static_local) Info.CCEDiag(VD->getLocation(), diag::note_constexpr_static_local)
<< (VD->getTSCSpec() == TSCS_unspecified ? 0 : 1) << VD; << (VD->getTSCSpec() == TSCS_unspecified ? 0 : 1) << VD;
return false; return false;
} }
▲ Show 20 Lines • Show All 11,261 Lines • Show Last 20 Lines

clang/lib/Basic/LangOptions.cpp

Show First 20 Lines • Show All 111 Lines • ▼ Show 20 Linesvoid LangOptions::setLangDefaults(LangOptions &Opts, Language Lang,
Opts.C11 = Std.isC11(); Opts.C11 = Std.isC11();
Opts.C17 = Std.isC17(); Opts.C17 = Std.isC17();
Opts.C2x = Std.isC2x(); Opts.C2x = Std.isC2x();
Opts.CPlusPlus = Std.isCPlusPlus(); Opts.CPlusPlus = Std.isCPlusPlus();
Opts.CPlusPlus11 = Std.isCPlusPlus11(); Opts.CPlusPlus11 = Std.isCPlusPlus11();
Opts.CPlusPlus14 = Std.isCPlusPlus14(); Opts.CPlusPlus14 = Std.isCPlusPlus14();
Opts.CPlusPlus17 = Std.isCPlusPlus17(); Opts.CPlusPlus17 = Std.isCPlusPlus17();
Opts.CPlusPlus20 = Std.isCPlusPlus20(); Opts.CPlusPlus20 = Std.isCPlusPlus20();
Opts.CPlusPlus2b = Std.isCPlusPlus2b(); Opts.CPlusPlus23 = Std.isCPlusPlus23();
Opts.GNUMode = Std.isGNUMode(); Opts.GNUMode = Std.isGNUMode();
Opts.GNUCVersion = 0; Opts.GNUCVersion = 0;
Opts.HexFloats = Std.hasHexFloats(); Opts.HexFloats = Std.hasHexFloats();
Opts.WChar = Std.isCPlusPlus(); Opts.WChar = Std.isCPlusPlus();
Opts.Digraphs = Std.hasDigraphs(); Opts.Digraphs = Std.hasDigraphs();
Opts.HLSL = Lang == Language::HLSL; Opts.HLSL = Lang == Language::HLSL;
if (Opts.HLSL && Opts.IncludeDefaultHeader) if (Opts.HLSL && Opts.IncludeDefaultHeader)
▲ Show 20 Lines • Show All 109 Lines • Show Last 20 Lines

clang/lib/Basic/Targets/OSTargets.cpp

Show First 20 Lines • Show All 208 Lines • ▼ Show 20 Lines if (Opts.MSCompatibilityVersion) {
Builder.defineMacro("_MSC_FULL_VER", Twine(Opts.MSCompatibilityVersion)); Builder.defineMacro("_MSC_FULL_VER", Twine(Opts.MSCompatibilityVersion));
// FIXME We cannot encode the revision information into 32-bits // FIXME We cannot encode the revision information into 32-bits
Builder.defineMacro("_MSC_BUILD", Twine(1)); Builder.defineMacro("_MSC_BUILD", Twine(1));
if (Opts.CPlusPlus11 && Opts.isCompatibleWithMSVC(LangOptions::MSVC2015)) if (Opts.CPlusPlus11 && Opts.isCompatibleWithMSVC(LangOptions::MSVC2015))
Builder.defineMacro("_HAS_CHAR16_T_LANGUAGE_SUPPORT", Twine(1)); Builder.defineMacro("_HAS_CHAR16_T_LANGUAGE_SUPPORT", Twine(1));
if (Opts.isCompatibleWithMSVC(LangOptions::MSVC2015)) { if (Opts.isCompatibleWithMSVC(LangOptions::MSVC2015)) {
if (Opts.CPlusPlus2b) if (Opts.CPlusPlus23)
// TODO update to the proper value.
Builder.defineMacro("_MSVC_LANG", "202004L"); Builder.defineMacro("_MSVC_LANG", "202004L");
else if (Opts.CPlusPlus20) else if (Opts.CPlusPlus20)
Builder.defineMacro("_MSVC_LANG", "202002L"); Builder.defineMacro("_MSVC_LANG", "202002L");
else if (Opts.CPlusPlus17) else if (Opts.CPlusPlus17)
Builder.defineMacro("_MSVC_LANG", "201703L"); Builder.defineMacro("_MSVC_LANG", "201703L");
else if (Opts.CPlusPlus14) else if (Opts.CPlusPlus14)
Builder.defineMacro("_MSVC_LANG", "201402L"); Builder.defineMacro("_MSVC_LANG", "201402L");
} }
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

clang/lib/Driver/Driver.cpp

Show First 20 Lines • Show All 1,389 Lines • ▼ Show 20 LinesCompilation *Driver::BuildCompilation(ArrayRef<const char *> ArgList) {
// Setting up the jobs for some precompile cases depends on whether we are // Setting up the jobs for some precompile cases depends on whether we are
// treating them as PCH, implicit modules or C++20 ones. // treating them as PCH, implicit modules or C++20 ones.
// TODO: inferring the mode like this seems fragile (it meets the objective // TODO: inferring the mode like this seems fragile (it meets the objective
// of not requiring anything new for operation, however). // of not requiring anything new for operation, however).
const Arg *Std = Args.getLastArg(options::OPT_std_EQ); const Arg *Std = Args.getLastArg(options::OPT_std_EQ);
ModulesModeCXX20 = ModulesModeCXX20 =
!Args.hasArg(options::OPT_fmodules) && Std && !Args.hasArg(options::OPT_fmodules) && Std &&
(Std->containsValue("c++20") || Std->containsValue("c++2b") || (Std->containsValue("c++20") || Std->containsValue("c++2a") ||
Std->containsValue("c++2a") || Std->containsValue("c++latest")); Std->containsValue("c++23") || Std->containsValue("c++2b") ||
Std->containsValue("c++latest"));
// Process -fmodule-header{=} flags. // Process -fmodule-header{=} flags.
if (Arg *A = Args.getLastArg(options::OPT_fmodule_header_EQ, if (Arg *A = Args.getLastArg(options::OPT_fmodule_header_EQ,
options::OPT_fmodule_header)) { options::OPT_fmodule_header)) {
// These flags force C++20 handling of headers. // These flags force C++20 handling of headers.
ModulesModeCXX20 = true; ModulesModeCXX20 = true;
if (A->getOption().matches(options::OPT_fmodule_header)) if (A->getOption().matches(options::OPT_fmodule_header))
CXX20HeaderType = HeaderMode_Default; CXX20HeaderType = HeaderMode_Default;
▲ Show 20 Lines • Show All 5,088 Lines • Show Last 20 Lines

clang/lib/Driver/ToolChains/Clang.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 3,667 Lines • ▼ Show 20 Linesstatic bool RenderModulesOptions(Compilation &C, const Driver &D,
const InputInfo &Output, const Arg *Std, const InputInfo &Output, const Arg *Std,
ArgStringList &CmdArgs) { ArgStringList &CmdArgs) {
bool IsCXX = types::isCXX(Input.getType()); bool IsCXX = types::isCXX(Input.getType());
// FIXME: Find a better way to determine whether the input has standard c++ // FIXME: Find a better way to determine whether the input has standard c++
// modules support by default. // modules support by default.
bool HaveStdCXXModules = bool HaveStdCXXModules =
IsCXX && Std && IsCXX && Std &&
(Std->containsValue("c++2a") || Std->containsValue("c++20") || (Std->containsValue("c++2a") || Std->containsValue("c++20") ||
Std->containsValue("c++2b") || Std->containsValue("c++latest")); Std->containsValue("c++2b") || Std->containsValue("c++23") ||
Std->containsValue("c++latest"));
bool HaveModules = HaveStdCXXModules; bool HaveModules = HaveStdCXXModules;
// -fmodules enables the use of precompiled modules (off by default). // -fmodules enables the use of precompiled modules (off by default).
// Users can pass -fno-cxx-modules to turn off modules support for // Users can pass -fno-cxx-modules to turn off modules support for
// C++/Objective-C++ programs. // C++/Objective-C++ programs.
bool HaveClangModules = false; bool HaveClangModules = false;
if (Args.hasFlag(options::OPT_fmodules, options::OPT_fno_modules, false)) { if (Args.hasFlag(options::OPT_fmodules, options::OPT_fno_modules, false)) {
bool AllowedInCXX = Args.hasFlag(options::OPT_fcxx_modules, bool AllowedInCXX = Args.hasFlag(options::OPT_fcxx_modules,
▲ Show 20 Lines • Show All 2,947 Lines • ▼ Show 20 Lines
if (ImplyVCPPCXXVer) { if (ImplyVCPPCXXVer) {
StringRef LanguageStandard; StringRef LanguageStandard;
if (const Arg *StdArg = Args.getLastArg(options::OPT__SLASH_std)) { if (const Arg *StdArg = Args.getLastArg(options::OPT__SLASH_std)) {
Std = StdArg; Std = StdArg;
LanguageStandard = llvm::StringSwitch<StringRef>(StdArg->getValue()) LanguageStandard = llvm::StringSwitch<StringRef>(StdArg->getValue())
.Case("c++14", "-std=c++14") .Case("c++14", "-std=c++14")
.Case("c++17", "-std=c++17") .Case("c++17", "-std=c++17")
.Case("c++20", "-std=c++20") .Case("c++20", "-std=c++20")
.Case("c++latest", "-std=c++2b") // TODO add c++23 when MSVC supports it.
.Case("c++latest", "-std=c++23")
aaron.ballmanUnsubmitted
Done
ReplyInline Actions

Good catch!

aaron.ballman: Good catch!
.Default(""); .Default("");
if (LanguageStandard.empty()) if (LanguageStandard.empty())
D.Diag(clang::diag::warn_drv_unused_argument) D.Diag(clang::diag::warn_drv_unused_argument)
<< StdArg->getAsString(Args); << StdArg->getAsString(Args);
} }
if (LanguageStandard.empty()) { if (LanguageStandard.empty()) {
if (IsMSVC2015Compatible) if (IsMSVC2015Compatible)
▲ Show 20 Lines • Show All 1,890 Lines • Show Last 20 Lines

clang/lib/Frontend/InitPreprocessor.cpp

Show First 20 Lines • Show All 446 Lines • ▼ Show 20 Lines else if (LangOpts.C11)
Builder.defineMacro("__STDC_VERSION__", "201112L"); Builder.defineMacro("__STDC_VERSION__", "201112L");
else if (LangOpts.C99) else if (LangOpts.C99)
Builder.defineMacro("__STDC_VERSION__", "199901L"); Builder.defineMacro("__STDC_VERSION__", "199901L");
else if (!LangOpts.GNUMode && LangOpts.Digraphs) else if (!LangOpts.GNUMode && LangOpts.Digraphs)
Builder.defineMacro("__STDC_VERSION__", "199409L"); Builder.defineMacro("__STDC_VERSION__", "199409L");
} else { } else {
// -- __cplusplus // -- __cplusplus
// FIXME: Use correct value for C++23. // FIXME: Use correct value for C++23.
if (LangOpts.CPlusPlus2b) if (LangOpts.CPlusPlus23)
Builder.defineMacro("__cplusplus", "202101L"); Builder.defineMacro("__cplusplus", "202101L");
// [C++20] The integer literal 202002L. // [C++20] The integer literal 202002L.
aaron.ballmanUnsubmitted
Done
ReplyInline Actions

I think this might still be premature. I noticed that the draft C++ standard does not have this value set yet: https://github.com/cplusplus/draft/blob/main/source/config.tex#L6

I've emailed the editor to find out if that's a mistake (I am pretty sure we're sending this off to PDTS at some point shortly).

aaron.ballman: I think this might still be premature. I noticed that the draft C++ standard does not have this…
MordanteAuthorUnsubmitted
Done
ReplyInline Actions

I've reverted this and similar parts. They are now in D149761. I will update that patch once editor made a release with the updated __cplusplus macro.

Mordante: I've reverted this and similar parts. They are now in D149761. I will update that patch once…
else if (LangOpts.CPlusPlus20) else if (LangOpts.CPlusPlus20)
Builder.defineMacro("__cplusplus", "202002L"); Builder.defineMacro("__cplusplus", "202002L");
// [C++17] The integer literal 201703L. // [C++17] The integer literal 201703L.
else if (LangOpts.CPlusPlus17) else if (LangOpts.CPlusPlus17)
Builder.defineMacro("__cplusplus", "201703L"); Builder.defineMacro("__cplusplus", "201703L");
// [C++14] The name __cplusplus is defined to the value 201402L when // [C++14] The name __cplusplus is defined to the value 201402L when
// compiling a C++ translation unit. // compiling a C++ translation unit.
else if (LangOpts.CPlusPlus14) else if (LangOpts.CPlusPlus14)
▲ Show 20 Lines • Show All 135 Lines • ▼ Show 20 Linesstatic void InitializeCPlusPlusFeatureTestMacros(const LangOptions &LangOpts,
// C++11 features. // C++11 features.
if (LangOpts.CPlusPlus11) { if (LangOpts.CPlusPlus11) {
Builder.defineMacro("__cpp_unicode_characters", "200704L"); Builder.defineMacro("__cpp_unicode_characters", "200704L");
Builder.defineMacro("__cpp_raw_strings", "200710L"); Builder.defineMacro("__cpp_raw_strings", "200710L");
Builder.defineMacro("__cpp_unicode_literals", "200710L"); Builder.defineMacro("__cpp_unicode_literals", "200710L");
Builder.defineMacro("__cpp_user_defined_literals", "200809L"); Builder.defineMacro("__cpp_user_defined_literals", "200809L");
Builder.defineMacro("__cpp_lambdas", "200907L"); Builder.defineMacro("__cpp_lambdas", "200907L");
Builder.defineMacro("__cpp_constexpr", LangOpts.CPlusPlus2b ? "202211L" Builder.defineMacro("__cpp_constexpr", LangOpts.CPlusPlus23 ? "202211L"
: LangOpts.CPlusPlus20 ? "201907L" : LangOpts.CPlusPlus20 ? "201907L"
: LangOpts.CPlusPlus17 ? "201603L" : LangOpts.CPlusPlus17 ? "201603L"
: LangOpts.CPlusPlus14 ? "201304L" : LangOpts.CPlusPlus14 ? "201304L"
: "200704"); : "200704");
Builder.defineMacro("__cpp_constexpr_in_decltype", "201711L"); Builder.defineMacro("__cpp_constexpr_in_decltype", "201711L");
Builder.defineMacro("__cpp_range_based_for", Builder.defineMacro("__cpp_range_based_for",
LangOpts.CPlusPlus17 ? "201603L" : "200907"); LangOpts.CPlusPlus17 ? "201603L" : "200907");
Builder.defineMacro("__cpp_static_assert", Builder.defineMacro("__cpp_static_assert",
▲ Show 20 Lines • Show All 67 Lines • ▼ Show 20 Lines if (LangOpts.CPlusPlus20) {
Builder.defineMacro("__cpp_constexpr_dynamic_alloc", "201907L"); Builder.defineMacro("__cpp_constexpr_dynamic_alloc", "201907L");
Builder.defineMacro("__cpp_constinit", "201907L"); Builder.defineMacro("__cpp_constinit", "201907L");
Builder.defineMacro("__cpp_impl_coroutine", "201902L"); Builder.defineMacro("__cpp_impl_coroutine", "201902L");
Builder.defineMacro("__cpp_designated_initializers", "201707L"); Builder.defineMacro("__cpp_designated_initializers", "201707L");
Builder.defineMacro("__cpp_impl_three_way_comparison", "201907L"); Builder.defineMacro("__cpp_impl_three_way_comparison", "201907L");
//Builder.defineMacro("__cpp_modules", "201907L"); //Builder.defineMacro("__cpp_modules", "201907L");
Builder.defineMacro("__cpp_using_enum", "201907L"); Builder.defineMacro("__cpp_using_enum", "201907L");
} }
// C++2b features. // C++23 features.
if (LangOpts.CPlusPlus2b) { if (LangOpts.CPlusPlus23) {
Builder.defineMacro("__cpp_implicit_move", "202011L"); Builder.defineMacro("__cpp_implicit_move", "202011L");
Builder.defineMacro("__cpp_size_t_suffix", "202011L"); Builder.defineMacro("__cpp_size_t_suffix", "202011L");
Builder.defineMacro("__cpp_if_consteval", "202106L"); Builder.defineMacro("__cpp_if_consteval", "202106L");
Builder.defineMacro("__cpp_multidimensional_subscript", "202211L"); Builder.defineMacro("__cpp_multidimensional_subscript", "202211L");
} }
// We provide those C++2b features as extensions in earlier language modes, so // We provide those C++23 features as extensions in earlier language modes, so
// we also define their feature test macros. // we also define their feature test macros.
if (LangOpts.CPlusPlus11) if (LangOpts.CPlusPlus11)
Builder.defineMacro("__cpp_static_call_operator", "202207L"); Builder.defineMacro("__cpp_static_call_operator", "202207L");
Builder.defineMacro("__cpp_named_character_escapes", "202207L"); Builder.defineMacro("__cpp_named_character_escapes", "202207L");
if (LangOpts.Char8) if (LangOpts.Char8)
Builder.defineMacro("__cpp_char8_t", "202207L"); Builder.defineMacro("__cpp_char8_t", "202207L");
Builder.defineMacro("__cpp_impl_destroying_delete", "201806L"); Builder.defineMacro("__cpp_impl_destroying_delete", "201806L");
▲ Show 20 Lines • Show All 684 Lines • Show Last 20 Lines

clang/lib/Headers/stdatomic.h

Show First 20 Lines • Show All 43 Lines • ▼ Show 20 Lines
#define ATOMIC_LLONG_LOCK_FREE __CLANG_ATOMIC_LLONG_LOCK_FREE #define ATOMIC_LLONG_LOCK_FREE __CLANG_ATOMIC_LLONG_LOCK_FREE
#define ATOMIC_POINTER_LOCK_FREE __CLANG_ATOMIC_POINTER_LOCK_FREE #define ATOMIC_POINTER_LOCK_FREE __CLANG_ATOMIC_POINTER_LOCK_FREE
/* 7.17.2 Initialization */ /* 7.17.2 Initialization */
/* FIXME: This is using the placeholder dates Clang produces for these macros /* FIXME: This is using the placeholder dates Clang produces for these macros
in C2x mode; switch to the correct values once they've been published. */ in C2x mode; switch to the correct values once they've been published. */
#if (defined(__STDC_VERSION__) && __STDC_VERSION__ < 202000L) || \ #if (defined(__STDC_VERSION__) && __STDC_VERSION__ < 202000L) || \
defined(__cplusplus) defined(__cplusplus)
/* ATOMIC_VAR_INIT was removed in C2x, but still remains in C++2b. */ /* ATOMIC_VAR_INIT was removed in C2x, but still remains in C++23. */
#define ATOMIC_VAR_INIT(value) (value) #define ATOMIC_VAR_INIT(value) (value)
#endif #endif
#if ((defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201710L && \ #if ((defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201710L && \
__STDC_VERSION__ < 202000L) || \ __STDC_VERSION__ < 202000L) || \
(defined(__cplusplus) && __cplusplus >= 202002L)) && \ (defined(__cplusplus) && __cplusplus >= 202002L)) && \
!defined(_CLANG_DISABLE_CRT_DEPRECATION_WARNINGS) !defined(_CLANG_DISABLE_CRT_DEPRECATION_WARNINGS)
/* ATOMIC_VAR_INIT was deprecated in C17 and C++20. */ /* ATOMIC_VAR_INIT was deprecated in C17 and C++20. */
▲ Show 20 Lines • Show All 136 Lines • Show Last 20 Lines

clang/lib/Lex/Lexer.cpp

Show First 20 Lines • Show All 3,342 Lines • ▼ Show 20 Lines if (Diagnose) {
Diag(KindLoc, diag::note_ucn_four_not_eight) Diag(KindLoc, diag::note_ucn_four_not_eight)
<< FixItHint::CreateReplacement(URange, "u"); << FixItHint::CreateReplacement(URange, "u");
} }
} }
return std::nullopt; return std::nullopt;
} }
if (Delimited && PP) { if (Delimited && PP) {
Diag(SlashLoc, PP->getLangOpts().CPlusPlus2b Diag(SlashLoc, PP->getLangOpts().CPlusPlus23
? diag::warn_cxx2b_delimited_escape_sequence ? diag::warn_cxx23_delimited_escape_sequence
: diag::ext_delimited_escape_sequence) : diag::ext_delimited_escape_sequence)
<< /*delimited*/ 0 << (PP->getLangOpts().CPlusPlus ? 1 : 0); << /*delimited*/ 0 << (PP->getLangOpts().CPlusPlus ? 1 : 0);
} }
if (Result) { if (Result) {
Result->setFlag(Token::HasUCN); Result->setFlag(Token::HasUCN);
// If the UCN contains either a trigraph or a line splicing, // If the UCN contains either a trigraph or a line splicing,
// we need to call getAndAdvanceChar again to set the appropriate flags // we need to call getAndAdvanceChar again to set the appropriate flags
▲ Show 20 Lines • Show All 70 Lines • ▼ Show 20 Lines if (Diagnose) {
} }
} }
// We do not offer misspelled character names suggestions here // We do not offer misspelled character names suggestions here
// as the set of what would be a valid suggestion depends on context, // as the set of what would be a valid suggestion depends on context,
// and we should not make invalid suggestions. // and we should not make invalid suggestions.
} }
if (Diagnose && Match) if (Diagnose && Match)
Diag(SlashLoc, PP->getLangOpts().CPlusPlus2b Diag(SlashLoc, PP->getLangOpts().CPlusPlus23
? diag::warn_cxx2b_delimited_escape_sequence ? diag::warn_cxx23_delimited_escape_sequence
: diag::ext_delimited_escape_sequence) : diag::ext_delimited_escape_sequence)
<< /*named*/ 1 << (PP->getLangOpts().CPlusPlus ? 1 : 0); << /*named*/ 1 << (PP->getLangOpts().CPlusPlus ? 1 : 0);
// If no diagnostic has been emitted yet, likely because we are doing a // If no diagnostic has been emitted yet, likely because we are doing a
// tentative lexing, we do not want to recover here to make sure the token // tentative lexing, we do not want to recover here to make sure the token
// will not be incorrectly considered valid. This function will be called // will not be incorrectly considered valid. This function will be called
// again and a diagnostic emitted then. // again and a diagnostic emitted then.
if (LooseMatch && Diagnose) if (LooseMatch && Diagnose)
▲ Show 20 Lines • Show All 1,077 Lines • Show Last 20 Lines

clang/lib/Lex/LiteralSupport.cpp

Show First 20 Lines • Show All 306 Lines • ▼ Show 20 Linesstatic unsigned ProcessCharEscape(const char *ThisTokBegin,
if (Delimited && Diags) { if (Delimited && Diags) {
if (!EndDelimiterFound) if (!EndDelimiterFound)
Diag(Diags, Features, Loc, ThisTokBegin, EscapeBegin, ThisTokBuf, Diag(Diags, Features, Loc, ThisTokBegin, EscapeBegin, ThisTokBuf,
diag::err_expected) diag::err_expected)
<< tok::r_brace; << tok::r_brace;
else if (!HadError) { else if (!HadError) {
Diag(Diags, Features, Loc, ThisTokBegin, EscapeBegin, ThisTokBuf, Diag(Diags, Features, Loc, ThisTokBegin, EscapeBegin, ThisTokBuf,
Features.CPlusPlus2b ? diag::warn_cxx2b_delimited_escape_sequence Features.CPlusPlus23 ? diag::warn_cxx23_delimited_escape_sequence
: diag::ext_delimited_escape_sequence) : diag::ext_delimited_escape_sequence)
<< /*delimited*/ 0 << (Features.CPlusPlus ? 1 : 0); << /*delimited*/ 0 << (Features.CPlusPlus ? 1 : 0);
} }
} }
return ResultChar; return ResultChar;
} }
▲ Show 20 Lines • Show All 312 Lines • ▼ Show 20 Linesstatic bool ProcessUCNEscape(const char *ThisTokBegin, const char *&ThisTokBuf,
} }
if (!Features.CPlusPlus && !Features.C99 && Diags) if (!Features.CPlusPlus && !Features.C99 && Diags)
Diag(Diags, Features, Loc, ThisTokBegin, UcnBegin, ThisTokBuf, Diag(Diags, Features, Loc, ThisTokBegin, UcnBegin, ThisTokBuf,
diag::warn_ucn_not_valid_in_c89_literal); diag::warn_ucn_not_valid_in_c89_literal);
if ((IsDelimitedEscapeSequence || IsNamedEscapeSequence) && Diags) if ((IsDelimitedEscapeSequence || IsNamedEscapeSequence) && Diags)
Diag(Diags, Features, Loc, ThisTokBegin, UcnBegin, ThisTokBuf, Diag(Diags, Features, Loc, ThisTokBegin, UcnBegin, ThisTokBuf,
Features.CPlusPlus2b ? diag::warn_cxx2b_delimited_escape_sequence Features.CPlusPlus23 ? diag::warn_cxx23_delimited_escape_sequence
: diag::ext_delimited_escape_sequence) : diag::ext_delimited_escape_sequence)
<< (IsNamedEscapeSequence ? 1 : 0) << (Features.CPlusPlus ? 1 : 0); << (IsNamedEscapeSequence ? 1 : 0) << (Features.CPlusPlus ? 1 : 0);
return true; return true;
} }
/// MeasureUCNEscape - Determine the number of bytes within the resulting string /// MeasureUCNEscape - Determine the number of bytes within the resulting string
/// which this UCN will occupy. /// which this UCN will occupy.
▲ Show 20 Lines • Show All 1,645 Lines • Show Last 20 Lines

clang/lib/Lex/PPDirectives.cpp

Show First 20 Lines • Show All 428 Lines • ▼ Show 20 Linesvoid Preprocessor::SuggestTypoedDirective(const Token &Tok,
StringRef Directive) const { StringRef Directive) const {
// If this is a `.S` file, treat unknown # directives as non-preprocessor // If this is a `.S` file, treat unknown # directives as non-preprocessor
// directives. // directives.
if (getLangOpts().AsmPreprocessor) return; if (getLangOpts().AsmPreprocessor) return;
std::vector<StringRef> Candidates = { std::vector<StringRef> Candidates = {
"if", "ifdef", "ifndef", "elif", "else", "endif" "if", "ifdef", "ifndef", "elif", "else", "endif"
}; };
if (LangOpts.C2x || LangOpts.CPlusPlus2b) if (LangOpts.C2x || LangOpts.CPlusPlus23)
Candidates.insert(Candidates.end(), {"elifdef", "elifndef"}); Candidates.insert(Candidates.end(), {"elifdef", "elifndef"});
if (std::optional<StringRef> Sugg = findSimilarStr(Directive, Candidates)) { if (std::optional<StringRef> Sugg = findSimilarStr(Directive, Candidates)) {
// Directive cannot be coming from macro. // Directive cannot be coming from macro.
assert(Tok.getLocation().isFileID()); assert(Tok.getLocation().isFileID());
CharSourceRange DirectiveRange = CharSourceRange::getCharRange( CharSourceRange DirectiveRange = CharSourceRange::getCharRange(
Tok.getLocation(), Tok.getLocation(),
Tok.getLocation().getLocWithOffset(Directive.size())); Tok.getLocation().getLocWithOffset(Directive.size()));
▲ Show 20 Lines • Show All 294 Lines • ▼ Show 20 Lines if (Directive.startswith("if")) {
Sub == "lifndef") { // "elifndef" Sub == "lifndef") { // "elifndef"
bool IsElifDef = Sub == "lifdef"; bool IsElifDef = Sub == "lifdef";
PPConditionalInfo &CondInfo = CurPPLexer->peekConditionalLevel(); PPConditionalInfo &CondInfo = CurPPLexer->peekConditionalLevel();
Token DirectiveToken = Tok; Token DirectiveToken = Tok;
if (!CondInfo.WasSkipping) if (!CondInfo.WasSkipping)
SkippingRangeState.endLexPass(Hashptr); SkippingRangeState.endLexPass(Hashptr);
// Warn if using `#elifdef` & `#elifndef` in not C2x & C++2b mode even // Warn if using `#elifdef` & `#elifndef` in not C2x & C++23 mode even
// if this branch is in a skipping block. // if this branch is in a skipping block.
unsigned DiagID; unsigned DiagID;
if (LangOpts.CPlusPlus) if (LangOpts.CPlusPlus)
DiagID = LangOpts.CPlusPlus2b ? diag::warn_cxx2b_compat_pp_directive DiagID = LangOpts.CPlusPlus23 ? diag::warn_cxx23_compat_pp_directive
: diag::ext_cxx2b_pp_directive; : diag::ext_cxx23_pp_directive;
else else
DiagID = LangOpts.C2x ? diag::warn_c2x_compat_pp_directive DiagID = LangOpts.C2x ? diag::warn_c2x_compat_pp_directive
: diag::ext_c2x_pp_directive; : diag::ext_c2x_pp_directive;
Diag(Tok, DiagID) << (IsElifDef ? PED_Elifdef : PED_Elifndef); Diag(Tok, DiagID) << (IsElifDef ? PED_Elifdef : PED_Elifndef);
// If this is a #elif with a #else before it, report the error. // If this is a #elif with a #else before it, report the error.
if (CondInfo.FoundElse) if (CondInfo.FoundElse)
Diag(Tok, diag::pp_err_elif_after_else) Diag(Tok, diag::pp_err_elif_after_else)
▲ Show 20 Lines • Show All 489 Lines • ▼ Show 20 Lines default:
// GNU Extensions. // GNU Extensions.
case tok::pp_import: case tok::pp_import:
return HandleImportDirective(SavedHash.getLocation(), Result); return HandleImportDirective(SavedHash.getLocation(), Result);
case tok::pp_include_next: case tok::pp_include_next:
return HandleIncludeNextDirective(SavedHash.getLocation(), Result); return HandleIncludeNextDirective(SavedHash.getLocation(), Result);
case tok::pp_warning: case tok::pp_warning:
if (LangOpts.CPlusPlus) if (LangOpts.CPlusPlus)
Diag(Result, LangOpts.CPlusPlus2b Diag(Result, LangOpts.CPlusPlus23
? diag::warn_cxx2b_compat_warning_directive ? diag::warn_cxx23_compat_warning_directive
: diag::ext_pp_warning_directive) : diag::ext_pp_warning_directive)
<< /*C++2b*/ 1; << /*C++23*/ 1;
else else
Diag(Result, LangOpts.C2x ? diag::warn_c2x_compat_warning_directive Diag(Result, LangOpts.C2x ? diag::warn_c2x_compat_warning_directive
: diag::ext_pp_warning_directive) : diag::ext_pp_warning_directive)
<< /*C2x*/ 0; << /*C2x*/ 0;
return HandleUserDiagnosticDirective(Result, true); return HandleUserDiagnosticDirective(Result, true);
case tok::pp_ident: case tok::pp_ident:
return HandleIdentSCCSDirective(Result); return HandleIdentSCCSDirective(Result);
▲ Show 20 Lines • Show All 2,147 Lines • ▼ Show 20 Lines
void Preprocessor::HandleElifFamilyDirective(Token &ElifToken, void Preprocessor::HandleElifFamilyDirective(Token &ElifToken,
const Token &HashToken, const Token &HashToken,
tok::PPKeywordKind Kind) { tok::PPKeywordKind Kind) {
PPElifDiag DirKind = Kind == tok::pp_elif ? PED_Elif PPElifDiag DirKind = Kind == tok::pp_elif ? PED_Elif
: Kind == tok::pp_elifdef ? PED_Elifdef : Kind == tok::pp_elifdef ? PED_Elifdef
: PED_Elifndef; : PED_Elifndef;
++NumElse; ++NumElse;
// Warn if using `#elifdef` & `#elifndef` in not C2x & C++2b mode. // Warn if using `#elifdef` & `#elifndef` in not C2x & C++23 mode.
switch (DirKind) { switch (DirKind) {
case PED_Elifdef: case PED_Elifdef:
case PED_Elifndef: case PED_Elifndef:
unsigned DiagID; unsigned DiagID;
if (LangOpts.CPlusPlus) if (LangOpts.CPlusPlus)
DiagID = LangOpts.CPlusPlus2b ? diag::warn_cxx2b_compat_pp_directive DiagID = LangOpts.CPlusPlus23 ? diag::warn_cxx23_compat_pp_directive
: diag::ext_cxx2b_pp_directive; : diag::ext_cxx23_pp_directive;
else else
DiagID = LangOpts.C2x ? diag::warn_c2x_compat_pp_directive DiagID = LangOpts.C2x ? diag::warn_c2x_compat_pp_directive
: diag::ext_c2x_pp_directive; : diag::ext_c2x_pp_directive;
Diag(ElifToken, DiagID) << DirKind; Diag(ElifToken, DiagID) << DirKind;
break; break;
default: default:
break; break;
} }
▲ Show 20 Lines • Show All 54 Lines • Show Last 20 Lines

clang/lib/Lex/PPExpressions.cpp

Show First 20 Lines • Show All 317 Lines • ▼ Show 20 Lines if (!PP.getLangOpts().C99 && Literal.isLongLong) {
if (PP.getLangOpts().CPlusPlus) if (PP.getLangOpts().CPlusPlus)
PP.Diag(PeekTok, PP.Diag(PeekTok,
PP.getLangOpts().CPlusPlus11 ? PP.getLangOpts().CPlusPlus11 ?
diag::warn_cxx98_compat_longlong : diag::ext_cxx11_longlong); diag::warn_cxx98_compat_longlong : diag::ext_cxx11_longlong);
else else
PP.Diag(PeekTok, diag::ext_c99_longlong); PP.Diag(PeekTok, diag::ext_c99_longlong);
} }
// 'z/uz' literals are a C++2b feature. // 'z/uz' literals are a C++23 feature.
if (Literal.isSizeT) if (Literal.isSizeT)
PP.Diag(PeekTok, PP.getLangOpts().CPlusPlus PP.Diag(PeekTok, PP.getLangOpts().CPlusPlus
? PP.getLangOpts().CPlusPlus2b ? PP.getLangOpts().CPlusPlus23
? diag::warn_cxx20_compat_size_t_suffix ? diag::warn_cxx20_compat_size_t_suffix
: diag::ext_cxx2b_size_t_suffix : diag::ext_cxx23_size_t_suffix
: diag::err_cxx2b_size_t_suffix); : diag::err_cxx23_size_t_suffix);
// 'wb/uwb' literals are a C2x feature. We explicitly do not support the // 'wb/uwb' literals are a C2x feature. We explicitly do not support the
// suffix in C++ as an extension because a library-based UDL that resolves // suffix in C++ as an extension because a library-based UDL that resolves
// to a library type may be more appropriate there. // to a library type may be more appropriate there.
if (Literal.isBitInt) if (Literal.isBitInt)
PP.Diag(PeekTok, PP.getLangOpts().C2x PP.Diag(PeekTok, PP.getLangOpts().C2x
? diag::warn_c2x_compat_bitint_suffix ? diag::warn_c2x_compat_bitint_suffix
: diag::ext_c2x_bitint_suffix); : diag::ext_c2x_bitint_suffix);
▲ Show 20 Lines • Show All 606 Lines • Show Last 20 Lines

clang/lib/Parse/ParseDeclCXX.cpp

Show First 20 Lines • Show All 1,070 Lines • ▼ Show 20 Lines if (T.expectAndConsume(diag::err_expected_lparen_after, "decltype",
DS.SetTypeSpecError(); DS.SetTypeSpecError();
return T.getOpenLocation() == Tok.getLocation() ? StartLoc return T.getOpenLocation() == Tok.getLocation() ? StartLoc
: T.getOpenLocation(); : T.getOpenLocation();
} }
// Check for C++1y 'decltype(auto)'. // Check for C++1y 'decltype(auto)'.
if (Tok.is(tok::kw_auto) && NextToken().is(tok::r_paren)) { if (Tok.is(tok::kw_auto) && NextToken().is(tok::r_paren)) {
// the typename-specifier in a function-style cast expression may // the typename-specifier in a function-style cast expression may
// be 'auto' since C++2b. // be 'auto' since C++23.
Diag(Tok.getLocation(), Diag(Tok.getLocation(),
getLangOpts().CPlusPlus14 getLangOpts().CPlusPlus14
? diag::warn_cxx11_compat_decltype_auto_type_specifier ? diag::warn_cxx11_compat_decltype_auto_type_specifier
: diag::ext_decltype_auto_type_specifier); : diag::ext_decltype_auto_type_specifier);
ConsumeToken(); ConsumeToken();
} else { } else {
// Parse the expression // Parse the expression
▲ Show 20 Lines • Show All 3,765 Lines • Show Last 20 Lines

clang/lib/Parse/ParseExpr.cpp

Show First 20 Lines • Show All 1,865 Lines • ▼ Show 20 Lines
/// Once the leading part of a postfix-expression is parsed, this /// Once the leading part of a postfix-expression is parsed, this
/// method parses any suffixes that apply. /// method parses any suffixes that apply.
/// ///
/// \verbatim /// \verbatim
/// postfix-expression: [C99 6.5.2] /// postfix-expression: [C99 6.5.2]
/// primary-expression /// primary-expression
/// postfix-expression '[' expression ']' /// postfix-expression '[' expression ']'
/// postfix-expression '[' braced-init-list ']' /// postfix-expression '[' braced-init-list ']'
/// postfix-expression '[' expression-list [opt] ']' [C++2b 12.4.5] /// postfix-expression '[' expression-list [opt] ']' [C++23 12.4.5]
/// postfix-expression '(' argument-expression-list[opt] ')' /// postfix-expression '(' argument-expression-list[opt] ')'
/// postfix-expression '.' identifier /// postfix-expression '.' identifier
/// postfix-expression '->' identifier /// postfix-expression '->' identifier
/// postfix-expression '++' /// postfix-expression '++'
/// postfix-expression '--' /// postfix-expression '--'
/// '(' type-name ')' '{' initializer-list '}' /// '(' type-name ')' '{' initializer-list '}'
/// '(' type-name ')' '{' initializer-list ',' '}' /// '(' type-name ')' '{' initializer-list ',' '}'
/// ///
▲ Show 20 Lines • Show All 58 Lines • ▼ Show 20 Lines case tok::l_square: { // postfix-expression: p-e '[' expression ']'
ExprResult Length, Stride; ExprResult Length, Stride;
SourceLocation ColonLocFirst, ColonLocSecond; SourceLocation ColonLocFirst, ColonLocSecond;
ExprVector ArgExprs; ExprVector ArgExprs;
bool HasError = false; bool HasError = false;
PreferredType.enterSubscript(Actions, Tok.getLocation(), LHS.get()); PreferredType.enterSubscript(Actions, Tok.getLocation(), LHS.get());
// We try to parse a list of indexes in all language mode first // We try to parse a list of indexes in all language mode first
// and, in we find 0 or one index, we try to parse an OpenMP array // and, in we find 0 or one index, we try to parse an OpenMP array
// section. This allow us to support C++2b multi dimensional subscript and // section. This allow us to support C++23 multi dimensional subscript and
// OpenMp sections in the same language mode. // OpenMp sections in the same language mode.
if (!getLangOpts().OpenMP || Tok.isNot(tok::colon)) { if (!getLangOpts().OpenMP || Tok.isNot(tok::colon)) {
if (!getLangOpts().CPlusPlus2b) { if (!getLangOpts().CPlusPlus23) {
ExprResult Idx; ExprResult Idx;
if (getLangOpts().CPlusPlus11 && Tok.is(tok::l_brace)) { if (getLangOpts().CPlusPlus11 && Tok.is(tok::l_brace)) {
Diag(Tok, diag::warn_cxx98_compat_generalized_initializer_lists); Diag(Tok, diag::warn_cxx98_compat_generalized_initializer_lists);
Idx = ParseBraceInitializer(); Idx = ParseBraceInitializer();
} else { } else {
Idx = ParseExpression(); // May be a comma expression Idx = ParseExpression(); // May be a comma expression
} }
LHS = Actions.CorrectDelayedTyposInExpr(LHS); LHS = Actions.CorrectDelayedTyposInExpr(LHS);
▲ Show 20 Lines • Show All 1,832 Lines • Show Last 20 Lines

clang/lib/Parse/ParseExprCXX.cpp

Show First 20 Lines • Show All 719 Lines • ▼ Show 20 Lines
/// '&' identifier /// '&' identifier
/// 'this' /// 'this'
/// ///
/// init-capture: [C++1y] /// init-capture: [C++1y]
/// identifier initializer /// identifier initializer
/// '&' identifier initializer /// '&' identifier initializer
/// ///
/// lambda-declarator: /// lambda-declarator:
/// lambda-specifiers [C++2b] /// lambda-specifiers [C++23]
/// '(' parameter-declaration-clause ')' lambda-specifiers /// '(' parameter-declaration-clause ')' lambda-specifiers
/// requires-clause[opt] /// requires-clause[opt]
/// ///
/// lambda-specifiers: /// lambda-specifiers:
/// decl-specifier-seq[opt] noexcept-specifier[opt] /// decl-specifier-seq[opt] noexcept-specifier[opt]
/// attribute-specifier-seq[opt] trailing-return-type[opt] /// attribute-specifier-seq[opt] trailing-return-type[opt]
/// ///
ExprResult Parser::ParseLambdaExpression() { ExprResult Parser::ParseLambdaExpression() {
▲ Show 20 Lines • Show All 463 Lines • ▼ Show 20 Lines default:
return; return;
} }
} }
} }
static void addStaticToLambdaDeclSpecifier(Parser &P, SourceLocation StaticLoc, static void addStaticToLambdaDeclSpecifier(Parser &P, SourceLocation StaticLoc,
DeclSpec &DS) { DeclSpec &DS) {
if (StaticLoc.isValid()) { if (StaticLoc.isValid()) {
P.Diag(StaticLoc, !P.getLangOpts().CPlusPlus2b P.Diag(StaticLoc, !P.getLangOpts().CPlusPlus23
? diag::err_static_lambda ? diag::err_static_lambda
: diag::warn_cxx20_compat_static_lambda); : diag::warn_cxx20_compat_static_lambda);
const char *PrevSpec = nullptr; const char *PrevSpec = nullptr;
unsigned DiagID = 0; unsigned DiagID = 0;
DS.SetStorageClassSpec(P.getActions(), DeclSpec::SCS_static, StaticLoc, DS.SetStorageClassSpec(P.getActions(), DeclSpec::SCS_static, StaticLoc,
PrevSpec, DiagID, PrevSpec, DiagID,
P.getActions().getASTContext().getPrintingPolicy()); P.getActions().getASTContext().getPrintingPolicy());
assert(PrevSpec == nullptr && DiagID == 0 && assert(PrevSpec == nullptr && DiagID == 0 &&
▲ Show 20 Lines • Show All 140 Lines • ▼ Show 20 Lines if (Tok.is(tok::less)) {
} }
} }
// Implement WG21 P2173, which allows attributes immediately before the // Implement WG21 P2173, which allows attributes immediately before the
// lambda declarator and applies them to the corresponding function operator // lambda declarator and applies them to the corresponding function operator
// or operator template declaration. We accept this as a conforming extension // or operator template declaration. We accept this as a conforming extension
// in all language modes that support lambdas. // in all language modes that support lambdas.
if (isCXX11AttributeSpecifier()) { if (isCXX11AttributeSpecifier()) {
Diag(Tok, getLangOpts().CPlusPlus2b Diag(Tok, getLangOpts().CPlusPlus23
? diag::warn_cxx20_compat_decl_attrs_on_lambda ? diag::warn_cxx20_compat_decl_attrs_on_lambda
: diag::ext_decl_attrs_on_lambda); : diag::ext_decl_attrs_on_lambda);
MaybeParseCXX11Attributes(D); MaybeParseCXX11Attributes(D);
} }
TypeResult TrailingReturnType; TypeResult TrailingReturnType;
SourceLocation TrailingReturnTypeLoc; SourceLocation TrailingReturnTypeLoc;
SourceLocation LParenLoc, RParenLoc; SourceLocation LParenLoc, RParenLoc;
▲ Show 20 Lines • Show All 122 Lines • ▼ Show 20 LinesExprResult Parser::ParseLambdaExpressionAfterIntroducer(
HasSpecifiers = HasSpecifiers =
Tok.isOneOf(tok::kw_mutable, tok::arrow, tok::kw___attribute, Tok.isOneOf(tok::kw_mutable, tok::arrow, tok::kw___attribute,
tok::kw_constexpr, tok::kw_consteval, tok::kw_static, tok::kw_constexpr, tok::kw_consteval, tok::kw_static,
tok::kw___private, tok::kw___global, tok::kw___local, tok::kw___private, tok::kw___global, tok::kw___local,
tok::kw___constant, tok::kw___generic, tok::kw_groupshared, tok::kw___constant, tok::kw___generic, tok::kw_groupshared,
tok::kw_requires, tok::kw_noexcept) || tok::kw_requires, tok::kw_noexcept) ||
(Tok.is(tok::l_square) && NextToken().is(tok::l_square)); (Tok.is(tok::l_square) && NextToken().is(tok::l_square));
if (HasSpecifiers && !HasParentheses && !getLangOpts().CPlusPlus2b) { if (HasSpecifiers && !HasParentheses && !getLangOpts().CPlusPlus23) {
// It's common to forget that one needs '()' before 'mutable', an // It's common to forget that one needs '()' before 'mutable', an
// attribute specifier, the result type, or the requires clause. Deal with // attribute specifier, the result type, or the requires clause. Deal with
// this. // this.
Diag(Tok, diag::ext_lambda_missing_parens) Diag(Tok, diag::ext_lambda_missing_parens)
<< FixItHint::CreateInsertion(Tok.getLocation(), "() "); << FixItHint::CreateInsertion(Tok.getLocation(), "() ");
} }
if (HasParentheses || HasSpecifiers) if (HasParentheses || HasSpecifiers)
▲ Show 20 Lines • Show All 478 Lines • ▼ Show 20 Lines assert((Context == DeclaratorContext::ForInit ||
"Unexpected Declarator Context"); "Unexpected Declarator Context");
DeclGroupPtrTy DG; DeclGroupPtrTy DG;
SourceLocation DeclStart = ConsumeToken(), DeclEnd; SourceLocation DeclStart = ConsumeToken(), DeclEnd;
DG = ParseUsingDeclaration(Context, {}, DeclStart, DeclEnd, Attrs, AS_none); DG = ParseUsingDeclaration(Context, {}, DeclStart, DeclEnd, Attrs, AS_none);
if (!DG) if (!DG)
return DG; return DG;
Diag(DeclStart, !getLangOpts().CPlusPlus2b Diag(DeclStart, !getLangOpts().CPlusPlus23
? diag::ext_alias_in_init_statement ? diag::ext_alias_in_init_statement
: diag::warn_cxx20_alias_in_init_statement) : diag::warn_cxx20_alias_in_init_statement)
<< SourceRange(DeclStart, DeclEnd); << SourceRange(DeclStart, DeclEnd);
return DG; return DG;
} }
/// ParseCXXCondition - if/switch/while condition expression. /// ParseCXXCondition - if/switch/while condition expression.
▲ Show 20 Lines • Show All 2,110 Lines • Show Last 20 Lines

clang/lib/Parse/ParseStmt.cpp

Show First 20 Lines • Show All 1,047 Lines • ▼ Show 20 Lines default:
break; break;
} }
} }
} }
void Parser::DiagnoseLabelAtEndOfCompoundStatement() { void Parser::DiagnoseLabelAtEndOfCompoundStatement() {
if (getLangOpts().CPlusPlus) { if (getLangOpts().CPlusPlus) {
Diag(Tok, getLangOpts().CPlusPlus2b Diag(Tok, getLangOpts().CPlusPlus23
? diag::warn_cxx20_compat_label_end_of_compound_statement ? diag::warn_cxx20_compat_label_end_of_compound_statement
: diag::ext_cxx_label_end_of_compound_statement); : diag::ext_cxx_label_end_of_compound_statement);
} else { } else {
Diag(Tok, getLangOpts().C2x Diag(Tok, getLangOpts().C2x
? diag::warn_c2x_compat_label_end_of_compound_statement ? diag::warn_c2x_compat_label_end_of_compound_statement
: diag::ext_c_label_end_of_compound_statement); : diag::ext_c_label_end_of_compound_statement);
} }
} }
▲ Show 20 Lines • Show All 387 Lines • ▼ Show 20 Lines if (Tok.is(tok::kw_constexpr)) {
IsConstexpr = true; IsConstexpr = true;
ConsumeToken(); ConsumeToken();
} else { } else {
if (Tok.is(tok::exclaim)) { if (Tok.is(tok::exclaim)) {
NotLocation = ConsumeToken(); NotLocation = ConsumeToken();
} }
if (Tok.is(tok::kw_consteval)) { if (Tok.is(tok::kw_consteval)) {
Diag(Tok, getLangOpts().CPlusPlus2b ? diag::warn_cxx20_compat_consteval_if Diag(Tok, getLangOpts().CPlusPlus23 ? diag::warn_cxx20_compat_consteval_if
: diag::ext_consteval_if); : diag::ext_consteval_if);
IsConsteval = true; IsConsteval = true;
ConstevalLoc = ConsumeToken(); ConstevalLoc = ConsumeToken();
} }
} }
if (!IsConsteval && (NotLocation.isValid() || Tok.isNot(tok::l_paren))) { if (!IsConsteval && (NotLocation.isValid() || Tok.isNot(tok::l_paren))) {
Diag(Tok, diag::err_expected_lparen_after) << "if"; Diag(Tok, diag::err_expected_lparen_after) << "if";
SkipUntil(tok::semi); SkipUntil(tok::semi);
▲ Show 20 Lines • Show All 455 Lines • ▼ Show 20 Lines
/// '(' for-range-declaration ':' for-range-initializer ')' /// '(' for-range-declaration ':' for-range-initializer ')'
/// statement /// statement
/// [OBJC2] 'for' '(' declaration 'in' expr ')' statement /// [OBJC2] 'for' '(' declaration 'in' expr ')' statement
/// [OBJC2] 'for' '(' expr 'in' expr ')' statement /// [OBJC2] 'for' '(' expr 'in' expr ')' statement
/// ///
/// [C++] for-init-statement: /// [C++] for-init-statement:
/// [C++] expression-statement /// [C++] expression-statement
/// [C++] simple-declaration /// [C++] simple-declaration
/// [C++2b] alias-declaration /// [C++23] alias-declaration
/// ///
/// [C++0x] for-range-declaration: /// [C++0x] for-range-declaration:
/// [C++0x] attribute-specifier-seq[opt] type-specifier-seq declarator /// [C++0x] attribute-specifier-seq[opt] type-specifier-seq declarator
/// [C++0x] for-range-initializer: /// [C++0x] for-range-initializer:
/// [C++0x] expression /// [C++0x] expression
/// [C++0x] braced-init-list [TODO] /// [C++0x] braced-init-list [TODO]
StmtResult Parser::ParseForStatement(SourceLocation *TrailingElseLoc) { StmtResult Parser::ParseForStatement(SourceLocation *TrailingElseLoc) {
assert(Tok.is(tok::kw_for) && "Not a for stmt!"); assert(Tok.is(tok::kw_for) && "Not a for stmt!");
▲ Show 20 Lines • Show All 802 Lines • Show Last 20 Lines

clang/lib/Sema/Sema.cpp

Show First 20 Lines • Show All 2,163 Lines • ▼ Show 20 Linesstatic void checkEscapingByref(VarDecl *VD, Sema &S) {
QualType T = VD->getType(); QualType T = VD->getType();
EnterExpressionEvaluationContext scope( EnterExpressionEvaluationContext scope(
S, Sema::ExpressionEvaluationContext::PotentiallyEvaluated); S, Sema::ExpressionEvaluationContext::PotentiallyEvaluated);
SourceLocation Loc = VD->getLocation(); SourceLocation Loc = VD->getLocation();
Expr *VarRef = Expr *VarRef =
new (S.Context) DeclRefExpr(S.Context, VD, false, T, VK_LValue, Loc); new (S.Context) DeclRefExpr(S.Context, VD, false, T, VK_LValue, Loc);
ExprResult Result; ExprResult Result;
auto IE = InitializedEntity::InitializeBlock(Loc, T); auto IE = InitializedEntity::InitializeBlock(Loc, T);
if (S.getLangOpts().CPlusPlus2b) { if (S.getLangOpts().CPlusPlus23) {
auto *E = ImplicitCastExpr::Create(S.Context, T, CK_NoOp, VarRef, nullptr, auto *E = ImplicitCastExpr::Create(S.Context, T, CK_NoOp, VarRef, nullptr,
VK_XValue, FPOptionsOverride()); VK_XValue, FPOptionsOverride());
Result = S.PerformCopyInitialization(IE, SourceLocation(), E); Result = S.PerformCopyInitialization(IE, SourceLocation(), E);
} else { } else {
Result = S.PerformMoveOrCopyInitialization( Result = S.PerformMoveOrCopyInitialization(
IE, Sema::NamedReturnInfo{VD, Sema::NamedReturnInfo::MoveEligible}, IE, Sema::NamedReturnInfo{VD, Sema::NamedReturnInfo::MoveEligible},
VarRef); VarRef);
} }
▲ Show 20 Lines • Show All 564 Lines • Show Last 20 Lines

clang/lib/Sema/SemaDeclCXX.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 756 Lines • ▼ Show 20 LinesSema::ActOnDecompositionDeclarator(Scope *S, Declarator &D,
DeclContext *const DC = CurContext; DeclContext *const DC = CurContext;
// C++17 [dcl.dcl]/8: // C++17 [dcl.dcl]/8:
// The decl-specifier-seq shall contain only the type-specifier auto // The decl-specifier-seq shall contain only the type-specifier auto
// and cv-qualifiers. // and cv-qualifiers.
// C++20 [dcl.dcl]/8: // C++20 [dcl.dcl]/8:
// If decl-specifier-seq contains any decl-specifier other than static, // If decl-specifier-seq contains any decl-specifier other than static,
// thread_local, auto, or cv-qualifiers, the program is ill-formed. // thread_local, auto, or cv-qualifiers, the program is ill-formed.
// C++2b [dcl.pre]/6: // C++23 [dcl.pre]/6:
// Each decl-specifier in the decl-specifier-seq shall be static, // Each decl-specifier in the decl-specifier-seq shall be static,
// thread_local, auto (9.2.9.6 [dcl.spec.auto]), or a cv-qualifier. // thread_local, auto (9.2.9.6 [dcl.spec.auto]), or a cv-qualifier.
auto &DS = D.getDeclSpec(); auto &DS = D.getDeclSpec();
{ {
// Note: While constrained-auto needs to be checked, we do so separately so // Note: While constrained-auto needs to be checked, we do so separately so
// we can emit a better diagnostic. // we can emit a better diagnostic.
SmallVector<StringRef, 8> BadSpecifiers; SmallVector<StringRef, 8> BadSpecifiers;
SmallVector<SourceLocation, 8> BadSpecifierLocs; SmallVector<SourceLocation, 8> BadSpecifierLocs;
▲ Show 20 Lines • Show All 1,149 Lines • ▼ Show 20 Lines case Decl::Decomposition: {
// a definition of a variable of non-literal type or of static or // a definition of a variable of non-literal type or of static or
// thread storage duration or [before C++2a] for which no // thread storage duration or [before C++2a] for which no
// initialization is performed. // initialization is performed.
const auto *VD = cast<VarDecl>(DclIt); const auto *VD = cast<VarDecl>(DclIt);
if (VD->isThisDeclarationADefinition()) { if (VD->isThisDeclarationADefinition()) {
if (VD->isStaticLocal()) { if (VD->isStaticLocal()) {
if (Kind == Sema::CheckConstexprKind::Diagnose) { if (Kind == Sema::CheckConstexprKind::Diagnose) {
SemaRef.Diag(VD->getLocation(), SemaRef.Diag(VD->getLocation(),
SemaRef.getLangOpts().CPlusPlus2b SemaRef.getLangOpts().CPlusPlus23
? diag::warn_cxx20_compat_constexpr_var ? diag::warn_cxx20_compat_constexpr_var
: diag::ext_constexpr_static_var) : diag::ext_constexpr_static_var)
<< isa<CXXConstructorDecl>(Dcl) << isa<CXXConstructorDecl>(Dcl)
<< (VD->getTLSKind() == VarDecl::TLS_Dynamic); << (VD->getTLSKind() == VarDecl::TLS_Dynamic);
} else if (!SemaRef.getLangOpts().CPlusPlus2b) { } else if (!SemaRef.getLangOpts().CPlusPlus23) {
return false; return false;
} }
} }
if (SemaRef.LangOpts.CPlusPlus2b) { if (SemaRef.LangOpts.CPlusPlus23) {
CheckLiteralType(SemaRef, Kind, VD->getLocation(), VD->getType(), CheckLiteralType(SemaRef, Kind, VD->getLocation(), VD->getType(),
diag::warn_cxx20_compat_constexpr_var, diag::warn_cxx20_compat_constexpr_var,
isa<CXXConstructorDecl>(Dcl), isa<CXXConstructorDecl>(Dcl),
/*variable of non-literal type*/ 2); /*variable of non-literal type*/ 2);
} else if (CheckLiteralType( } else if (CheckLiteralType(
SemaRef, Kind, VD->getLocation(), VD->getType(), SemaRef, Kind, VD->getLocation(), VD->getType(),
diag::err_constexpr_local_var_non_literal_type, diag::err_constexpr_local_var_non_literal_type,
isa<CXXConstructorDecl>(Dcl))) { isa<CXXConstructorDecl>(Dcl))) {
▲ Show 20 Lines • Show All 322 Lines • ▼ Show 20 Lines if (SubStmt &&
!CheckConstexprFunctionStmt(SemaRef, Dcl, SubStmt, ReturnStmts, !CheckConstexprFunctionStmt(SemaRef, Dcl, SubStmt, ReturnStmts,
Cxx1yLoc, Cxx2aLoc, Cxx2bLoc, Kind)) Cxx1yLoc, Cxx2aLoc, Cxx2bLoc, Kind))
return false; return false;
} }
if (Kind == Sema::CheckConstexprKind::CheckValid) { if (Kind == Sema::CheckConstexprKind::CheckValid) {
// If this is only valid as an extension, report that we don't satisfy the // If this is only valid as an extension, report that we don't satisfy the
// constraints of the current language. // constraints of the current language.
if ((Cxx2bLoc.isValid() && !SemaRef.getLangOpts().CPlusPlus2b) || if ((Cxx2bLoc.isValid() && !SemaRef.getLangOpts().CPlusPlus23) ||
(Cxx2aLoc.isValid() && !SemaRef.getLangOpts().CPlusPlus20) || (Cxx2aLoc.isValid() && !SemaRef.getLangOpts().CPlusPlus20) ||
(Cxx1yLoc.isValid() && !SemaRef.getLangOpts().CPlusPlus17)) (Cxx1yLoc.isValid() && !SemaRef.getLangOpts().CPlusPlus17))
return false; return false;
} else if (Cxx2bLoc.isValid()) { } else if (Cxx2bLoc.isValid()) {
SemaRef.Diag(Cxx2bLoc, SemaRef.Diag(Cxx2bLoc,
SemaRef.getLangOpts().CPlusPlus2b SemaRef.getLangOpts().CPlusPlus23
? diag::warn_cxx20_compat_constexpr_body_invalid_stmt ? diag::warn_cxx20_compat_constexpr_body_invalid_stmt
: diag::ext_constexpr_body_invalid_stmt_cxx2b) : diag::ext_constexpr_body_invalid_stmt_cxx23)
<< isa<CXXConstructorDecl>(Dcl); << isa<CXXConstructorDecl>(Dcl);
} else if (Cxx2aLoc.isValid()) { } else if (Cxx2aLoc.isValid()) {
SemaRef.Diag(Cxx2aLoc, SemaRef.Diag(Cxx2aLoc,
SemaRef.getLangOpts().CPlusPlus20 SemaRef.getLangOpts().CPlusPlus20
? diag::warn_cxx17_compat_constexpr_body_invalid_stmt ? diag::warn_cxx17_compat_constexpr_body_invalid_stmt
: diag::ext_constexpr_body_invalid_stmt_cxx20) : diag::ext_constexpr_body_invalid_stmt_cxx20)
<< isa<CXXConstructorDecl>(Dcl); << isa<CXXConstructorDecl>(Dcl);
} else if (Cxx1yLoc.isValid()) { } else if (Cxx1yLoc.isValid()) {
▲ Show 20 Lines • Show All 13,675 Lines • ▼ Show 20 Linesbool Sema::CheckOverloadedOperatorDeclaration(FunctionDecl *FnDecl) {
// whose type is a class, a reference to a class, an enumeration, // whose type is a class, a reference to a class, an enumeration,
// or a reference to an enumeration. // or a reference to an enumeration.
// Note: Before C++23, a member function could not be static. The only member // Note: Before C++23, a member function could not be static. The only member
// function allowed to be static is the call operator function. // function allowed to be static is the call operator function.
if (CXXMethodDecl *MethodDecl = dyn_cast<CXXMethodDecl>(FnDecl)) { if (CXXMethodDecl *MethodDecl = dyn_cast<CXXMethodDecl>(FnDecl)) {
if (MethodDecl->isStatic()) { if (MethodDecl->isStatic()) {
if (Op == OO_Call || Op == OO_Subscript) if (Op == OO_Call || Op == OO_Subscript)
Diag(FnDecl->getLocation(), Diag(FnDecl->getLocation(),
(LangOpts.CPlusPlus2b (LangOpts.CPlusPlus23
? diag::warn_cxx20_compat_operator_overload_static ? diag::warn_cxx20_compat_operator_overload_static
: diag::ext_operator_overload_static)) : diag::ext_operator_overload_static))
<< FnDecl; << FnDecl;
else else
return Diag(FnDecl->getLocation(), diag::err_operator_overload_static) return Diag(FnDecl->getLocation(), diag::err_operator_overload_static)
<< FnDecl; << FnDecl;
} }
} else { } else {
Show All 24 Lines if (Op != OO_Call) {
for (auto *Param : FnDecl->parameters()) { for (auto *Param : FnDecl->parameters()) {
if (Param->hasDefaultArg()) { if (Param->hasDefaultArg()) {
FirstDefaultedParam = Param; FirstDefaultedParam = Param;
break; break;
} }
} }
if (FirstDefaultedParam) { if (FirstDefaultedParam) {
if (Op == OO_Subscript) { if (Op == OO_Subscript) {
Diag(FnDecl->getLocation(), LangOpts.CPlusPlus2b Diag(FnDecl->getLocation(), LangOpts.CPlusPlus23
? diag::ext_subscript_overload ? diag::ext_subscript_overload
: diag::error_subscript_overload) : diag::error_subscript_overload)
<< FnDecl->getDeclName() << 1 << FnDecl->getDeclName() << 1
<< FirstDefaultedParam->getDefaultArgRange(); << FirstDefaultedParam->getDefaultArgRange();
} else { } else {
return Diag(FirstDefaultedParam->getLocation(), return Diag(FirstDefaultedParam->getLocation(),
diag::err_operator_overload_default_arg) diag::err_operator_overload_default_arg)
<< FnDecl->getDeclName() << FnDecl->getDeclName()
Show All 34 Lines if (CanBeUnaryOperator && CanBeBinaryOperator) {
"All non-call overloaded operators are unary or binary!"); "All non-call overloaded operators are unary or binary!");
ErrorKind = 1; // 1 -> binary ErrorKind = 1; // 1 -> binary
} }
return Diag(FnDecl->getLocation(), diag::err_operator_overload_must_be) return Diag(FnDecl->getLocation(), diag::err_operator_overload_must_be)
<< FnDecl->getDeclName() << NumParams << ErrorKind; << FnDecl->getDeclName() << NumParams << ErrorKind;
} }
if (Op == OO_Subscript && NumParams != 2) { if (Op == OO_Subscript && NumParams != 2) {
Diag(FnDecl->getLocation(), LangOpts.CPlusPlus2b Diag(FnDecl->getLocation(), LangOpts.CPlusPlus23
? diag::ext_subscript_overload ? diag::ext_subscript_overload
: diag::error_subscript_overload) : diag::error_subscript_overload)
<< FnDecl->getDeclName() << (NumParams == 1 ? 0 : 2); << FnDecl->getDeclName() << (NumParams == 1 ? 0 : 2);
} }
// Overloaded operators other than operator() and operator[] cannot be // Overloaded operators other than operator() and operator[] cannot be
// variadic. // variadic.
if (Op != OO_Call && if (Op != OO_Call &&
▲ Show 20 Lines • Show All 2,552 Lines • Show Last 20 Lines

clang/lib/Sema/SemaExpr.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 3,951 Lines • ▼ Show 20 Lines if (Ty == Context.DoubleTy) {
Res = ImpCastExprToType(Res, Context.FloatTy, CK_FloatingCast).get(); Res = ImpCastExprToType(Res, Context.FloatTy, CK_FloatingCast).get();
} }
} }
} else if (!Literal.isIntegerLiteral()) { } else if (!Literal.isIntegerLiteral()) {
return ExprError(); return ExprError();
} else { } else {
QualType Ty; QualType Ty;
// 'z/uz' literals are a C++2b feature. // 'z/uz' literals are a C++23 feature.
if (Literal.isSizeT) if (Literal.isSizeT)
Diag(Tok.getLocation(), getLangOpts().CPlusPlus Diag(Tok.getLocation(), getLangOpts().CPlusPlus
? getLangOpts().CPlusPlus2b ? getLangOpts().CPlusPlus23
? diag::warn_cxx20_compat_size_t_suffix ? diag::warn_cxx20_compat_size_t_suffix
: diag::ext_cxx2b_size_t_suffix : diag::ext_cxx23_size_t_suffix
: diag::err_cxx2b_size_t_suffix); : diag::err_cxx23_size_t_suffix);
// 'wb/uwb' literals are a C2x feature. We support _BitInt as a type in C++, // 'wb/uwb' literals are a C2x feature. We support _BitInt as a type in C++,
// but we do not currently support the suffix in C++ mode because it's not // but we do not currently support the suffix in C++ mode because it's not
// entirely clear whether WG21 will prefer this suffix to return a library // entirely clear whether WG21 will prefer this suffix to return a library
// type such as std::bit_int instead of returning a _BitInt. // type such as std::bit_int instead of returning a _BitInt.
if (Literal.isBitInt && !getLangOpts().CPlusPlus) if (Literal.isBitInt && !getLangOpts().CPlusPlus)
PP.Diag(Tok.getLocation(), getLangOpts().C2x PP.Diag(Tok.getLocation(), getLangOpts().C2x
? diag::warn_c2x_compat_bitint_suffix ? diag::warn_c2x_compat_bitint_suffix
▲ Show 20 Lines • Show All 63 Lines • ▼ Show 20 Lines if (Literal.GetIntegerValue(ResultVal)) {
// Reset the result value to the smaller APInt and select the correct // Reset the result value to the smaller APInt and select the correct
// type to be used. Note, we zext even for signed values because the // type to be used. Note, we zext even for signed values because the
// literal itself is always an unsigned value (a preceeding - is a // literal itself is always an unsigned value (a preceeding - is a
// unary operator, not part of the literal). // unary operator, not part of the literal).
ResultVal = ResultVal.zextOrTrunc(Width); ResultVal = ResultVal.zextOrTrunc(Width);
Ty = Context.getBitIntType(Literal.isUnsigned, Width); Ty = Context.getBitIntType(Literal.isUnsigned, Width);
} }
// Check C++2b size_t literals. // Check C++23 size_t literals.
if (Literal.isSizeT) { if (Literal.isSizeT) {
assert(!Literal.MicrosoftInteger && assert(!Literal.MicrosoftInteger &&
"size_t literals can't be Microsoft literals"); "size_t literals can't be Microsoft literals");
unsigned SizeTSize = Context.getTargetInfo().getTypeWidth( unsigned SizeTSize = Context.getTargetInfo().getTypeWidth(
Context.getTargetInfo().getSizeType()); Context.getTargetInfo().getSizeType());
// Does it fit in size_t? // Does it fit in size_t?
if (ResultVal.isIntN(SizeTSize)) { if (ResultVal.isIntN(SizeTSize)) {
▲ Show 20 Lines • Show All 17,354 Lines • Show Last 20 Lines

clang/lib/Sema/SemaExprCXX.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 1,461 Lines • ▼ Show 20 Lines InitializationKind Kind =
? ListInitialization ? ListInitialization
? InitializationKind::CreateDirectList( ? InitializationKind::CreateDirectList(
TyBeginLoc, LParenOrBraceLoc, RParenOrBraceLoc) TyBeginLoc, LParenOrBraceLoc, RParenOrBraceLoc)
: InitializationKind::CreateDirect(TyBeginLoc, LParenOrBraceLoc, : InitializationKind::CreateDirect(TyBeginLoc, LParenOrBraceLoc,
RParenOrBraceLoc) RParenOrBraceLoc)
: InitializationKind::CreateValue(TyBeginLoc, LParenOrBraceLoc, : InitializationKind::CreateValue(TyBeginLoc, LParenOrBraceLoc,
RParenOrBraceLoc); RParenOrBraceLoc);
// C++1z [expr.type.conv]p1: // C++17 [expr.type.conv]p1:
// If the type is a placeholder for a deduced class type, [...perform class // If the type is a placeholder for a deduced class type, [...perform class
// template argument deduction...] // template argument deduction...]
// C++2b: // C++23:
// Otherwise, if the type contains a placeholder type, it is replaced by the // Otherwise, if the type contains a placeholder type, it is replaced by the
// type determined by placeholder type deduction. // type determined by placeholder type deduction.
DeducedType *Deduced = Ty->getContainedDeducedType(); DeducedType *Deduced = Ty->getContainedDeducedType();
if (Deduced && !Deduced->isDeduced() && if (Deduced && !Deduced->isDeduced() &&
isa<DeducedTemplateSpecializationType>(Deduced)) { isa<DeducedTemplateSpecializationType>(Deduced)) {
Ty = DeduceTemplateSpecializationFromInitializer(TInfo, Entity, Ty = DeduceTemplateSpecializationFromInitializer(TInfo, Entity,
Kind, Exprs); Kind, Exprs);
if (Ty.isNull()) if (Ty.isNull())
Show All 10 Lines if (Inits.empty())
return ExprError(Diag(TyBeginLoc, diag::err_auto_expr_init_no_expression) return ExprError(Diag(TyBeginLoc, diag::err_auto_expr_init_no_expression)
<< Ty << FullRange); << Ty << FullRange);
if (Inits.size() > 1) { if (Inits.size() > 1) {
Expr *FirstBad = Inits[1]; Expr *FirstBad = Inits[1];
return ExprError(Diag(FirstBad->getBeginLoc(), return ExprError(Diag(FirstBad->getBeginLoc(),
diag::err_auto_expr_init_multiple_expressions) diag::err_auto_expr_init_multiple_expressions)
<< Ty << FullRange); << Ty << FullRange);
} }
if (getLangOpts().CPlusPlus2b) { if (getLangOpts().CPlusPlus23) {
if (Ty->getAs<AutoType>()) if (Ty->getAs<AutoType>())
Diag(TyBeginLoc, diag::warn_cxx20_compat_auto_expr) << FullRange; Diag(TyBeginLoc, diag::warn_cxx20_compat_auto_expr) << FullRange;
} }
Expr *Deduce = Inits[0]; Expr *Deduce = Inits[0];
if (isa<InitListExpr>(Deduce)) if (isa<InitListExpr>(Deduce))
return ExprError( return ExprError(
Diag(Deduce->getBeginLoc(), diag::err_auto_expr_init_paren_braces) Diag(Deduce->getBeginLoc(), diag::err_auto_expr_init_paren_braces)
<< ListInitialization << Ty << FullRange); << ListInitialization << Ty << FullRange);
▲ Show 20 Lines • Show All 2,508 Lines • ▼ Show 20 LinesExprResult Sema::CheckCXXBooleanCondition(Expr *CondExpr, bool IsConstexpr) {
// C++11 6.4p4: // C++11 6.4p4:
// The value of a condition that is an initialized declaration in a statement // The value of a condition that is an initialized declaration in a statement
// other than a switch statement is the value of the declared variable // other than a switch statement is the value of the declared variable
// implicitly converted to type bool. If that conversion is ill-formed, the // implicitly converted to type bool. If that conversion is ill-formed, the
// program is ill-formed. // program is ill-formed.
// The value of a condition that is an expression is the value of the // The value of a condition that is an expression is the value of the
// expression, implicitly converted to bool. // expression, implicitly converted to bool.
// //
// C++2b 8.5.2p2 // C++23 8.5.2p2
// If the if statement is of the form if constexpr, the value of the condition // If the if statement is of the form if constexpr, the value of the condition
// is contextually converted to bool and the converted expression shall be // is contextually converted to bool and the converted expression shall be
// a constant expression. // a constant expression.
// //
ExprResult E = PerformContextuallyConvertToBool(CondExpr); ExprResult E = PerformContextuallyConvertToBool(CondExpr);
if (!IsConstexpr || E.isInvalid() || E.get()->isValueDependent()) if (!IsConstexpr || E.isInvalid() || E.get()->isValueDependent())
return E; return E;
▲ Show 20 Lines • Show All 5,107 Lines • Show Last 20 Lines

clang/lib/Sema/SemaModule.cpp

Show First 20 Lines • Show All 249 Lines • ▼ Show 20 Lines SourceLocation BeginLoc =
? SourceMgr.getLocForStartOfFile(SourceMgr.getMainFileID()) ? SourceMgr.getLocForStartOfFile(SourceMgr.getMainFileID())
: ModuleScopes.back().BeginLoc; : ModuleScopes.back().BeginLoc;
if (BeginLoc.isValid()) { if (BeginLoc.isValid()) {
Diag(BeginLoc, diag::note_global_module_introducer_missing) Diag(BeginLoc, diag::note_global_module_introducer_missing)
<< FixItHint::CreateInsertion(BeginLoc, "module;\n"); << FixItHint::CreateInsertion(BeginLoc, "module;\n");
} }
} }
// C++2b [module.unit]p1: ... The identifiers module and import shall not // C++23 [module.unit]p1: ... The identifiers module and import shall not
// appear as identifiers in a module-name or module-partition. All // appear as identifiers in a module-name or module-partition. All
// module-names either beginning with an identifier consisting of std // module-names either beginning with an identifier consisting of std
// followed by zero or more digits or containing a reserved identifier // followed by zero or more digits or containing a reserved identifier
// ([lex.name]) are reserved and shall not be specified in a // ([lex.name]) are reserved and shall not be specified in a
// module-declaration; no diagnostic is required. // module-declaration; no diagnostic is required.
// Test the first part of the path to see if it's std[0-9]+ but allow the // Test the first part of the path to see if it's std[0-9]+ but allow the
// name in a system header. // name in a system header.
▲ Show 20 Lines • Show All 770 Lines • Show Last 20 Lines

clang/lib/Sema/SemaOverload.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 9,923 Lines • ▼ Show 20 Lines if (FunctionDecl *Caller = S.getCurFunctionDecl(/*AllowLambda=*/true)) {
auto Cand2Emittable = P2 > EmitThreshold; auto Cand2Emittable = P2 > EmitThreshold;
if (Cand1Emittable && !Cand2Emittable) if (Cand1Emittable && !Cand2Emittable)
return true; return true;
if (!Cand1Emittable && Cand2Emittable) if (!Cand1Emittable && Cand2Emittable)
return false; return false;
} }
} }
// C++ [over.match.best]p1: (Changed in C++2b) // C++ [over.match.best]p1: (Changed in C++23)
// //
// -- if F is a static member function, ICS1(F) is defined such // -- if F is a static member function, ICS1(F) is defined such
// that ICS1(F) is neither better nor worse than ICS1(G) for // that ICS1(F) is neither better nor worse than ICS1(G) for
// any function G, and, symmetrically, ICS1(G) is neither // any function G, and, symmetrically, ICS1(G) is neither
// better nor worse than ICS1(F). // better nor worse than ICS1(F).
unsigned StartArg = 0; unsigned StartArg = 0;
if (Cand1.IgnoreObjectArgument || Cand2.IgnoreObjectArgument) if (Cand1.IgnoreObjectArgument || Cand2.IgnoreObjectArgument)
StartArg = 1; StartArg = 1;
▲ Show 20 Lines • Show All 5,153 Lines • ▼ Show 20 Lines if (NewFn.isInvalid())
return true; return true;
SmallVector<Expr *, 8> MethodArgs; SmallVector<Expr *, 8> MethodArgs;
MethodArgs.reserve(NumParams + 1); MethodArgs.reserve(NumParams + 1);
bool IsError = false; bool IsError = false;
// Initialize the implicit object parameter if needed. // Initialize the implicit object parameter if needed.
// Since C++2b, this could also be a call to a static call operator // Since C++23, this could also be a call to a static call operator
// which we emit as a regular CallExpr. // which we emit as a regular CallExpr.
if (Method->isInstance()) { if (Method->isInstance()) {
ExprResult ObjRes = PerformObjectArgumentInitialization( ExprResult ObjRes = PerformObjectArgumentInitialization(
Object.get(), /*Qualifier=*/nullptr, Best->FoundDecl, Method); Object.get(), /*Qualifier=*/nullptr, Best->FoundDecl, Method);
if (ObjRes.isInvalid()) if (ObjRes.isInvalid())
IsError = true; IsError = true;
else else
Object = ObjRes; Object = ObjRes;
▲ Show 20 Lines • Show All 514 Lines • Show Last 20 Lines

clang/lib/Sema/SemaStmt.cpp

Show First 20 Lines • Show All 3,358 Lines • ▼ Show 20 Lines
/// copy-elidable in either a (co_)return statement or throw expression, /// copy-elidable in either a (co_)return statement or throw expression,
/// without considering function return type, if applicable. /// without considering function return type, if applicable.
/// ///
/// \param E The expression being returned from the function or block, /// \param E The expression being returned from the function or block,
/// being thrown, or being co_returned from a coroutine. This expression /// being thrown, or being co_returned from a coroutine. This expression
/// might be modified by the implementation. /// might be modified by the implementation.
/// ///
/// \param Mode Overrides detection of current language mode /// \param Mode Overrides detection of current language mode
/// and uses the rules for C++2b. /// and uses the rules for C++23.
/// ///
/// \returns An aggregate which contains the Candidate and isMoveEligible /// \returns An aggregate which contains the Candidate and isMoveEligible
/// and isCopyElidable methods. If Candidate is non-null, it means /// and isCopyElidable methods. If Candidate is non-null, it means
/// isMoveEligible() would be true under the most permissive language standard. /// isMoveEligible() would be true under the most permissive language standard.
Sema::NamedReturnInfo Sema::getNamedReturnInfo(Expr *&E, Sema::NamedReturnInfo Sema::getNamedReturnInfo(Expr *&E,
SimplerImplicitMoveMode Mode) { SimplerImplicitMoveMode Mode) {
if (!E) if (!E)
return NamedReturnInfo(); return NamedReturnInfo();
// - in a return statement in a function [where] ... // - in a return statement in a function [where] ...
// ... the expression is the name of a non-volatile automatic object ... // ... the expression is the name of a non-volatile automatic object ...
const auto *DR = dyn_cast<DeclRefExpr>(E->IgnoreParens()); const auto *DR = dyn_cast<DeclRefExpr>(E->IgnoreParens());
if (!DR || DR->refersToEnclosingVariableOrCapture()) if (!DR || DR->refersToEnclosingVariableOrCapture())
return NamedReturnInfo(); return NamedReturnInfo();
const auto *VD = dyn_cast<VarDecl>(DR->getDecl()); const auto *VD = dyn_cast<VarDecl>(DR->getDecl());
if (!VD) if (!VD)
return NamedReturnInfo(); return NamedReturnInfo();
NamedReturnInfo Res = getNamedReturnInfo(VD); NamedReturnInfo Res = getNamedReturnInfo(VD);
if (Res.Candidate && !E->isXValue() && if (Res.Candidate && !E->isXValue() &&
(Mode == SimplerImplicitMoveMode::ForceOn || (Mode == SimplerImplicitMoveMode::ForceOn ||
(Mode != SimplerImplicitMoveMode::ForceOff && (Mode != SimplerImplicitMoveMode::ForceOff &&
getLangOpts().CPlusPlus2b))) { getLangOpts().CPlusPlus23))) {
E = ImplicitCastExpr::Create(Context, VD->getType().getNonReferenceType(), E = ImplicitCastExpr::Create(Context, VD->getType().getNonReferenceType(),
CK_NoOp, E, nullptr, VK_XValue, CK_NoOp, E, nullptr, VK_XValue,
FPOptionsOverride()); FPOptionsOverride());
} }
return Res; return Res;
} }
/// Determine whether the given NRVO candidate variable is move-eligible or /// Determine whether the given NRVO candidate variable is move-eligible or
▲ Show 20 Lines • Show All 127 Lines • ▼ Show 20 Lines
/// ///
/// This routine implements C++20 [class.copy.elision]p3, which attempts to /// This routine implements C++20 [class.copy.elision]p3, which attempts to
/// treat returned lvalues as rvalues in certain cases (to prefer move /// treat returned lvalues as rvalues in certain cases (to prefer move
/// construction), then falls back to treating them as lvalues if that failed. /// construction), then falls back to treating them as lvalues if that failed.
ExprResult Sema::PerformMoveOrCopyInitialization( ExprResult Sema::PerformMoveOrCopyInitialization(
const InitializedEntity &Entity, const NamedReturnInfo &NRInfo, Expr *Value, const InitializedEntity &Entity, const NamedReturnInfo &NRInfo, Expr *Value,
bool SupressSimplerImplicitMoves) { bool SupressSimplerImplicitMoves) {
if (getLangOpts().CPlusPlus && if (getLangOpts().CPlusPlus &&
(!getLangOpts().CPlusPlus2b || SupressSimplerImplicitMoves) && (!getLangOpts().CPlusPlus23 || SupressSimplerImplicitMoves) &&
NRInfo.isMoveEligible()) { NRInfo.isMoveEligible()) {
ImplicitCastExpr AsRvalue(ImplicitCastExpr::OnStack, Value->getType(), ImplicitCastExpr AsRvalue(ImplicitCastExpr::OnStack, Value->getType(),
CK_NoOp, Value, VK_XValue, FPOptionsOverride()); CK_NoOp, Value, VK_XValue, FPOptionsOverride());
Expr *InitExpr = &AsRvalue; Expr *InitExpr = &AsRvalue;
auto Kind = InitializationKind::CreateCopy(Value->getBeginLoc(), auto Kind = InitializationKind::CreateCopy(Value->getBeginLoc(),
Value->getBeginLoc()); Value->getBeginLoc());
InitializationSequence Seq(*this, Entity, Kind, InitExpr); InitializationSequence Seq(*this, Entity, Kind, InitExpr);
auto Res = Seq.getFailedOverloadResult(); auto Res = Seq.getFailedOverloadResult();
▲ Show 20 Lines • Show All 356 Lines • ▼ Show 20 LinesSema::ActOnReturnStmt(SourceLocation ReturnLoc, Expr *RetValExp,
CheckJumpOutOfSEHFinally(*this, ReturnLoc, *CurScope->getFnParent()); CheckJumpOutOfSEHFinally(*this, ReturnLoc, *CurScope->getFnParent());
return R; return R;
} }
static bool CheckSimplerImplicitMovesMSVCWorkaround(const Sema &S, static bool CheckSimplerImplicitMovesMSVCWorkaround(const Sema &S,
const Expr *E) { const Expr *E) {
if (!E || !S.getLangOpts().CPlusPlus2b || !S.getLangOpts().MSVCCompat) if (!E || !S.getLangOpts().CPlusPlus23 || !S.getLangOpts().MSVCCompat)
return false; return false;
const Decl *D = E->getReferencedDeclOfCallee(); const Decl *D = E->getReferencedDeclOfCallee();
if (!D || !S.SourceMgr.isInSystemHeader(D->getLocation())) if (!D || !S.SourceMgr.isInSystemHeader(D->getLocation()))
return false; return false;
for (const DeclContext *DC = D->getDeclContext(); DC; DC = DC->getParent()) { for (const DeclContext *DC = D->getDeclContext(); DC; DC = DC->getParent()) {
if (DC->isStdNamespace()) if (DC->isStdNamespace())
return true; return true;
} }
▲ Show 20 Lines • Show All 934 Lines • Show Last 20 Lines

clang/lib/Sema/SemaType.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 3,639 Lines • ▼ Show 20 Lines if (Deduced) {
case DeclaratorContext::ConversionId: case DeclaratorContext::ConversionId:
if (!SemaRef.getLangOpts().CPlusPlus14 || !IsCXXAutoType) if (!SemaRef.getLangOpts().CPlusPlus14 || !IsCXXAutoType)
Error = 14; // conversion-type-id Error = 14; // conversion-type-id
IsDeducedReturnType = true; IsDeducedReturnType = true;
break; break;
case DeclaratorContext::FunctionalCast: case DeclaratorContext::FunctionalCast:
if (isa<DeducedTemplateSpecializationType>(Deduced)) if (isa<DeducedTemplateSpecializationType>(Deduced))
break; break;
if (SemaRef.getLangOpts().CPlusPlus2b && IsCXXAutoType && if (SemaRef.getLangOpts().CPlusPlus23 && IsCXXAutoType &&
!Auto->isDecltypeAuto()) !Auto->isDecltypeAuto())
break; // auto(x) break; // auto(x)
[[fallthrough]]; [[fallthrough]];
case DeclaratorContext::TypeName: case DeclaratorContext::TypeName:
case DeclaratorContext::Association: case DeclaratorContext::Association:
Error = 15; // Generic Error = 15; // Generic
break; break;
case DeclaratorContext::File: case DeclaratorContext::File:
▲ Show 20 Lines • Show All 6,088 Lines • Show Last 20 Lines

clang/test/AST/Interp/if.cpp

// RUN: %clang_cc1 -std=c++2b -fsyntax-only -fexperimental-new-constant-interpreter %s -verify // RUN: %clang_cc1 -std=c++23 -fsyntax-only -fexperimental-new-constant-interpreter %s -verify
// RUN: %clang_cc1 -std=c++2b -fsyntax-only %s -verify=ref // RUN: %clang_cc1 -std=c++23 -fsyntax-only %s -verify=ref
// expected-no-diagnostics // expected-no-diagnostics
// ref-no-diagnostics // ref-no-diagnostics
namespace ConstEval { namespace ConstEval {
constexpr int f() { constexpr int f() {
int i = 0; int i = 0;
if consteval { if consteval {
Show All 36 Lines

clang/test/AST/ast-dump-if-json.cpp

// RUN: %clang_cc1 -triple x86_64-pc-linux -std=c++2b -ast-dump=json %s | FileCheck %s // RUN: %clang_cc1 -triple x86_64-pc-linux -std=c++23 -ast-dump=json %s | FileCheck %s
void func(int val) { void func(int val) {
if (val) if (val)
; ;
if (val) if (val)
; ;
else else
▲ Show 20 Lines • Show All 1,193 Lines • Show Last 20 Lines

clang/test/AST/ast-dump-stmt.cpp

// Test without serialization: // Test without serialization:
// RUN: %clang_cc1 -std=c++2b -triple x86_64-linux-gnu -fcxx-exceptions -ast-dump %s \ // RUN: %clang_cc1 -std=c++23 -triple x86_64-linux-gnu -fcxx-exceptions -ast-dump %s \
// RUN: | FileCheck -strict-whitespace %s // RUN: | FileCheck -strict-whitespace %s
// //
// Test with serialization: // Test with serialization:
// RUN: %clang_cc1 -std=c++2b -triple x86_64-linux-gnu -fcxx-exceptions -emit-pch -o %t %s // RUN: %clang_cc1 -std=c++23 -triple x86_64-linux-gnu -fcxx-exceptions -emit-pch -o %t %s
// RUN: %clang_cc1 -x c++ -std=c++2b -triple x86_64-linux-gnu -fcxx-exceptions -include-pch %t -ast-dump-all /dev/null \ // RUN: %clang_cc1 -x c++ -std=c++23 -triple x86_64-linux-gnu -fcxx-exceptions -include-pch %t -ast-dump-all /dev/null \
// RUN: | sed -e "s/ <undeserialized declarations>//" -e "s/ imported//" \ // RUN: | sed -e "s/ <undeserialized declarations>//" -e "s/ imported//" \
// RUN: | FileCheck -strict-whitespace %s // RUN: | FileCheck -strict-whitespace %s
namespace n { namespace n {
void function() {} void function() {}
int Variable; int Variable;
} }
using n::function; using n::function;
▲ Show 20 Lines • Show All 277 Lines • Show Last 20 Lines

clang/test/CXX/class/class.init/class.copy.elision/p3.cpp

// RUN: %clang_cc1 -std=c++2b -fsyntax-only -fcxx-exceptions -verify=expected,cxx11_2b,cxx2b %s // RUN: %clang_cc1 -std=c++23 -fsyntax-only -fcxx-exceptions -verify=expected,cxx11_23,cxx23 %s
// RUN: %clang_cc1 -std=c++20 -fsyntax-only -fcxx-exceptions -verify=expected,cxx98_20,cxx11_2b,cxx11_20 %s // RUN: %clang_cc1 -std=c++20 -fsyntax-only -fcxx-exceptions -verify=expected,cxx98_20,cxx11_23,cxx11_20 %s
// RUN: %clang_cc1 -std=c++11 -fsyntax-only -fcxx-exceptions -verify=expected,cxx98_20,cxx11_2b,cxx11_20 %s // RUN: %clang_cc1 -std=c++11 -fsyntax-only -fcxx-exceptions -verify=expected,cxx98_20,cxx11_23,cxx11_20 %s
// RUN: %clang_cc1 -std=c++98 -fsyntax-only -fcxx-exceptions -Wno-c++11-extensions -verify=expected,cxx98_20,cxx98 %s // RUN: %clang_cc1 -std=c++98 -fsyntax-only -fcxx-exceptions -Wno-c++11-extensions -verify=expected,cxx98_20,cxx98 %s
namespace test_delete_function { namespace test_delete_function {
struct A1 { struct A1 {
A1(); A1();
A1(const A1 &); A1(const A1 &);
A1(A1 &&) = delete; // expected-note {{'A1' has been explicitly marked deleted here}} A1(A1 &&) = delete; // expected-note {{'A1' has been explicitly marked deleted here}}
}; };
▲ Show 20 Lines • Show All 81 Lines • ▼ Show 20 Lines
// catch-clause parameter. // catch-clause parameter.
namespace test_throw_parameter { namespace test_throw_parameter {
void func(); void func();
struct A1 { struct A1 {
A1(const A1 &); A1(const A1 &);
A1(A1 &&) = delete; A1(A1 &&) = delete;
// expected-note@-1 2{{'A1' has been explicitly marked deleted here}} // expected-note@-1 2{{'A1' has been explicitly marked deleted here}}
// cxx11_2b-note@-2 3{{'A1' has been explicitly marked deleted here}} // cxx11_23-note@-2 3{{'A1' has been explicitly marked deleted here}}
}; };
void test1() { void test1() {
try { try {
func(); func();
} catch (A1 a) { } catch (A1 a) {
throw a; // expected-error {{call to deleted constructor of 'A1'}} throw a; // expected-error {{call to deleted constructor of 'A1'}}
} }
} }
▲ Show 20 Lines • Show All 93 Lines • ▼ Show 20 Linesstruct NeedRvalueRef {
NeedRvalueRef(A1 &&); NeedRvalueRef(A1 &&);
NeedRvalueRef(A2 &&); NeedRvalueRef(A2 &&);
NeedRvalueRef(B1 &&); NeedRvalueRef(B1 &&);
NeedRvalueRef(B2 &&); NeedRvalueRef(B2 &&);
}; };
struct NeedValue { struct NeedValue {
NeedValue(A1); // cxx98-note 2 {{passing argument to parameter here}} NeedValue(A1); // cxx98-note 2 {{passing argument to parameter here}}
NeedValue(A2); NeedValue(A2);
NeedValue(B1); // cxx11_2b-note 2 {{passing argument to parameter here}} NeedValue(B1); // cxx11_23-note 2 {{passing argument to parameter here}}
NeedValue(B2); NeedValue(B2);
}; };
struct A1 { struct A1 {
A1(); A1();
A1(A1 &&); A1(A1 &&);
A1(const A1 &) = delete; // cxx98-note 2 {{marked deleted here}} A1(const A1 &) = delete; // cxx98-note 2 {{marked deleted here}}
}; };
▲ Show 20 Lines • Show All 42 Lines • ▼ Show 20 LinesNeedValue test_2_3() {
// not same type // not same type
DerivedA2 a; DerivedA2 a;
return a; // cxx98-error {{calling a private constructor}} return a; // cxx98-error {{calling a private constructor}}
} }
struct B1 { struct B1 {
B1(); B1();
B1(const B1 &); B1(const B1 &);
B1(B1 &&) = delete; // cxx11_2b-note 3 {{'B1' has been explicitly marked deleted here}} B1(B1 &&) = delete; // cxx11_23-note 3 {{'B1' has been explicitly marked deleted here}}
// cxx98-note@-1 {{'B1' has been explicitly marked deleted here}} // cxx98-note@-1 {{'B1' has been explicitly marked deleted here}}
}; };
NeedValue test_3_1() { NeedValue test_3_1() {
// not rvalue reference // not rvalue reference
// same type // same type
B1 b; B1 b;
return b; // cxx11_2b-error {{call to deleted constructor of 'B1'}} return b; // cxx11_23-error {{call to deleted constructor of 'B1'}}
} }
class DerivedB1 : public B1 {}; class DerivedB1 : public B1 {};
B1 test_3_2() { B1 test_3_2() {
// rvalue reference // rvalue reference
// not same type // not same type
DerivedB1 b; DerivedB1 b;
return b; // expected-error {{call to deleted constructor of 'B1'}} return b; // expected-error {{call to deleted constructor of 'B1'}}
} }
NeedValue test_3_3() { NeedValue test_3_3() {
// not rvalue reference // not rvalue reference
// not same type // not same type
DerivedB1 b; DerivedB1 b;
return b; // cxx11_2b-error {{call to deleted constructor of 'B1'}} return b; // cxx11_23-error {{call to deleted constructor of 'B1'}}
} }
struct B2 { struct B2 {
B2(); B2();
B2(const B2 &); B2(const B2 &);
private: private:
B2(B2 &&); // cxx11_2b-note 3 {{declared private here}} B2(B2 &&); // cxx11_23-note 3 {{declared private here}}
// cxx98-note@-1 {{declared private here}} // cxx98-note@-1 {{declared private here}}
}; };
NeedValue test_4_1() { NeedValue test_4_1() {
// not rvalue reference // not rvalue reference
// same type // same type
B2 b; B2 b;
return b; // cxx11_2b-error {{calling a private constructor of class 'test_ctor_param_rvalue_ref::B2'}} return b; // cxx11_23-error {{calling a private constructor of class 'test_ctor_param_rvalue_ref::B2'}}
} }
class DerivedB2 : public B2 {}; class DerivedB2 : public B2 {};
B2 test_4_2() { B2 test_4_2() {
// rvalue reference // rvalue reference
// not same type // not same type
DerivedB2 b; DerivedB2 b;
return b; // expected-error {{calling a private constructor of class 'test_ctor_param_rvalue_ref::B2'}} return b; // expected-error {{calling a private constructor of class 'test_ctor_param_rvalue_ref::B2'}}
} }
NeedValue test_4_3() { NeedValue test_4_3() {
// not rvalue reference // not rvalue reference
// not same type // not same type
DerivedB2 b; DerivedB2 b;
return b; // cxx11_2b-error {{calling a private constructor of class 'test_ctor_param_rvalue_ref::B2'}} return b; // cxx11_23-error {{calling a private constructor of class 'test_ctor_param_rvalue_ref::B2'}}
} }
} // namespace test_ctor_param_rvalue_ref } // namespace test_ctor_param_rvalue_ref
namespace test_lvalue_ref_is_not_moved_from { namespace test_lvalue_ref_is_not_moved_from {
struct Target {}; struct Target {};
// expected-note@-1 {{candidate constructor (the implicit copy constructor) not viable}} // expected-note@-1 {{candidate constructor (the implicit copy constructor) not viable}}
// cxx11_2b-note@-2 {{candidate constructor (the implicit move constructor) not viable}} // cxx11_23-note@-2 {{candidate constructor (the implicit move constructor) not viable}}
struct CopyOnly { struct CopyOnly {
CopyOnly(CopyOnly &&) = delete; // expected-note {{has been explicitly marked deleted here}} CopyOnly(CopyOnly &&) = delete; // expected-note {{has been explicitly marked deleted here}}
CopyOnly(CopyOnly&); CopyOnly(CopyOnly&);
operator Target() && = delete; // expected-note {{has been explicitly marked deleted here}} operator Target() && = delete; // expected-note {{has been explicitly marked deleted here}}
operator Target() &; operator Target() &;
}; };
struct MoveOnly { struct MoveOnly {
MoveOnly(MoveOnly &&); // cxx11_2b-note {{copy constructor is implicitly deleted because}} MoveOnly(MoveOnly &&); // cxx11_23-note {{copy constructor is implicitly deleted because}}
operator Target() &&; // expected-note {{candidate function not viable}} operator Target() &&; // expected-note {{candidate function not viable}}
}; };
extern CopyOnly copyonly; extern CopyOnly copyonly;
extern MoveOnly moveonly; extern MoveOnly moveonly;
CopyOnly t1() { CopyOnly t1() {
CopyOnly& r = copyonly; CopyOnly& r = copyonly;
return r; return r;
} }
CopyOnly t2() { CopyOnly t2() {
CopyOnly&& r = static_cast<CopyOnly&&>(copyonly); CopyOnly&& r = static_cast<CopyOnly&&>(copyonly);
return r; // expected-error {{call to deleted constructor}} return r; // expected-error {{call to deleted constructor}}
} }
MoveOnly t3() { MoveOnly t3() {
MoveOnly& r = moveonly; MoveOnly& r = moveonly;
return r; // cxx11_2b-error {{call to implicitly-deleted copy constructor}} return r; // cxx11_23-error {{call to implicitly-deleted copy constructor}}
} }
MoveOnly t4() { MoveOnly t4() {
MoveOnly&& r = static_cast<MoveOnly&&>(moveonly); MoveOnly&& r = static_cast<MoveOnly&&>(moveonly);
return r; return r;
} }
Target t5() { Target t5() {
▲ Show 20 Lines • Show All 68 Lines • ▼ Show 20 Lines
ConstCopyOnly t1() { ConstCopyOnly t1() {
ConstCopyOnly x; ConstCopyOnly x;
return x; // cxx98-error {{call to deleted constructor}} return x; // cxx98-error {{call to deleted constructor}}
} }
struct NonConstCopyOnly { struct NonConstCopyOnly {
NonConstCopyOnly(); NonConstCopyOnly();
NonConstCopyOnly(NonConstCopyOnly &); NonConstCopyOnly(NonConstCopyOnly &);
NonConstCopyOnly(const NonConstCopyOnly &) = delete; // cxx11_2b-note {{marked deleted here}} NonConstCopyOnly(const NonConstCopyOnly &) = delete; // cxx11_23-note {{marked deleted here}}
}; };
NonConstCopyOnly t2() { NonConstCopyOnly t2() {
NonConstCopyOnly x; NonConstCopyOnly x;
return x; // cxx11_2b-error {{call to deleted constructor}} return x; // cxx11_23-error {{call to deleted constructor}}
} }
} // namespace test_constandnonconstcopy } // namespace test_constandnonconstcopy
namespace test_conversion { namespace test_conversion {
struct B; struct B;
struct A { struct A {
Show All 11 Lines
}; };
C test2(D x) { return x; } // expected-error {{invokes a deleted function}} C test2(D x) { return x; } // expected-error {{invokes a deleted function}}
} // namespace test_conversion } // namespace test_conversion
namespace test_simpler_implicit_move { namespace test_simpler_implicit_move {
struct CopyOnly { struct CopyOnly {
CopyOnly(); // cxx2b-note {{candidate constructor not viable: requires 0 arguments, but 1 was provided}} CopyOnly(); // cxx23-note {{candidate constructor not viable: requires 0 arguments, but 1 was provided}}
// cxx2b-note@-1 {{candidate constructor not viable: requires 0 arguments, but 1 was provided}} // cxx23-note@-1 {{candidate constructor not viable: requires 0 arguments, but 1 was provided}}
CopyOnly(CopyOnly &); // cxx2b-note {{candidate constructor not viable: expects an lvalue for 1st argument}} CopyOnly(CopyOnly &); // cxx23-note {{candidate constructor not viable: expects an lvalue for 1st argument}}
// cxx2b-note@-1 {{candidate constructor not viable: expects an lvalue for 1st argument}} // cxx23-note@-1 {{candidate constructor not viable: expects an lvalue for 1st argument}}
}; };
struct MoveOnly { struct MoveOnly {
MoveOnly(); MoveOnly();
MoveOnly(MoveOnly &&); MoveOnly(MoveOnly &&);
}; };
MoveOnly &&rref(); MoveOnly &&rref();
MoveOnly &&test1(MoveOnly &&w) { MoveOnly &&test1(MoveOnly &&w) {
return w; // cxx98_20-error {{cannot bind to lvalue of type}} return w; // cxx98_20-error {{cannot bind to lvalue of type}}
} }
CopyOnly test2(bool b) { CopyOnly test2(bool b) {
static CopyOnly w1; static CopyOnly w1;
CopyOnly w2; CopyOnly w2;
if (b) { if (b) {
return w1; return w1;
} else { } else {
return w2; // cxx2b-error {{no matching constructor for initialization}} return w2; // cxx23-error {{no matching constructor for initialization}}
} }
} }
template <class T> T &&test3(T &&x) { return x; } // cxx98_20-error {{cannot bind to lvalue of type}} template <class T> T &&test3(T &&x) { return x; } // cxx98_20-error {{cannot bind to lvalue of type}}
template MoveOnly& test3<MoveOnly&>(MoveOnly&); template MoveOnly& test3<MoveOnly&>(MoveOnly&);
template MoveOnly &&test3<MoveOnly>(MoveOnly &&); // cxx98_20-note {{in instantiation of function template specialization}} template MoveOnly &&test3<MoveOnly>(MoveOnly &&); // cxx98_20-note {{in instantiation of function template specialization}}
MoveOnly &&test4() { MoveOnly &&test4() {
MoveOnly &&x = rref(); MoveOnly &&x = rref();
return x; // cxx98_20-error {{cannot bind to lvalue of type}} return x; // cxx98_20-error {{cannot bind to lvalue of type}}
} }
void test5() try { void test5() try {
CopyOnly x; CopyOnly x;
throw x; // cxx2b-error {{no matching constructor for initialization}} throw x; // cxx23-error {{no matching constructor for initialization}}
} catch (...) { } catch (...) {
} }
} // namespace test_simpler_implicit_move } // namespace test_simpler_implicit_move
namespace test_auto_variables { namespace test_auto_variables {
struct S {}; struct S {};
▲ Show 20 Lines • Show All 56 Lines • Show Last 20 Lines

clang/test/CXX/dcl.dcl/dcl.spec/dcl.constexpr/dtor.cpp

// RUN: %clang_cc1 -std=c++2a -verify=expected,cxx2a %s // RUN: %clang_cc1 -std=c++2a -verify=expected,cxx2a %s
// RUN: %clang_cc1 -std=c++2b -verify=expected %s // RUN: %clang_cc1 -std=c++23 -verify=expected %s
// p3: if the function is a constructor or destructor, its class shall not have // p3: if the function is a constructor or destructor, its class shall not have
// any virtual base classes; // any virtual base classes;
namespace vbase { namespace vbase {
struct A {}; struct A {};
struct B : virtual A { // expected-note {{virtual}} struct B : virtual A { // expected-note {{virtual}}
constexpr ~B() {} // expected-error {{constexpr member function not allowed in struct with virtual base class}} constexpr ~B() {} // expected-error {{constexpr member function not allowed in struct with virtual base class}}
}; };
} }
namespace contents { namespace contents {
struct A { struct A {
constexpr ~A() { constexpr ~A() {
return; return;
goto x; // cxx2a-warning {{use of this statement in a constexpr function is a C++2b extension}} goto x; // cxx2a-warning {{use of this statement in a constexpr function is a C++23 extension}}
x: ; x: ;
} }
}; };
struct B { struct B {
constexpr ~B() { constexpr ~B() {
x:; // cxx2a-warning {{use of this statement in a constexpr function is a C++2b extension}} x:; // cxx2a-warning {{use of this statement in a constexpr function is a C++23 extension}}
} }
}; };
struct Nonlit { // cxx2a-note {{'Nonlit' is not literal because}} struct Nonlit { // cxx2a-note {{'Nonlit' is not literal because}}
Nonlit(); Nonlit();
}; };
struct C { struct C {
constexpr ~C() { constexpr ~C() {
return; return;
Nonlit nl; // cxx2a-error {{variable of non-literal type 'Nonlit' cannot be defined in a constexpr function before C++2b}} Nonlit nl; // cxx2a-error {{variable of non-literal type 'Nonlit' cannot be defined in a constexpr function before C++23}}
} }
}; };
struct D { struct D {
constexpr ~D() { constexpr ~D() {
return; return;
static int a; // cxx2a-warning {{definition of a static variable in a constexpr function is a C++2b extension}} static int a; // cxx2a-warning {{definition of a static variable in a constexpr function is a C++23 extension}}
} }
}; };
struct E { struct E {
constexpr ~E() { constexpr ~E() {
return; return;
thread_local int e; // cxx2a-warning {{definition of a thread_local variable in a constexpr function is a C++2b extension}} thread_local int e; // cxx2a-warning {{definition of a thread_local variable in a constexpr function is a C++23 extension}}
} }
}; };
struct F { struct F {
constexpr ~F() { constexpr ~F() {
return; return;
extern int f; extern int f;
} }
}; };
Show All 20 Lines

clang/test/CXX/dcl.dcl/dcl.spec/dcl.constexpr/p3-2b.cpp

// RUN: %clang_cc1 -verify -std=c++2b -Wpre-c++2b-compat %s // RUN: %clang_cc1 -verify -std=c++23 -Wpre-c++23-compat %s
constexpr int h(int n) { constexpr int h(int n) {
if (!n) if (!n)
return 0; return 0;
static const int m = n; // expected-warning {{definition of a static variable in a constexpr function is incompatible with C++ standards before C++2b}} static const int m = n; // expected-warning {{definition of a static variable in a constexpr function is incompatible with C++ standards before C++23}}
return m; return m;
} }
constexpr int i(int n) { constexpr int i(int n) {
if (!n) if (!n)
return 0; return 0;
thread_local const int m = n; // expected-warning {{definition of a thread_local variable in a constexpr function is incompatible with C++ standards before C++2b}} thread_local const int m = n; // expected-warning {{definition of a thread_local variable in a constexpr function is incompatible with C++ standards before C++23}}
return m; return m;
} }
constexpr int g() { // expected-error {{constexpr function never produces a constant expression}} constexpr int g() { // expected-error {{constexpr function never produces a constant expression}}
goto test; // expected-note {{subexpression not valid in a constant expression}} \ goto test; // expected-note {{subexpression not valid in a constant expression}} \
// expected-warning {{use of this statement in a constexpr function is incompatible with C++ standards before C++2b}} // expected-warning {{use of this statement in a constexpr function is incompatible with C++ standards before C++23}}
test: test:
return 0; return 0;
} }
constexpr void h() { constexpr void h() {
label:; // expected-warning {{use of this statement in a constexpr function is incompatible with C++ standards before C++2b}} label:; // expected-warning {{use of this statement in a constexpr function is incompatible with C++ standards before C++23}}
} }
struct NonLiteral { // expected-note 2 {{'NonLiteral' is not literal}} struct NonLiteral { // expected-note 2 {{'NonLiteral' is not literal}}
NonLiteral() {} NonLiteral() {}
}; };
constexpr void non_literal() { // expected-error {{constexpr function never produces a constant expression}} constexpr void non_literal() { // expected-error {{constexpr function never produces a constant expression}}
NonLiteral n; // expected-note {{non-literal type 'NonLiteral' cannot be used in a constant expression}} \ NonLiteral n; // expected-note {{non-literal type 'NonLiteral' cannot be used in a constant expression}} \
// expected-warning {{definition of a variable of non-literal type in a constexpr function is incompatible with C++ standards before C++2b}} // expected-warning {{definition of a variable of non-literal type in a constexpr function is incompatible with C++ standards before C++23}}
} }
constexpr void non_literal2(bool b) { constexpr void non_literal2(bool b) {
if (!b) if (!b)
NonLiteral n; // expected-warning {{definition of a variable of non-literal type in a constexpr function is incompatible with C++ standards before C++2b}} NonLiteral n; // expected-warning {{definition of a variable of non-literal type in a constexpr function is incompatible with C++ standards before C++23}}
} }
constexpr int c_thread_local(int n) { constexpr int c_thread_local(int n) {
if (!n) if (!n)
return 0; return 0;
static _Thread_local int a; // expected-warning {{definition of a static variable in a constexpr function is incompatible with C++ standards before C++2b}} static _Thread_local int a; // expected-warning {{definition of a static variable in a constexpr function is incompatible with C++ standards before C++23}}
_Thread_local int b; // // expected-error {{'_Thread_local' variables must have global storage}} _Thread_local int b; // // expected-error {{'_Thread_local' variables must have global storage}}
return 0; return 0;
} }
constexpr int gnu_thread_local(int n) { constexpr int gnu_thread_local(int n) {
if (!n) if (!n)
return 0; return 0;
static __thread int a; // expected-warning {{definition of a static variable in a constexpr function is incompatible with C++ standards before C++2b}} static __thread int a; // expected-warning {{definition of a static variable in a constexpr function is incompatible with C++ standards before C++23}}
__thread int b; // expected-error {{'__thread' variables must have global storage}} __thread int b; // expected-error {{'__thread' variables must have global storage}}
return 0; return 0;
} }

clang/test/CXX/dcl.dcl/dcl.spec/dcl.constexpr/p3.cpp

// RUN: %clang_cc1 -fcxx-exceptions -verify=expected,beforecxx14,beforecxx20,beforecxx2b -std=c++11 %s // RUN: %clang_cc1 -fcxx-exceptions -verify=expected,beforecxx14,beforecxx20,beforecxx23 -std=c++11 %s
// RUN: %clang_cc1 -fcxx-exceptions -verify=expected,aftercxx14,beforecxx20,beforecxx2b -std=c++14 %s // RUN: %clang_cc1 -fcxx-exceptions -verify=expected,aftercxx14,beforecxx20,beforecxx23 -std=c++14 %s
// RUN: %clang_cc1 -fcxx-exceptions -verify=expected,aftercxx14,aftercxx20,beforecxx2b -std=c++20 %s // RUN: %clang_cc1 -fcxx-exceptions -verify=expected,aftercxx14,aftercxx20,beforecxx23 -std=c++20 %s
// RUN: %clang_cc1 -fcxx-exceptions -verify=expected,aftercxx14,aftercxx20 -std=c++2b %s // RUN: %clang_cc1 -fcxx-exceptions -verify=expected,aftercxx14,aftercxx20 -std=c++23 %s
namespace N { namespace N {
typedef char C; typedef char C;
} }
namespace M { namespace M {
typedef double D; typedef double D;
} }
▲ Show 20 Lines • Show All 106 Lines • ▼ Show 20 Linesconstexpr int DisallowedStmtsCXX14_1(bool b) {
// - an asm-definition // - an asm-definition
if (b) if (b)
asm("int3"); // beforecxx20-warning {{use of this statement in a constexpr function is a C++20 extension}} asm("int3"); // beforecxx20-warning {{use of this statement in a constexpr function is a C++20 extension}}
return 0; return 0;
} }
constexpr int DisallowedStmtsCXX14_2() { constexpr int DisallowedStmtsCXX14_2() {
return 0; // beforecxx14-note {{previous}} return 0; // beforecxx14-note {{previous}}
// - a goto statement // - a goto statement
goto x; // beforecxx2b-warning {{use of this statement in a constexpr function is a C++2b extension}} goto x; // beforecxx23-warning {{use of this statement in a constexpr function is a C++23 extension}}
x:; x:;
return 0; // beforecxx14-warning {{multiple return}} return 0; // beforecxx14-warning {{multiple return}}
} }
constexpr int DisallowedStmtsCXX14_2_1() { constexpr int DisallowedStmtsCXX14_2_1() {
merp: // beforecxx2b-warning {{use of this statement in a constexpr function is a C++2b extension}} merp: // beforecxx23-warning {{use of this statement in a constexpr function is a C++23 extension}}
return 0; return 0;
} }
constexpr int DisallowedStmtsCXX14_3() { constexpr int DisallowedStmtsCXX14_3() {
// - a try-block, // - a try-block,
try { } // beforecxx20-warning {{use of this statement in a constexpr function is a C++20 extension}} try { } // beforecxx20-warning {{use of this statement in a constexpr function is a C++20 extension}}
catch (...) {} catch (...) {}
return 0; return 0;
} }
constexpr int DisallowedStmtsCXX14_4() { constexpr int DisallowedStmtsCXX14_4() {
// - a definition of a variable of non-literal type // - a definition of a variable of non-literal type
return 0; return 0;
NonLiteral nl; // beforecxx2b-error {{variable of non-literal type 'NonLiteral' cannot be defined in a constexpr function before C++2b}} \ NonLiteral nl; // beforecxx23-error {{variable of non-literal type 'NonLiteral' cannot be defined in a constexpr function before C++23}} \
// beforecxx2b-note@14 {{'NonLiteral' is not literal}} // beforecxx23-note@14 {{'NonLiteral' is not literal}}
} }
constexpr int DisallowedStmtsCXX14_5() { constexpr int DisallowedStmtsCXX14_5() {
return 0; return 0;
// - a definition of a variable of static storage duration // - a definition of a variable of static storage duration
static constexpr int n = 123; // beforecxx2b-warning {{definition of a static variable in a constexpr function is a C++2b extension}} \ static constexpr int n = 123; // beforecxx23-warning {{definition of a static variable in a constexpr function is a C++23 extension}} \
// beforecxx14-warning {{variable declaration in a constexpr function is a C++14 extension}} // beforecxx14-warning {{variable declaration in a constexpr function is a C++14 extension}}
} }
constexpr int DisallowedStmtsCXX14_6() { constexpr int DisallowedStmtsCXX14_6() {
// - a definition of a variable of thread storage duration // - a definition of a variable of thread storage duration
return 0; return 0;
thread_local constexpr int n = 123; // beforecxx14-warning {{variable declaration in a constexpr function is a C++14 extension}} \ thread_local constexpr int n = 123; // beforecxx14-warning {{variable declaration in a constexpr function is a C++14 extension}} \
// beforecxx2b-warning {{definition of a thread_local variable in a constexpr function is a C++2b extension}} // beforecxx23-warning {{definition of a thread_local variable in a constexpr function is a C++23 extension}}
} }
constexpr int DisallowedStmtsCXX14_7() { constexpr int DisallowedStmtsCXX14_7() {
// - a definition of a variable for which no initialization is performed // - a definition of a variable for which no initialization is performed
return 0; return 0;
int n; // beforecxx20-warning {{uninitialized variable in a constexpr function}} int n; // beforecxx20-warning {{uninitialized variable in a constexpr function}}
} }
constexpr int ForStmt() { constexpr int ForStmt() {
▲ Show 20 Lines • Show All 89 Lines • ▼ Show 20 Linesnamespace std_example {
} }
constexpr int abs(int x) { constexpr int abs(int x) {
if (x < 0) // beforecxx14-warning {{C++14}} if (x < 0) // beforecxx14-warning {{C++14}}
x = -x; x = -x;
return x; return x;
} }
constexpr int first(int n) { constexpr int first(int n) {
return 0; return 0;
static int value = n; // beforecxx2b-warning {{definition of a static variable in a constexpr function is a C++2b extension}} \ static int value = n; // beforecxx23-warning {{definition of a static variable in a constexpr function is a C++23 extension}} \
// beforecxx14-warning {{variable declaration in a constexpr function is a C++14 extension}} // beforecxx14-warning {{variable declaration in a constexpr function is a C++14 extension}}
} }
constexpr int uninit() { constexpr int uninit() {
int a; // beforecxx20-warning {{uninitialized}} int a; // beforecxx20-warning {{uninitialized}}
return a; return a;
} }
constexpr int prev(int x) { // beforecxx14-error {{never produces a constant expression}} constexpr int prev(int x) { // beforecxx14-error {{never produces a constant expression}}
return --x; // beforecxx14-note {{subexpression}} return --x; // beforecxx14-note {{subexpression}}
Show All 9 Lines

clang/test/CXX/dcl.dcl/dcl.spec/dcl.type/dcl.spec.auto/p7-cxx14.cpp

// RUN: %clang_cc1 -verify -std=c++2b -verify=expected,cxx2b %s // RUN: %clang_cc1 -verify -std=c++23 -verify=expected,cxx23 %s
// RUN: %clang_cc1 -verify -std=c++20 -verify=expected,cxx14_20 %s // RUN: %clang_cc1 -verify -std=c++20 -verify=expected,cxx14_20 %s
// RUN: %clang_cc1 -verify -std=c++14 -verify=expected,cxx14_20 %s // RUN: %clang_cc1 -verify -std=c++14 -verify=expected,cxx14_20 %s
namespace std { namespace std {
template<typename T> struct initializer_list { template<typename T> struct initializer_list {
const T *p; const T *p;
unsigned long n; unsigned long n;
initializer_list(const T *p, unsigned long n); initializer_list(const T *p, unsigned long n);
Show All 15 Lines
auto x3a = i; auto x3a = i;
decltype(auto) x3d = i; decltype(auto) x3d = i;
using Int = decltype(x3a); using Int = decltype(x3a);
using Int = decltype(x3d); using Int = decltype(x3d);
auto x4a = (i); auto x4a = (i);
decltype(auto) x4d = (i); decltype(auto) x4d = (i);
using Int = decltype(x4a); using Int = decltype(x4a);
using IntLRef = decltype(x4d); // cxx2b-note {{previous definition is here}} using IntLRef = decltype(x4d); // cxx23-note {{previous definition is here}}
auto x5a = f(); auto x5a = f();
decltype(auto) x5d = f(); decltype(auto) x5d = f();
using Int = decltype(x5a); using Int = decltype(x5a);
using IntRRef = decltype(x5d); using IntRRef = decltype(x5d);
auto x6a = { 1, 2 }; auto x6a = { 1, 2 };
decltype(auto) x6d = { 1, 2 }; // expected-error {{cannot deduce 'decltype(auto)' from initializer list}} decltype(auto) x6d = { 1, 2 }; // expected-error {{cannot deduce 'decltype(auto)' from initializer list}}
Show All 34 Lines
auto f2a(int n) { return n; } auto f2a(int n) { return n; }
decltype(auto) f2d(int n) { return n; } decltype(auto) f2d(int n) { return n; }
using Int = decltype(f2a(0)); using Int = decltype(f2a(0));
using Int = decltype(f2d(0)); using Int = decltype(f2d(0));
auto f3a(int n) { return (n); } auto f3a(int n) { return (n); }
decltype(auto) f3d(int n) { return (n); } // expected-warning {{reference to stack memory}} decltype(auto) f3d(int n) { return (n); } // expected-warning {{reference to stack memory}}
using Int = decltype(f3a(0)); using Int = decltype(f3a(0));
using IntLRef = decltype(f3d(0)); // cxx2b-error {{type alias redefinition with different types ('decltype(f3d(0))' (aka 'int &&') vs 'decltype(x4d)' (aka 'int &'))}} using IntLRef = decltype(f3d(0)); // cxx23-error {{type alias redefinition with different types ('decltype(f3d(0))' (aka 'int &&') vs 'decltype(x4d)' (aka 'int &'))}}
auto f4a(int n) { return f(); } auto f4a(int n) { return f(); }
decltype(auto) f4d(int n) { return f(); } decltype(auto) f4d(int n) { return f(); }
using Int = decltype(f4a(0)); using Int = decltype(f4a(0));
using IntRRef = decltype(f4d(0)); using IntRRef = decltype(f4d(0));
auto f5aa(int n) { auto x = f(); return x; } auto f5aa(int n) { auto x = f(); return x; }
auto f5ad(int n) { decltype(auto) x = f(); return x; } auto f5ad(int n) { decltype(auto) x = f(); return x; }
decltype(auto) f5da(int n) { auto x = f(); return x; } decltype(auto) f5da(int n) { auto x = f(); return x; }
decltype(auto) f5dd(int n) { decltype(auto) x = f(); return x; } // cxx14_20-error {{rvalue reference to type 'int' cannot bind to lvalue}} decltype(auto) f5dd(int n) { decltype(auto) x = f(); return x; } // cxx14_20-error {{rvalue reference to type 'int' cannot bind to lvalue}}
using Int = decltype(f5aa(0)); using Int = decltype(f5aa(0));
using Int = decltype(f5ad(0)); using Int = decltype(f5ad(0));
using Int = decltype(f5da(0)); using Int = decltype(f5da(0));
auto init_list_1() { return { 1, 2, 3 }; } // expected-error {{cannot deduce return type from initializer list}} auto init_list_1() { return { 1, 2, 3 }; } // expected-error {{cannot deduce return type from initializer list}}
decltype(auto) init_list_2() { return { 1, 2, 3 }; } // expected-error {{cannot deduce return type from initializer list}} decltype(auto) init_list_2() { return { 1, 2, 3 }; } // expected-error {{cannot deduce return type from initializer list}}

clang/test/CXX/dcl.dcl/dcl.spec/dcl.type/dcl.type.auto.deduct/p2.cpp

// RUN: %clang_cc1 -std=c++2b -verify %s // RUN: %clang_cc1 -std=c++23 -verify %s
// p2.3 allows only T = auto in T(x). // p2.3 allows only T = auto in T(x).
void test_decay() { void test_decay() {
int v[3]; int v[3];
static_assert(__is_same(decltype(auto(v)), int *)); static_assert(__is_same(decltype(auto(v)), int *));
static_assert(__is_same(decltype(auto{v}), int *)); static_assert(__is_same(decltype(auto{v}), int *));
static_assert(__is_same(decltype(auto("lit")), char const *)); static_assert(__is_same(decltype(auto("lit")), char const *));
▲ Show 20 Lines • Show All 72 Lines • Show Last 20 Lines

clang/test/CXX/drs/dr0xx.cpp

// RUN: %clang_cc1 -std=c++98 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors -Wno-bind-to-temporary-copy // RUN: %clang_cc1 -std=c++98 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors -Wno-bind-to-temporary-copy
// RUN: %clang_cc1 -std=c++11 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors -triple %itanium_abi_triple // RUN: %clang_cc1 -std=c++11 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors -triple %itanium_abi_triple
// RUN: %clang_cc1 -std=c++14 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors -triple %itanium_abi_triple // RUN: %clang_cc1 -std=c++14 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors -triple %itanium_abi_triple
// RUN: %clang_cc1 -std=c++17 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors -triple %itanium_abi_triple // RUN: %clang_cc1 -std=c++17 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors -triple %itanium_abi_triple
// RUN: %clang_cc1 -std=c++20 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors -triple %itanium_abi_triple // RUN: %clang_cc1 -std=c++20 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors -triple %itanium_abi_triple
// RUN: %clang_cc1 -std=c++2b %s -verify -fexceptions -fcxx-exceptions -pedantic-errors -triple %itanium_abi_triple // RUN: %clang_cc1 -std=c++23 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors -triple %itanium_abi_triple
namespace dr1 { // dr1: no namespace dr1 { // dr1: no
namespace X { extern "C" void dr1_f(int a = 1); } namespace X { extern "C" void dr1_f(int a = 1); }
namespace Y { extern "C" void dr1_f(int a = 1); } namespace Y { extern "C" void dr1_f(int a = 1); }
using X::dr1_f; using Y::dr1_f; using X::dr1_f; using Y::dr1_f;
void g() { void g() {
dr1_f(0); dr1_f(0);
// FIXME: This should be rejected, due to the ambiguous default argument. // FIXME: This should be rejected, due to the ambiguous default argument.
▲ Show 20 Lines • Show All 1,253 Lines • Show Last 20 Lines

clang/test/CXX/drs/dr10xx.cpp

// RUN: %clang_cc1 -std=c++98 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors // RUN: %clang_cc1 -std=c++98 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
// RUN: %clang_cc1 -std=c++11 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors // 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++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++17 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
// RUN: %clang_cc1 -std=c++20 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors // RUN: %clang_cc1 -std=c++20 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
// RUN: %clang_cc1 -std=c++2b %s -verify -fexceptions -fcxx-exceptions -pedantic-errors // RUN: %clang_cc1 -std=c++23 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
namespace std { namespace std {
__extension__ typedef __SIZE_TYPE__ size_t; __extension__ typedef __SIZE_TYPE__ size_t;
template<typename T> struct initializer_list { template<typename T> struct initializer_list {
const T *p; size_t n; const T *p; size_t n;
initializer_list(const T *p, size_t n); initializer_list(const T *p, size_t n);
}; };
▲ Show 20 Lines • Show All 86 Lines • Show Last 20 Lines

clang/test/CXX/drs/dr12xx.cpp

// RUN: %clang_cc1 -std=c++98 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors // RUN: %clang_cc1 -std=c++98 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
// RUN: %clang_cc1 -std=c++11 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors // 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++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++17 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
// RUN: %clang_cc1 -std=c++20 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors // RUN: %clang_cc1 -std=c++20 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
// RUN: %clang_cc1 -std=c++2b %s -verify -fexceptions -fcxx-exceptions -pedantic-errors // RUN: %clang_cc1 -std=c++23 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
// dr1200: na // dr1200: na
namespace dr1213 { // dr1213: 7 namespace dr1213 { // dr1213: 7
#if __cplusplus >= 201103L #if __cplusplus >= 201103L
using T = int[3]; using T = int[3];
int &&r = T{}[1]; int &&r = T{}[1];
▲ Show 20 Lines • Show All 87 Lines • Show Last 20 Lines

clang/test/CXX/drs/dr18xx.cpp

// RUN: %clang_cc1 -std=c++98 -triple x86_64-unknown-unknown %s -verify -fexceptions -Wno-deprecated-builtins -fcxx-exceptions -pedantic-errors // RUN: %clang_cc1 -std=c++98 -triple x86_64-unknown-unknown %s -verify -fexceptions -Wno-deprecated-builtins -fcxx-exceptions -pedantic-errors
// RUN: %clang_cc1 -std=c++11 -triple x86_64-unknown-unknown %s -verify -fexceptions -Wno-deprecated-builtins -fcxx-exceptions -pedantic-errors // RUN: %clang_cc1 -std=c++11 -triple x86_64-unknown-unknown %s -verify -fexceptions -Wno-deprecated-builtins -fcxx-exceptions -pedantic-errors
// RUN: %clang_cc1 -std=c++14 -triple x86_64-unknown-unknown %s -verify -fexceptions -Wno-deprecated-builtins -fcxx-exceptions -pedantic-errors // RUN: %clang_cc1 -std=c++14 -triple x86_64-unknown-unknown %s -verify -fexceptions -Wno-deprecated-builtins -fcxx-exceptions -pedantic-errors
// RUN: %clang_cc1 -std=c++17 -triple x86_64-unknown-unknown %s -verify -fexceptions -Wno-deprecated-builtins -fcxx-exceptions -pedantic-errors // RUN: %clang_cc1 -std=c++17 -triple x86_64-unknown-unknown %s -verify -fexceptions -Wno-deprecated-builtins -fcxx-exceptions -pedantic-errors
// RUN: %clang_cc1 -std=c++20 -triple x86_64-unknown-unknown %s -verify -fexceptions -Wno-deprecated-builtins -fcxx-exceptions -pedantic-errors // RUN: %clang_cc1 -std=c++20 -triple x86_64-unknown-unknown %s -verify -fexceptions -Wno-deprecated-builtins -fcxx-exceptions -pedantic-errors
// RUN: %clang_cc1 -std=c++2b -triple x86_64-unknown-unknown %s -verify -fexceptions -Wno-deprecated-builtins -fcxx-exceptions -pedantic-errors // RUN: %clang_cc1 -std=c++23 -triple x86_64-unknown-unknown %s -verify -fexceptions -Wno-deprecated-builtins -fcxx-exceptions -pedantic-errors
#if __cplusplus < 201103L #if __cplusplus < 201103L
// expected-error@+1 {{variadic macro}} // expected-error@+1 {{variadic macro}}
#define static_assert(...) __extension__ _Static_assert(__VA_ARGS__) #define static_assert(...) __extension__ _Static_assert(__VA_ARGS__)
#endif #endif
namespace dr1813 { // dr1813: 7 namespace dr1813 { // dr1813: 7
struct B { int i; }; struct B { int i; };
▲ Show 20 Lines • Show All 200 Lines • Show Last 20 Lines

clang/test/CXX/drs/dr1xx.cpp

// RUN: %clang_cc1 -std=c++98 -triple x86_64-unknown-unknown %s -verify -fexceptions -fcxx-exceptions -pedantic-errors // RUN: %clang_cc1 -std=c++98 -triple x86_64-unknown-unknown %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
// RUN: %clang_cc1 -std=c++11 -triple x86_64-unknown-unknown %s -verify -fexceptions -fcxx-exceptions -pedantic-errors // RUN: %clang_cc1 -std=c++11 -triple x86_64-unknown-unknown %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
// RUN: %clang_cc1 -std=c++14 -triple x86_64-unknown-unknown %s -verify -fexceptions -fcxx-exceptions -pedantic-errors // RUN: %clang_cc1 -std=c++14 -triple x86_64-unknown-unknown %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
// RUN: %clang_cc1 -std=c++17 -triple x86_64-unknown-unknown %s -verify -fexceptions -fcxx-exceptions -pedantic-errors // RUN: %clang_cc1 -std=c++17 -triple x86_64-unknown-unknown %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
// RUN: %clang_cc1 -std=c++20 -triple x86_64-unknown-unknown %s -verify -fexceptions -fcxx-exceptions -pedantic-errors // RUN: %clang_cc1 -std=c++20 -triple x86_64-unknown-unknown %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
// RUN: %clang_cc1 -std=c++2b -triple x86_64-unknown-unknown %s -verify -fexceptions -fcxx-exceptions -pedantic-errors // RUN: %clang_cc1 -std=c++23 -triple x86_64-unknown-unknown %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
namespace dr100 { // dr100: yes namespace dr100 { // dr100: yes
template<const char (*)[4]> struct A {}; // expected-note 0-1{{declared here}} template<const char (*)[4]> struct A {}; // expected-note 0-1{{declared here}}
template<const char (&)[4]> struct B {}; // expected-note 0-1{{declared here}} template<const char (&)[4]> struct B {}; // expected-note 0-1{{declared here}}
template<const char *> struct C {}; // expected-note 0-1{{declared here}} template<const char *> struct C {}; // expected-note 0-1{{declared here}}
template<const char &> struct D {}; // expected-note 0-1{{declared here}} template<const char &> struct D {}; // expected-note 0-1{{declared here}}
A<&"foo"> a; // #100a A<&"foo"> a; // #100a
B<"bar"> b; // #100b B<"bar"> b; // #100b
▲ Show 20 Lines • Show All 1,093 Lines • Show Last 20 Lines

clang/test/CXX/drs/dr20xx.cpp

// RUN: %clang_cc1 -std=c++98 -triple x86_64-unknown-unknown %s -verify -fexceptions -fcxx-exceptions -pedantic-errors \ // RUN: %clang_cc1 -std=c++98 -triple x86_64-unknown-unknown %s -verify -fexceptions -fcxx-exceptions -pedantic-errors \
// RUN: -Wno-variadic-macros -Wno-c11-extensions // RUN: -Wno-variadic-macros -Wno-c11-extensions
// RUN: %clang_cc1 -std=c++11 -triple x86_64-unknown-unknown %s -verify -fexceptions -fcxx-exceptions -pedantic-errors // RUN: %clang_cc1 -std=c++11 -triple x86_64-unknown-unknown %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
// RUN: %clang_cc1 -std=c++14 -triple x86_64-unknown-unknown %s -verify -fexceptions -fcxx-exceptions -pedantic-errors // RUN: %clang_cc1 -std=c++14 -triple x86_64-unknown-unknown %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
// RUN: %clang_cc1 -std=c++17 -triple x86_64-unknown-unknown %s -verify -fexceptions -fcxx-exceptions -pedantic-errors // RUN: %clang_cc1 -std=c++17 -triple x86_64-unknown-unknown %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
// RUN: %clang_cc1 -std=c++20 -triple x86_64-unknown-unknown %s -verify -fexceptions -fcxx-exceptions -pedantic-errors // RUN: %clang_cc1 -std=c++20 -triple x86_64-unknown-unknown %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
// RUN: %clang_cc1 -std=c++2b -triple x86_64-unknown-unknown %s -verify -fexceptions -fcxx-exceptions -pedantic-errors // RUN: %clang_cc1 -std=c++23 -triple x86_64-unknown-unknown %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
#if __cplusplus < 201103L #if __cplusplus < 201103L
#define static_assert(...) _Static_assert(__VA_ARGS__) #define static_assert(...) _Static_assert(__VA_ARGS__)
#endif #endif
namespace dr2007 { // dr2007: 3.4 namespace dr2007 { // dr2007: 3.4
template<typename T> struct A { typename T::error e; }; template<typename T> struct A { typename T::error e; };
template<typename T> struct B { }; template<typename T> struct B { };
▲ Show 20 Lines • Show All 337 Lines • Show Last 20 Lines

clang/test/CXX/drs/dr21xx.cpp

// RUN: %clang_cc1 -std=c++98 -triple x86_64-unknown-unknown %s -verify -fexceptions -Wno-deprecated-builtins -fcxx-exceptions -pedantic-errors // RUN: %clang_cc1 -std=c++98 -triple x86_64-unknown-unknown %s -verify -fexceptions -Wno-deprecated-builtins -fcxx-exceptions -pedantic-errors
// RUN: %clang_cc1 -std=c++11 -triple x86_64-unknown-unknown %s -verify -fexceptions -Wno-deprecated-builtins -fcxx-exceptions -pedantic-errors // RUN: %clang_cc1 -std=c++11 -triple x86_64-unknown-unknown %s -verify -fexceptions -Wno-deprecated-builtins -fcxx-exceptions -pedantic-errors
// RUN: %clang_cc1 -std=c++14 -triple x86_64-unknown-unknown %s -verify -fexceptions -Wno-deprecated-builtins -fcxx-exceptions -pedantic-errors // RUN: %clang_cc1 -std=c++14 -triple x86_64-unknown-unknown %s -verify -fexceptions -Wno-deprecated-builtins -fcxx-exceptions -pedantic-errors
// RUN: %clang_cc1 -std=c++17 -triple x86_64-unknown-unknown %s -verify -fexceptions -Wno-deprecated-builtins -fcxx-exceptions -pedantic-errors // RUN: %clang_cc1 -std=c++17 -triple x86_64-unknown-unknown %s -verify -fexceptions -Wno-deprecated-builtins -fcxx-exceptions -pedantic-errors
// RUN: %clang_cc1 -std=c++20 -triple x86_64-unknown-unknown %s -verify -fexceptions -Wno-deprecated-builtins -fcxx-exceptions -pedantic-errors // RUN: %clang_cc1 -std=c++20 -triple x86_64-unknown-unknown %s -verify -fexceptions -Wno-deprecated-builtins -fcxx-exceptions -pedantic-errors
// RUN: %clang_cc1 -std=c++2b -triple x86_64-unknown-unknown %s -verify -fexceptions -Wno-deprecated-builtins -fcxx-exceptions -pedantic-errors // RUN: %clang_cc1 -std=c++23 -triple x86_64-unknown-unknown %s -verify -fexceptions -Wno-deprecated-builtins -fcxx-exceptions -pedantic-errors
#if __cplusplus < 201103L #if __cplusplus < 201103L
// expected-error@+1 {{variadic macro}} // expected-error@+1 {{variadic macro}}
#define static_assert(...) __extension__ _Static_assert(__VA_ARGS__) #define static_assert(...) __extension__ _Static_assert(__VA_ARGS__)
#endif #endif
namespace dr2100 { // dr2100: 12 namespace dr2100 { // dr2100: 12
template<const int *P, bool = true> struct X {}; template<const int *P, bool = true> struct X {};
▲ Show 20 Lines • Show All 206 Lines • Show Last 20 Lines

clang/test/CXX/drs/dr23xx.cpp

// RUN: %clang_cc1 -std=c++98 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors 2>&1 // RUN: %clang_cc1 -std=c++98 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors 2>&1
// RUN: %clang_cc1 -std=c++11 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors 2>&1 | FileCheck %s // RUN: %clang_cc1 -std=c++11 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors 2>&1 | FileCheck %s
// RUN: %clang_cc1 -std=c++14 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors 2>&1 | FileCheck %s // RUN: %clang_cc1 -std=c++14 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors 2>&1 | FileCheck %s
// RUN: %clang_cc1 -std=c++17 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors 2>&1 | FileCheck %s // RUN: %clang_cc1 -std=c++17 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors 2>&1 | FileCheck %s
// RUN: %clang_cc1 -std=c++20 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors 2>&1 | FileCheck %s // RUN: %clang_cc1 -std=c++20 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors 2>&1 | FileCheck %s
// RUN: %clang_cc1 -std=c++2b %s -verify -fexceptions -fcxx-exceptions -pedantic-errors 2>&1 | FileCheck %s // RUN: %clang_cc1 -std=c++23 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors 2>&1 | FileCheck %s
#if __cplusplus >= 201103L #if __cplusplus >= 201103L
namespace dr2303 { // dr2303: 12 namespace dr2303 { // dr2303: 12
template <typename... T> template <typename... T>
struct A; struct A;
template <> template <>
struct A<> {}; struct A<> {};
template <typename T, typename... Ts> template <typename T, typename... Ts>
▲ Show 20 Lines • Show All 213 Lines • Show Last 20 Lines

clang/test/CXX/drs/dr2xx.cpp

// RUN: %clang_cc1 -std=c++98 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors // RUN: %clang_cc1 -std=c++98 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
// RUN: %clang_cc1 -std=c++11 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors // 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++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++17 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
// RUN: %clang_cc1 -std=c++20 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors // RUN: %clang_cc1 -std=c++20 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
// RUN: %clang_cc1 -std=c++2b %s -verify -fexceptions -fcxx-exceptions -pedantic-errors // RUN: %clang_cc1 -std=c++23 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
// PR13819 -- __SIZE_TYPE__ is incompatible. // PR13819 -- __SIZE_TYPE__ is incompatible.
typedef __SIZE_TYPE__ size_t; // expected-error 0-1 {{extension}} typedef __SIZE_TYPE__ size_t; // expected-error 0-1 {{extension}}
#if __cplusplus < 201103L #if __cplusplus < 201103L
#define fold(x) (__builtin_constant_p(x) ? (x) : (x)) #define fold(x) (__builtin_constant_p(x) ? (x) : (x))
#else #else
#define fold #define fold
▲ Show 20 Lines • Show All 1,141 Lines • Show Last 20 Lines

clang/test/CXX/drs/dr3xx.cpp

// RUN: %clang_cc1 -std=c++2b -verify=expected,cxx20_2b,cxx2b -triple %itanium_abi_triple %s -fexceptions -fcxx-exceptions -pedantic-errors // RUN: %clang_cc1 -std=c++23 -verify=expected,cxx20_23,cxx23 -triple %itanium_abi_triple %s -fexceptions -fcxx-exceptions -pedantic-errors
// RUN: %clang_cc1 -std=c++20 -verify=expected,cxx98_20,cxx20_2b -triple %itanium_abi_triple %s -fexceptions -fcxx-exceptions -pedantic-errors // RUN: %clang_cc1 -std=c++20 -verify=expected,cxx98_20,cxx20_23 -triple %itanium_abi_triple %s -fexceptions -fcxx-exceptions -pedantic-errors
// RUN: %clang_cc1 -std=c++17 -verify=expected,cxx98_17,cxx98_20 -triple %itanium_abi_triple %s -fexceptions -fcxx-exceptions -pedantic-errors // RUN: %clang_cc1 -std=c++17 -verify=expected,cxx98_17,cxx98_20 -triple %itanium_abi_triple %s -fexceptions -fcxx-exceptions -pedantic-errors
// RUN: %clang_cc1 -std=c++14 -verify=expected,cxx98_17,cxx98_20 -triple %itanium_abi_triple %s -fexceptions -fcxx-exceptions -pedantic-errors // RUN: %clang_cc1 -std=c++14 -verify=expected,cxx98_17,cxx98_20 -triple %itanium_abi_triple %s -fexceptions -fcxx-exceptions -pedantic-errors
// RUN: %clang_cc1 -std=c++11 -verify=expected,cxx98_17,cxx98_20 -triple %itanium_abi_triple %s -fexceptions -fcxx-exceptions -pedantic-errors // RUN: %clang_cc1 -std=c++11 -verify=expected,cxx98_17,cxx98_20 -triple %itanium_abi_triple %s -fexceptions -fcxx-exceptions -pedantic-errors
// RUN: %clang_cc1 -std=c++98 -verify=expected,cxx98_17,cxx98_20 -triple %itanium_abi_triple %s -fexceptions -fcxx-exceptions -pedantic-errors // RUN: %clang_cc1 -std=c++98 -verify=expected,cxx98_17,cxx98_20 -triple %itanium_abi_triple %s -fexceptions -fcxx-exceptions -pedantic-errors
namespace dr300 { // dr300: yes namespace dr300 { // dr300: yes
template<typename R, typename A> void f(R (&)(A)) {} template<typename R, typename A> void f(R (&)(A)) {}
int g(int); int g(int);
void h() { f(g); } void h() { f(g); }
} }
namespace dr301 { // dr301: yes namespace dr301 { // dr301: yes
// see also dr38 // see also dr38
struct S; struct S;
template<typename T> void operator+(T, T); template<typename T> void operator+(T, T);
void operator-(S, S); void operator-(S, S);
void f() { void f() {
bool a = (void(*)(S, S))operator+<S> < // expected-warning {{ordered comparison of function pointers}} bool a = (void(*)(S, S))operator+<S> < // expected-warning {{ordered comparison of function pointers}}
(void(*)(S, S))operator+<S>; (void(*)(S, S))operator+<S>;
bool b = (void(*)(S, S))operator- < // cxx20_2b-note {{to match this '<'}} cxx98_17-warning {{ordered comparison of function pointers}} bool b = (void(*)(S, S))operator- < // cxx20_23-note {{to match this '<'}} cxx98_17-warning {{ordered comparison of function pointers}}
(void(*)(S, S))operator-; // cxx20_2b-error {{expected '>'}} (void(*)(S, S))operator-; // cxx20_23-error {{expected '>'}}
bool c = (void(*)(S, S))operator+ < // expected-note {{to match this '<'}} bool c = (void(*)(S, S))operator+ < // expected-note {{to match this '<'}}
(void(*)(S, S))operator-; // expected-error {{expected '>'}} (void(*)(S, S))operator-; // expected-error {{expected '>'}}
} }
template<typename T> void f() { template<typename T> void f() {
typename T::template operator+<int> a; // expected-error {{typename specifier refers to a non-type template}} expected-error +{{}} typename T::template operator+<int> a; // expected-error {{typename specifier refers to a non-type template}} expected-error +{{}}
// FIXME: This shouldn't say (null). // FIXME: This shouldn't say (null).
class T::template operator+<int> b; // expected-error {{identifier followed by '<' indicates a class template specialization but (null) refers to a function template}} class T::template operator+<int> b; // expected-error {{identifier followed by '<' indicates a class template specialization but (null) refers to a function template}}
▲ Show 20 Lines • Show All 421 Lines • ▼ Show 20 Lines
namespace dr331 { // dr331: yes namespace dr331 { // dr331: yes
struct A { struct A {
A(volatile A&); // expected-note 2{{candidate}} A(volatile A&); // expected-note 2{{candidate}}
} const a, b(a); // expected-error 2{{no matching constructor}} } const a, b(a); // expected-error 2{{no matching constructor}}
} }
namespace dr332 { // dr332: dup 577 namespace dr332 { // dr332: dup 577
void f(volatile void); // expected-error {{'void' as parameter must not have type qualifiers}} void f(volatile void); // expected-error {{'void' as parameter must not have type qualifiers}}
// cxx20_2b-warning@-1 {{volatile-qualified parameter type 'volatile void' is deprecated}} // cxx20_23-warning@-1 {{volatile-qualified parameter type 'volatile void' is deprecated}}
void g(const void); // expected-error {{'void' as parameter must not have type qualifiers}} void g(const void); // expected-error {{'void' as parameter must not have type qualifiers}}
void h(int n, volatile void); // expected-error {{'void' must be the first and only parameter}} void h(int n, volatile void); // expected-error {{'void' must be the first and only parameter}}
// cxx20_2b-warning@-1 {{volatile-qualified parameter type 'volatile void' is deprecated}} // cxx20_23-warning@-1 {{volatile-qualified parameter type 'volatile void' is deprecated}}
} }
namespace dr333 { // dr333: yes namespace dr333 { // dr333: yes
int n = 0; int n = 0;
int f(int(n)); int f(int(n));
int g((int(n))); int g((int(n)));
int h = f(g); int h = f(g);
} }
▲ Show 20 Lines • Show All 168 Lines • ▼ Show 20 Lines
// dr348: na // dr348: na
namespace dr349 { // dr349: no namespace dr349 { // dr349: no
struct A { struct A {
template <class T> operator T ***() { template <class T> operator T ***() {
int ***p = 0; int ***p = 0;
return p; // cxx98_20-error {{cannot initialize return object of type 'const int ***' with an lvalue of type 'int ***'}} return p; // cxx98_20-error {{cannot initialize return object of type 'const int ***' with an lvalue of type 'int ***'}}
// cxx2b-error@-1 {{cannot initialize return object of type 'const int ***' with an rvalue of type 'int ***'}} // cxx23-error@-1 {{cannot initialize return object of type 'const int ***' with an rvalue of type 'int ***'}}
} }
}; };
// FIXME: This is valid. // FIXME: This is valid.
A a; A a;
const int *const *const *p1 = a; // expected-note {{in instantiation of}} const int *const *const *p1 = a; // expected-note {{in instantiation of}}
struct B { struct B {
▲ Show 20 Lines • Show All 297 Lines • ▼ Show 20 Lines#if __cplusplus < 201103L
// expected-error@-3 2{{variable length array}} // expected-error@-3 2{{variable length array}}
#endif #endif
} }
namespace dr368 { // dr368: yes namespace dr368 { // dr368: yes
template<typename T, T> struct S {}; // expected-note {{here}} template<typename T, T> struct S {}; // expected-note {{here}}
template<typename T> int f(S<T, T()> *); // expected-error {{function type}} template<typename T> int f(S<T, T()> *); // expected-error {{function type}}
template<typename T> int g(S<T, (T())> *); // cxx98_17-note {{type 'X'}} template<typename T> int g(S<T, (T())> *); // cxx98_17-note {{type 'X'}}
// cxx20_2b-note@-1 {{candidate function [with T = dr368::X]}} // cxx20_23-note@-1 {{candidate function [with T = dr368::X]}}
template<typename T> int g(S<T, true ? T() : T()> *); // cxx98_17-note {{type 'X'}} template<typename T> int g(S<T, true ? T() : T()> *); // cxx98_17-note {{type 'X'}}
// cxx20_2b-note@-1 {{candidate function [with T = dr368::X]}} // cxx20_23-note@-1 {{candidate function [with T = dr368::X]}}
struct X {}; struct X {};
int n = g<X>(0); // cxx98_17-error {{no matching}} int n = g<X>(0); // cxx98_17-error {{no matching}}
// cxx20_2b-error@-1 {{call to 'g' is ambiguous}} // cxx20_23-error@-1 {{call to 'g' is ambiguous}}
} }
// dr370: na // dr370: na
namespace dr372 { // dr372: no namespace dr372 { // dr372: no
namespace example1 { namespace example1 {
template<typename T> struct X { template<typename T> struct X {
protected: protected:
▲ Show 20 Lines • Show All 460 Lines • Show Last 20 Lines

clang/test/CXX/drs/dr4xx.cpp

// RUN: env ASAN_OPTIONS=detect_stack_use_after_return=0 %clang_cc1 -std=c++98 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors // RUN: env ASAN_OPTIONS=detect_stack_use_after_return=0 %clang_cc1 -std=c++98 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
// RUN: env ASAN_OPTIONS=detect_stack_use_after_return=0 %clang_cc1 -std=c++11 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors // RUN: env ASAN_OPTIONS=detect_stack_use_after_return=0 %clang_cc1 -std=c++11 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
// RUN: env ASAN_OPTIONS=detect_stack_use_after_return=0 %clang_cc1 -std=c++14 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors // RUN: env ASAN_OPTIONS=detect_stack_use_after_return=0 %clang_cc1 -std=c++14 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
// RUN: env ASAN_OPTIONS=detect_stack_use_after_return=0 %clang_cc1 -std=c++17 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors // RUN: env ASAN_OPTIONS=detect_stack_use_after_return=0 %clang_cc1 -std=c++17 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
// RUN: env ASAN_OPTIONS=detect_stack_use_after_return=0 %clang_cc1 -std=c++20 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors // RUN: env ASAN_OPTIONS=detect_stack_use_after_return=0 %clang_cc1 -std=c++20 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
// RUN: env ASAN_OPTIONS=detect_stack_use_after_return=0 %clang_cc1 -std=c++2b %s -verify -fexceptions -fcxx-exceptions -pedantic-errors // RUN: env ASAN_OPTIONS=detect_stack_use_after_return=0 %clang_cc1 -std=c++23 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
// FIXME: __SIZE_TYPE__ expands to 'long long' on some targets. // FIXME: __SIZE_TYPE__ expands to 'long long' on some targets.
__extension__ typedef __SIZE_TYPE__ size_t; __extension__ typedef __SIZE_TYPE__ size_t;
namespace std { struct type_info; } namespace std { struct type_info; }
namespace dr400 { // dr400: yes namespace dr400 { // dr400: yes
struct A { int a; struct a {}; }; // expected-note 2{{conflicting}} expected-note {{ambiguous}} struct A { int a; struct a {}; }; // expected-note 2{{conflicting}} expected-note {{ambiguous}}
▲ Show 20 Lines • Show All 1,307 Lines • Show Last 20 Lines

clang/test/CXX/drs/dr5xx.cpp

// RUN: %clang_cc1 -std=c++98 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors // RUN: %clang_cc1 -std=c++98 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
// RUN: %clang_cc1 -std=c++11 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors // 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++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++17 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
// RUN: %clang_cc1 -std=c++20 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors // RUN: %clang_cc1 -std=c++20 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
// RUN: %clang_cc1 -std=c++2b %s -verify -fexceptions -fcxx-exceptions -pedantic-errors // RUN: %clang_cc1 -std=c++23 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
// FIXME: This is included to avoid a diagnostic with no source location // FIXME: This is included to avoid a diagnostic with no source location
// pointing at the implicit operator new. We can't match such a diagnostic // pointing at the implicit operator new. We can't match such a diagnostic
// with -verify. // with -verify.
__extension__ typedef __SIZE_TYPE__ size_t; __extension__ typedef __SIZE_TYPE__ size_t;
void *operator new(size_t); // expected-error 0-1{{missing exception spec}} expected-note{{candidate}} void *operator new(size_t); // expected-error 0-1{{missing exception spec}} expected-note{{candidate}}
#if __cplusplus > 201402L #if __cplusplus > 201402L
namespace std { namespace std {
▲ Show 20 Lines • Show All 1,026 Lines • Show Last 20 Lines

clang/test/CXX/drs/dr6xx.cpp

// RUN: %clang_cc1 -std=c++98 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors -fno-spell-checking // RUN: %clang_cc1 -std=c++98 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors -fno-spell-checking
// RUN: %clang_cc1 -std=c++11 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors -fno-spell-checking // 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++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++17 %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 // RUN: %clang_cc1 -std=c++20 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors -fno-spell-checking
// RUN: %clang_cc1 -std=c++2b %s -verify -fexceptions -fcxx-exceptions -pedantic-errors -fno-spell-checking // RUN: %clang_cc1 -std=c++23 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors -fno-spell-checking
namespace dr600 { // dr600: yes namespace dr600 { // dr600: yes
struct S { struct S {
void f(int); void f(int);
private: private:
void f(double); // expected-note {{declared private here}} void f(double); // expected-note {{declared private here}}
}; };
▲ Show 20 Lines • Show All 1,195 Lines • Show Last 20 Lines

clang/test/CXX/drs/dr9xx.cpp

// RUN: %clang_cc1 -std=c++98 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors // RUN: %clang_cc1 -std=c++98 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
// RUN: %clang_cc1 -std=c++11 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors // 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++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++17 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
// RUN: %clang_cc1 -std=c++20 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors // RUN: %clang_cc1 -std=c++20 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
// RUN: %clang_cc1 -std=c++2b %s -verify -fexceptions -fcxx-exceptions -pedantic-errors // RUN: %clang_cc1 -std=c++23 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
namespace std { namespace std {
__extension__ typedef __SIZE_TYPE__ size_t; __extension__ typedef __SIZE_TYPE__ size_t;
template<typename T> struct initializer_list { template<typename T> struct initializer_list {
const T *p; size_t n; const T *p; size_t n;
initializer_list(const T *p, size_t n); initializer_list(const T *p, size_t n);
}; };
▲ Show 20 Lines • Show All 106 Lines • Show Last 20 Lines

clang/test/CXX/expr/expr.post/expr.type.conv/p1-2b.cpp

// RUN: %clang_cc1 -std=c++2b -verify %s // RUN: %clang_cc1 -std=c++23 -verify %s
template <class T> template <class T>
void foo(T); void foo(T);
struct A { struct A {
int m; int m;
char g(int); char g(int);
float g(double); float g(double);
} a{1}; } a{1};
// C++2b [dcl.type.auto.deduct]p2.3 // C++23 [dcl.type.auto.deduct]p2.3
// For an explicit type conversion, T is the specified type, which shall be auto. // For an explicit type conversion, T is the specified type, which shall be auto.
void diagnostics() { void diagnostics() {
foo(auto()); // expected-error {{initializer for functional-style cast to 'auto' is empty}} foo(auto()); // expected-error {{initializer for functional-style cast to 'auto' is empty}}
foo(auto{}); // expected-error {{initializer for functional-style cast to 'auto' is empty}} foo(auto{}); // expected-error {{initializer for functional-style cast to 'auto' is empty}}
foo(auto({})); // expected-error {{cannot deduce actual type for 'auto' from parenthesized initializer list}} foo(auto({})); // expected-error {{cannot deduce actual type for 'auto' from parenthesized initializer list}}
foo(auto{{}}); // expected-error {{cannot deduce actual type for 'auto' from nested initializer list}} foo(auto{{}}); // expected-error {{cannot deduce actual type for 'auto' from nested initializer list}}
// - If the initializer is a parenthesized expression-list, the expression-list shall be a single assignmentexpression and E is the assignment-expression. // - If the initializer is a parenthesized expression-list, the expression-list shall be a single assignmentexpression and E is the assignment-expression.
Show All 19 Lines

clang/test/CXX/expr/expr.prim/expr.prim.lambda/p4-cxx14.cpp

// RUN: %clang_cc1 -std=c++2b -fsyntax-only -verify=expected,cxx2b %s // RUN: %clang_cc1 -std=c++23 -fsyntax-only -verify=expected,cxx23 %s
// RUN: %clang_cc1 -std=c++20 -fsyntax-only -verify=expected,cxx14_20 %s // RUN: %clang_cc1 -std=c++20 -fsyntax-only -verify=expected,cxx14_20 %s
// RUN: %clang_cc1 -std=c++14 -fsyntax-only -verify=expected,cxx14_20 %s // RUN: %clang_cc1 -std=c++14 -fsyntax-only -verify=expected,cxx14_20 %s
int a; int a;
int &b = [] (int &r) -> decltype(auto) { return r; } (a); int &b = [] (int &r) -> decltype(auto) { return r; } (a);
int &c = [] (int &r) -> decltype(auto) { return (r); } (a); int &c = [] (int &r) -> decltype(auto) { return (r); } (a);
int &d = [] (int &r) -> auto & { return r; } (a); int &d = [] (int &r) -> auto & { return r; } (a);
int &e = [] (int &r) -> auto { return r; } (a); // expected-error {{cannot bind to a temporary}} int &e = [] (int &r) -> auto { return r; } (a); // expected-error {{cannot bind to a temporary}}
int &f = [] (int r) -> decltype(auto) { return r; } (a); // expected-error {{non-const lvalue reference to type 'int' cannot bind to a temporary of type 'int'}} int &f = [] (int r) -> decltype(auto) { return r; } (a); // expected-error {{non-const lvalue reference to type 'int' cannot bind to a temporary of type 'int'}}
int &g = [] (int r) -> decltype(auto) { return (r); } (a); // expected-warning {{reference to stack}} int &g = [] (int r) -> decltype(auto) { return (r); } (a); // expected-warning {{reference to stack}}
// cxx2b-error@-1 {{non-const lvalue reference to type 'int' cannot bind to a temporary of type 'int'}} // cxx23-error@-1 {{non-const lvalue reference to type 'int' cannot bind to a temporary of type 'int'}}
int test_explicit_auto_return() int test_explicit_auto_return()
{ {
struct X {}; struct X {};
auto L = [](auto F, auto a) { return F(a); }; auto L = [](auto F, auto a) { return F(a); };
auto M = [](auto a) -> auto { return a; }; // OK auto M = [](auto a) -> auto { return a; }; // OK
auto MRef = [](auto b) -> auto & { return b; }; //cxx14_20-warning{{reference to stack}} auto MRef = [](auto b) -> auto & { return b; }; //cxx14_20-warning{{reference to stack}}
// cxx2b-error@-1 {{non-const lvalue reference to type 'X' cannot bind to a temporary of type 'X'}} // cxx23-error@-1 {{non-const lvalue reference to type 'X' cannot bind to a temporary of type 'X'}}
auto MPtr = [](auto c) -> auto* { return &c; }; //expected-warning{{address of stack}} auto MPtr = [](auto c) -> auto* { return &c; }; //expected-warning{{address of stack}}
auto MDeclType = [](auto&& d) -> decltype(auto) { return static_cast<decltype(d)>(d); }; //OK auto MDeclType = [](auto&& d) -> decltype(auto) { return static_cast<decltype(d)>(d); }; //OK
M(3); M(3);
auto &&x = MDeclType(X{}); auto &&x = MDeclType(X{});
auto &&x1 = M(X{}); auto &&x1 = M(X{});
auto &&x2 = MRef(X{});//expected-note{{in instantiation of}} auto &&x2 = MRef(X{});//expected-note{{in instantiation of}}
auto &&x3 = MPtr(X{}); //expected-note{{in instantiation of}} auto &&x3 = MPtr(X{}); //expected-note{{in instantiation of}}
Show All 23 Linesint test_multiple_returns() {
return 0; return 0;
} }
int test_no_parameter_list() int test_no_parameter_list()
{ {
static int si = 0; static int si = 0;
auto M = [] { return 5; }; // OK auto M = [] { return 5; }; // OK
auto M2 = [] -> auto && { return si; }; auto M2 = [] -> auto && { return si; };
#if __cplusplus <= 202002L #if __cplusplus <= 202002L
// expected-warning@-2{{is a C++2b extension}} // expected-warning@-2{{is a C++23 extension}}
#endif #endif
M(); M();
} }
int test_conditional_in_return() { int test_conditional_in_return() {
auto Fac = [](auto f, auto n) { auto Fac = [](auto f, auto n) {
return n <= 0 ? n : f(f, n - 1) * n; return n <= 0 ? n : f(f, n - 1) * n;
}; };
// FIXME: this test causes a recursive limit - need to error more gracefully. // FIXME: this test causes a recursive limit - need to error more gracefully.
//Fac(Fac, 3); //Fac(Fac, 3);
} }

clang/test/CXX/expr/expr.unary/expr.new/p2-cxx1z.cpp

// RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++14 // RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++14
// RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++17 -pedantic // RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++17 -pedantic
// [expr.new]p2 ... the invented declaration: T x init ; // [expr.new]p2 ... the invented declaration: T x init ;
// C++2b [dcl.type.auto.deduct]p2.2 // C++23 [dcl.type.auto.deduct]p2.2
// For a variable declared with a type that contains a placeholder type, T is the declared type of the variable. // For a variable declared with a type that contains a placeholder type, T is the declared type of the variable.
void f() { void f() {
// - If the initializer is a parenthesized expression-list, the expression-list shall be a single assignmentexpression and E is the assignment-expression. // - If the initializer is a parenthesized expression-list, the expression-list shall be a single assignmentexpression and E is the assignment-expression.
new auto('a'); new auto('a');
new decltype(auto)('a'); new decltype(auto)('a');
// - If the initializer is a braced-init-list, it shall consist of a single brace-enclosed assignment-expression and E is the assignment-expression. // - If the initializer is a braced-init-list, it shall consist of a single brace-enclosed assignment-expression and E is the assignment-expression.
new auto{2}; new auto{2};
new decltype(auto){2}; new decltype(auto){2};
Show All 17 Lines

clang/test/CXX/over/over.match/over.match.best/over.best.ics/p6.cpp

// RUN: %clang_cc1 -fsyntax-only -verify=cxx2b -std=c++2b %s // RUN: %clang_cc1 -fsyntax-only -verify=cxx23 -std=c++23 %s
// RUN: %clang_cc1 -fsyntax-only -verify=cxx20 -std=c++20 %s // RUN: %clang_cc1 -fsyntax-only -verify=cxx20 -std=c++20 %s
// cxx2b-no-diagnostics // cxx23-no-diagnostics
struct __unique { struct __unique {
static constexpr auto operator()() { return 4; }; // cxx20-warning {{is a C++2b extension}} static constexpr auto operator()() { return 4; }; // cxx20-warning {{is a C++23 extension}}
using P = int(); using P = int();
constexpr operator P*() { return operator(); } constexpr operator P*() { return operator(); }
}; };
__unique four{}; __unique four{};
int test_four() { int test_four() {
// Checks that overload resolution works. // Checks that overload resolution works.
return four(); return four();
} }

clang/test/CXX/over/over.oper/p7.cpp

// RUN: %clang_cc1 -std=c++11 %s -verify=expected,cxx11 // RUN: %clang_cc1 -std=c++11 %s -verify=expected,cxx11
// RUN: %clang_cc1 -std=c++2b %s -verify=expected,cxx2b // RUN: %clang_cc1 -std=c++23 %s -verify=expected,cxx23
// RUN: %clang_cc1 -std=c++2b -Wpre-c++2b-compat %s -verify=expected,precxx2b // RUN: %clang_cc1 -std=c++23 -Wpre-c++23-compat %s -verify=expected,precxx23
struct Functor { struct Functor {
static int operator()(int a, int b); static int operator()(int a, int b);
static int operator[](int a1); static int operator[](int a1);
// cxx11-warning@-2 {{declaring overloaded 'operator()' as 'static' is a C++2b extension}} // cxx11-warning@-2 {{declaring overloaded 'operator()' as 'static' is a C++23 extension}}
// cxx11-warning@-2 {{declaring overloaded 'operator[]' as 'static' is a C++2b extension}} // cxx11-warning@-2 {{declaring overloaded 'operator[]' as 'static' is a C++23 extension}}
// precxx2b-warning@-4 {{incompatible with C++ standards before C++2b}} // precxx23-warning@-4 {{incompatible with C++ standards before C++23}}
// precxx2b-warning@-4 {{incompatible with C++ standards before C++2b}} // precxx23-warning@-4 {{incompatible with C++ standards before C++23}}
}; };
struct InvalidParsing1 { struct InvalidParsing1 {
extern int operator()(int a, int b); // expected-error {{storage class specified}} extern int operator()(int a, int b); // expected-error {{storage class specified}}
extern int operator[](int a1); // expected-error {{storage class specified}} extern int operator[](int a1); // expected-error {{storage class specified}}
}; };
struct InvalidParsing2 { struct InvalidParsing2 {
extern static int operator()(int a, int b); // expected-error {{storage class specified}} // expected-error {{cannot combine with previous 'extern' declaration specifier}} extern static int operator()(int a, int b); // expected-error {{storage class specified}} // expected-error {{cannot combine with previous 'extern' declaration specifier}}
extern static int operator[](int a); // expected-error {{storage class specified}} // expected-error {{cannot combine with previous 'extern' declaration specifier}} extern static int operator[](int a); // expected-error {{storage class specified}} // expected-error {{cannot combine with previous 'extern' declaration specifier}}
}; };

clang/test/CXX/special/class.copy/p3-cxx11.cpp

// RUN: %clang_cc1 -fcxx-exceptions -fexceptions -std=c++2b -fsyntax-only -verify %s // RUN: %clang_cc1 -fcxx-exceptions -fexceptions -std=c++23 -fsyntax-only -verify %s
// RUN: %clang_cc1 -fcxx-exceptions -fexceptions -std=c++20 -fsyntax-only -verify %s // RUN: %clang_cc1 -fcxx-exceptions -fexceptions -std=c++20 -fsyntax-only -verify %s
// RUN: %clang_cc1 -fcxx-exceptions -fexceptions -std=c++11 -fsyntax-only -verify %s // RUN: %clang_cc1 -fcxx-exceptions -fexceptions -std=c++11 -fsyntax-only -verify %s
class X { class X {
X(const X&); X(const X&);
public: public:
X(); X();
X(X&&); X(X&&);
▲ Show 20 Lines • Show All 50 Lines • Show Last 20 Lines

clang/test/CXX/stmt.stmt/stmt.select/stmt.if/p4.cpp

// RUN: %clang_cc1 -std=c++2b -verify %s // RUN: %clang_cc1 -std=c++23 -verify %s
void test_consteval() { void test_consteval() {
if consteval ({(void)1;}); // expected-error {{expected { after consteval}} if consteval ({(void)1;}); // expected-error {{expected { after consteval}}
if consteval (void) 0; // expected-error {{expected { after consteval}} if consteval (void) 0; // expected-error {{expected { after consteval}}
if consteval { if consteval {
(void)0; (void)0;
} else (void)0; // expected-error {{expected { after else}} } else (void)0; // expected-error {{expected { after else}}
▲ Show 20 Lines • Show All 149 Lines • Show Last 20 Lines

clang/test/CXX/temp/temp.decls/temp.mem/p5.cpp

// RUN: %clang_cc1 -std=c++2b -fsyntax-only -verify=expected,cxx2b %s // RUN: %clang_cc1 -std=c++23 -fsyntax-only -verify=expected,cxx23 %s
// RUN: %clang_cc1 -std=c++20 -fsyntax-only -verify=expected,cxx98_20 %s // RUN: %clang_cc1 -std=c++20 -fsyntax-only -verify=expected,cxx98_20 %s
// RUN: %clang_cc1 -std=c++98 -fsyntax-only -verify=expected,cxx98_20 %s // RUN: %clang_cc1 -std=c++98 -fsyntax-only -verify=expected,cxx98_20 %s
// RUN: %clang_cc1 -fsyntax-only -verify=expected,cxx98_20 %s // RUN: %clang_cc1 -fsyntax-only -verify=expected,cxx98_20 %s
struct A { struct A {
template <class T> operator T*(); template <class T> operator T*();
}; };
▲ Show 20 Lines • Show All 54 Lines • ▼ Show 20 Linesstruct X0 {
} }
template<typename T> operator T*() const; // expected-note{{explicit instantiation refers here}} template<typename T> operator T*() const; // expected-note{{explicit instantiation refers here}}
template<typename T> operator const T*() const { template<typename T> operator const T*() const {
T x = T(); T x = T();
return x; // cxx98_20-error{{cannot initialize return object of type 'const char *' with an lvalue of type 'char'}} \ return x; // cxx98_20-error{{cannot initialize return object of type 'const char *' with an lvalue of type 'char'}} \
// cxx98_20-error{{cannot initialize return object of type 'const int *' with an lvalue of type 'int'}} \ // cxx98_20-error{{cannot initialize return object of type 'const int *' with an lvalue of type 'int'}} \
// cxx2b-error{{cannot initialize return object of type 'const char *' with an rvalue of type 'char'}} \ // cxx23-error{{cannot initialize return object of type 'const char *' with an rvalue of type 'char'}} \
// cxx2b-error{{cannot initialize return object of type 'const int *' with an rvalue of type 'int'}} // cxx23-error{{cannot initialize return object of type 'const int *' with an rvalue of type 'int'}}
} }
}; };
template X0::operator const char*() const; // expected-note{{'X0::operator const char *<char>' requested here}} template X0::operator const char*() const; // expected-note{{'X0::operator const char *<char>' requested here}}
template X0::operator const int*(); // expected-note{{'X0::operator const int *<const int>' requested here}} template X0::operator const int*(); // expected-note{{'X0::operator const int *<const int>' requested here}}
template X0::operator float*() const; // expected-error{{explicit instantiation of undefined function template 'operator type-parameter-0-0 *'}} template X0::operator float*() const; // expected-error{{explicit instantiation of undefined function template 'operator type-parameter-0-0 *'}}
void test_X0(X0 x0, const X0 &x0c) { void test_X0(X0 x0, const X0 &x0c) {
Show All 17 Lines

clang/test/CXX/temp/temp.decls/temp.variadic/p5.cpp

// RUN: %clang_cc1 -fcxx-exceptions -fexceptions -std=c++11 -fblocks -fms-extensions -fsyntax-only -verify=expected,cxx11 %s // RUN: %clang_cc1 -fcxx-exceptions -fexceptions -std=c++11 -fblocks -fms-extensions -fsyntax-only -verify=expected,cxx11 %s
// RUN: %clang_cc1 -fcxx-exceptions -fexceptions -std=c++2b -fblocks -fms-extensions -fsyntax-only -verify=expected %s // RUN: %clang_cc1 -fcxx-exceptions -fexceptions -std=c++23 -fblocks -fms-extensions -fsyntax-only -verify=expected %s
template<typename T, typename U> struct pair; template<typename T, typename U> struct pair;
template<typename ...> struct tuple; template<typename ...> struct tuple;
// A parameter pack whose name appears within the pattern of a pack // A parameter pack whose name appears within the pattern of a pack
// expansion is expanded by that pack expansion. An appearance of the // expansion is expanded by that pack expansion. An appearance of the
// name of a parameter pack is only expanded by the innermost // name of a parameter pack is only expanded by the innermost
// enclosing pack expansion. The pattern of a pack expansion shall // enclosing pack expansion. The pattern of a pack expansion shall
▲ Show 20 Lines • Show All 507 Lines • Show Last 20 Lines

clang/test/CodeGenCXX/cxx2b-consteval-if.cpp

// RUN: %clang_cc1 -std=c++2b %s -emit-llvm -o - | FileCheck %s // RUN: %clang_cc1 -std=c++23 %s -emit-llvm -o - | FileCheck %s
void should_be_used_1(); void should_be_used_1();
void should_be_used_2(); void should_be_used_2();
void should_be_used_3(); void should_be_used_3();
constexpr void should_not_be_used() {} constexpr void should_not_be_used() {}
constexpr void f() { constexpr void f() {
if consteval { if consteval {
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

clang/test/CodeGenCXX/cxx2b-static-call-operator.cpp

// RUN: %clang_cc1 -std=c++2b %s -emit-llvm -triple x86_64-linux -o - | FileCheck %s // RUN: %clang_cc1 -std=c++23 %s -emit-llvm -triple x86_64-linux -o - | FileCheck %s
// RUN: %clang_cc1 -std=c++2b %s -emit-llvm -triple x86_64-windows-msvc -o - | FileCheck %s // RUN: %clang_cc1 -std=c++23 %s -emit-llvm -triple x86_64-windows-msvc -o - | FileCheck %s
struct Functor { struct Functor {
static int operator()(int x, int y) { static int operator()(int x, int y) {
return x + y; return x + y;
} }
}; };
auto GetALambda() { auto GetALambda() {
▲ Show 20 Lines • Show All 121 Lines • Show Last 20 Lines

clang/test/CodeGenCXX/cxx2b-static-subscript-operator.cpp

// RUN: %clang_cc1 -std=c++2b %s -emit-llvm -triple x86_64-linux -o - | FileCheck %s // RUN: %clang_cc1 -std=c++23 %s -emit-llvm -triple x86_64-linux -o - | FileCheck %s
// RUN: %clang_cc1 -std=c++2b %s -emit-llvm -triple x86_64-windows-msvc -o - | FileCheck %s // RUN: %clang_cc1 -std=c++23 %s -emit-llvm -triple x86_64-windows-msvc -o - | FileCheck %s
struct Functor { struct Functor {
static int operator[](int x, int y) { static int operator[](int x, int y) {
return x + y; return x + y;
} }
}; };
void call_static_subscript_operator() { void call_static_subscript_operator() {
▲ Show 20 Lines • Show All 56 Lines • Show Last 20 Lines

clang/test/CoverageMapping/if.cpp

// RUN: %clang_cc1 -fms-extensions -mllvm -emptyline-comment-coverage=false -fprofile-instrument=clang -fcoverage-mapping -dump-coverage-mapping -emit-llvm-only -std=c++2b -triple %itanium_abi_triple -main-file-name if.cpp %s | FileCheck %s // RUN: %clang_cc1 -fms-extensions -mllvm -emptyline-comment-coverage=false -fprofile-instrument=clang -fcoverage-mapping -dump-coverage-mapping -emit-llvm-only -std=c++23 -triple %itanium_abi_triple -main-file-name if.cpp %s | FileCheck %s
int nop() { return 0; } int nop() { return 0; }
struct S { struct S {
int i; int i;
int putprop(int j) { int putprop(int j) {
i = j; i = j;
return i; return i;
} }
▲ Show 20 Lines • Show All 90 Lines • Show Last 20 Lines

clang/test/CoverageMapping/strong_order.cpp

// RUN: %clang_cc1 -mllvm -emptyline-comment-coverage=false -fprofile-instrument=clang -fcoverage-mapping -dump-coverage-mapping -emit-llvm-only -std=c++2b -triple %itanium_abi_triple -main-file-name if.cpp %s // RUN: %clang_cc1 -mllvm -emptyline-comment-coverage=false -fprofile-instrument=clang -fcoverage-mapping -dump-coverage-mapping -emit-llvm-only -std=c++23 -triple %itanium_abi_triple -main-file-name if.cpp %s
// No crash for following example. // No crash for following example.
// See https://github.com/llvm/llvm-project/issues/45481 // See https://github.com/llvm/llvm-project/issues/45481
namespace std { namespace std {
class strong_ordering; class strong_ordering;
// Mock how STD defined unspecified parameters for the operators below. // Mock how STD defined unspecified parameters for the operators below.
struct _CmpUnspecifiedParam { struct _CmpUnspecifiedParam {
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

clang/test/Driver/cl-options.c

Show First 20 Lines • Show All 598 Lines • ▼ Show 20 Lines
// RUN: %clang_cl -fmsc-version=1900 -TP -std:c++17 -### -- %s 2>&1 | FileCheck -check-prefix=STDCXX17 %s // RUN: %clang_cl -fmsc-version=1900 -TP -std:c++17 -### -- %s 2>&1 | FileCheck -check-prefix=STDCXX17 %s
// STDCXX17: -std=c++17 // STDCXX17: -std=c++17
// RUN: %clang_cl -fmsc-version=1900 -TP -std:c++20 -### -- %s 2>&1 | FileCheck -check-prefix=STDCXX20 %s // RUN: %clang_cl -fmsc-version=1900 -TP -std:c++20 -### -- %s 2>&1 | FileCheck -check-prefix=STDCXX20 %s
// STDCXX20: -std=c++20 // STDCXX20: -std=c++20
// RUN: %clang_cl -fmsc-version=1900 -TP -std:c++latest -### -- %s 2>&1 | FileCheck -check-prefix=STDCXXLATEST %s // RUN: %clang_cl -fmsc-version=1900 -TP -std:c++latest -### -- %s 2>&1 | FileCheck -check-prefix=STDCXXLATEST %s
// STDCXXLATEST: -std=c++2b // STDCXXLATEST: -std=c++23
// RUN: env CL="/Gy" %clang_cl -### -- %s 2>&1 | FileCheck -check-prefix=ENV-CL %s // RUN: env CL="/Gy" %clang_cl -### -- %s 2>&1 | FileCheck -check-prefix=ENV-CL %s
// ENV-CL: "-ffunction-sections" // ENV-CL: "-ffunction-sections"
// RUN: env CL="/Gy" _CL_="/Gy- -- %s" %clang_cl -### 2>&1 | FileCheck -check-prefix=ENV-_CL_ %s // RUN: env CL="/Gy" _CL_="/Gy- -- %s" %clang_cl -### 2>&1 | FileCheck -check-prefix=ENV-_CL_ %s
// ENV-_CL_-NOT: "-ffunction-sections" // ENV-_CL_-NOT: "-ffunction-sections"
// RUN: env CL="%s" _CL_="%s" not %clang --rsp-quoting=windows -c // RUN: env CL="%s" _CL_="%s" not %clang --rsp-quoting=windows -c
▲ Show 20 Lines • Show All 179 Lines • Show Last 20 Lines

clang/test/Driver/modules-fprebuilt-mdoule-path.cpp

// RUN: %clang -std=c++2a -fprebuilt-module-path=. -### -c %s 2>&1 | FileCheck %s // RUN: %clang -std=c++2a -fprebuilt-module-path=. -### -c %s 2>&1 | FileCheck %s
// RUN: %clang -std=c++20 -fprebuilt-module-path=. -### -c %s 2>&1 | FileCheck %s // RUN: %clang -std=c++20 -fprebuilt-module-path=. -### -c %s 2>&1 | FileCheck %s
// RUN: %clang -std=c++2b -fprebuilt-module-path=. -### -c %s 2>&1 | FileCheck %s // RUN: %clang -std=c++23 -fprebuilt-module-path=. -### -c %s 2>&1 | FileCheck %s
// RUN: %clang -std=c++latest -fprebuilt-module-path=. -### -c %s 2>&1 | FileCheck %s // RUN: %clang -std=c++latest -fprebuilt-module-path=. -### -c %s 2>&1 | FileCheck %s
// //
// CHECK-NOT: warning: argument unused during compilation // CHECK-NOT: warning: argument unused during compilation
// CHECK: -fprebuilt-module-path=. // CHECK: -fprebuilt-module-path=.

clang/test/Driver/std.cpp

// RUN: not %clang -std=c++98 %s -Wno-c++0x-compat -fsyntax-only 2>&1 | FileCheck -check-prefix=CXX98 %s // RUN: not %clang -std=c++98 %s -Wno-c++0x-compat -fsyntax-only 2>&1 | FileCheck -check-prefix=CXX98 %s
// RUN: not %clang -std=gnu++98 %s -Wno-c++0x-compat -fsyntax-only 2>&1 | FileCheck -check-prefix=GNUXX98 %s // RUN: not %clang -std=gnu++98 %s -Wno-c++0x-compat -fsyntax-only 2>&1 | FileCheck -check-prefix=GNUXX98 %s
// RUN: not %clang -std=c++03 %s -Wno-c++0x-compat -fsyntax-only 2>&1 | FileCheck -check-prefix=CXX98 %s // RUN: not %clang -std=c++03 %s -Wno-c++0x-compat -fsyntax-only 2>&1 | FileCheck -check-prefix=CXX98 %s
// RUN: not %clang -std=c++0x %s -fsyntax-only 2>&1 | FileCheck -check-prefix=CXX11 %s // RUN: not %clang -std=c++0x %s -fsyntax-only 2>&1 | FileCheck -check-prefix=CXX11 %s
// RUN: not %clang -std=gnu++0x %s -fsyntax-only 2>&1 | FileCheck -check-prefix=GNUXX11 %s // RUN: not %clang -std=gnu++0x %s -fsyntax-only 2>&1 | FileCheck -check-prefix=GNUXX11 %s
// RUN: not %clang -std=c++11 %s -fsyntax-only 2>&1 | FileCheck -check-prefix=CXX11 %s // RUN: not %clang -std=c++11 %s -fsyntax-only 2>&1 | FileCheck -check-prefix=CXX11 %s
// RUN: not %clang -std=gnu++11 %s -fsyntax-only 2>&1 | FileCheck -check-prefix=GNUXX11 %s // RUN: not %clang -std=gnu++11 %s -fsyntax-only 2>&1 | FileCheck -check-prefix=GNUXX11 %s
// RUN: not %clang -std=c++1y %s -fsyntax-only 2>&1 | FileCheck -check-prefix=CXX1Y %s // RUN: not %clang -std=c++1y %s -fsyntax-only 2>&1 | FileCheck -check-prefix=CXX1Y %s
// RUN: not %clang -std=gnu++1y %s -fsyntax-only 2>&1 | FileCheck -check-prefix=GNUXX1Y %s // RUN: not %clang -std=gnu++1y %s -fsyntax-only 2>&1 | FileCheck -check-prefix=GNUXX1Y %s
// RUN: not %clang -std=c++1z %s -fsyntax-only 2>&1 | FileCheck -check-prefix=CXX1Z %s // RUN: not %clang -std=c++1z %s -fsyntax-only 2>&1 | FileCheck -check-prefix=CXX1Z %s
// RUN: not %clang -std=gnu++1z %s -fsyntax-only 2>&1 | FileCheck -check-prefix=GNUXX1Z %s // RUN: not %clang -std=gnu++1z %s -fsyntax-only 2>&1 | FileCheck -check-prefix=GNUXX1Z %s
// RUN: not %clang -std=c++2a %s -fsyntax-only 2>&1 | FileCheck -check-prefix=CXX2A %s // RUN: not %clang -std=c++2a %s -fsyntax-only 2>&1 | FileCheck -check-prefix=CXX2A %s
// RUN: not %clang -std=gnu++2a %s -fsyntax-only 2>&1 | FileCheck -check-prefix=GNUXX2A %s // RUN: not %clang -std=gnu++2a %s -fsyntax-only 2>&1 | FileCheck -check-prefix=GNUXX2A %s
// RUN: not %clang -std=c++2b %s -fsyntax-only 2>&1 | FileCheck -check-prefix=CXX2B %s // RUN: not %clang -std=c++23 %s -fsyntax-only 2>&1 | FileCheck -check-prefix=CXX2B %s
// RUN: not %clang -std=gnu++2b %s -fsyntax-only 2>&1 | FileCheck -check-prefix=GNUXX2B %s // RUN: not %clang -std=gnu++23 %s -fsyntax-only 2>&1 | FileCheck -check-prefix=GNUXX2B %s
void f(int n) { void f(int n) {
typeof(n)(); typeof(n)();
decltype(n)(); decltype(n)();
} }
// CXX98: undeclared identifier 'typeof' // CXX98: undeclared identifier 'typeof'
// CXX98: undeclared identifier 'decltype' // CXX98: undeclared identifier 'decltype'
Show All 33 Lines

clang/test/Driver/unknown-std.cpp

Show All 11 Lines
// CHECK-NEXT: note: use 'c++11' for 'ISO C++ 2011 with amendments' standard // CHECK-NEXT: note: use 'c++11' for 'ISO C++ 2011 with amendments' standard
// CHECK-NEXT: note: use 'gnu++11' for 'ISO C++ 2011 with amendments and GNU extensions' standard // CHECK-NEXT: note: use 'gnu++11' for 'ISO C++ 2011 with amendments and GNU extensions' standard
// CHECK-NEXT: note: use 'c++14' for 'ISO C++ 2014 with amendments' standard // CHECK-NEXT: note: use 'c++14' for 'ISO C++ 2014 with amendments' standard
// CHECK-NEXT: note: use 'gnu++14' for 'ISO C++ 2014 with amendments and GNU extensions' standard // 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 '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 'gnu++17' for 'ISO C++ 2017 with amendments and GNU extensions' standard
// CHECK-NEXT: note: use 'c++20' for 'ISO C++ 2020 DIS' 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 // CHECK-NEXT: note: use 'gnu++20' for 'ISO C++ 2020 DIS with GNU extensions' standard
// CHECK-NEXT: note: use 'c++2b' for 'Working draft for ISO C++ 2023 DIS' standard // CHECK-NEXT: note: use 'c++23' for 'ISO C++ 2023 DIS' standard
// CHECK-NEXT: note: use 'gnu++2b' for 'Working draft for ISO C++ 2023 DIS with GNU extensions' standard // CHECK-NEXT: note: use 'gnu++23' for 'ISO C++ 2023 DIS with GNU extensions' standard
// CUDA-NEXT: note: use 'cuda' for 'NVIDIA CUDA(tm)' standard // CUDA-NEXT: note: use 'cuda' for 'NVIDIA CUDA(tm)' standard
// Make sure that no other output is present. // Make sure that no other output is present.
// CHECK-NOT: {{^.+$}} // CHECK-NOT: {{^.+$}}

clang/test/FixIt/fixit-c++11.cpp

Show First 20 Lines • Show All 53 Lines • ▼ Show 20 Lines
void S2::f(int i) { void S2::f(int i) {
(void)[&, &i, &i]{}; // expected-error 2{{'&' cannot precede a capture when the capture default is '&'}} (void)[&, &i, &i]{}; // expected-error 2{{'&' cannot precede a capture when the capture default is '&'}}
(void)[i, i]{ }; // expected-error{{'i' can appear only once in a capture list}} (void)[i, i]{ }; // expected-error{{'i' can appear only once in a capture list}}
(void)[&, i, i]{ }; // expected-error{{'i' can appear only once in a capture list}} (void)[&, i, i]{ }; // expected-error{{'i' can appear only once in a capture list}}
(void)[] mutable {}; (void)[] mutable {};
(void)[]->int{}; (void)[]->int{};
#if __cplusplus <= 202002L #if __cplusplus <= 202002L
// expected-warning@-3{{is a C++2b extension}} // expected-warning@-3{{is a C++23 extension}}
// expected-warning@-3{{is a C++2b extension}} // expected-warning@-3{{is a C++23 extension}}
#endif #endif
delete []() { return new int; }(); // expected-error{{'[]' after delete interpreted as 'delete[]'}} delete []() { return new int; }(); // expected-error{{'[]' after delete interpreted as 'delete[]'}}
delete [] { return new int; }(); // expected-error{{'[]' after delete interpreted as 'delete[]'}} delete [] { return new int; }(); // expected-error{{'[]' after delete interpreted as 'delete[]'}}
} }
#define bar "bar" #define bar "bar"
const char *p = "foo"bar; // expected-error {{requires a space between}} const char *p = "foo"bar; // expected-error {{requires a space between}}
▲ Show 20 Lines • Show All 114 Lines • Show Last 20 Lines

clang/test/Lexer/char-escapes-delimited.c

// RUN: %clang_cc1 -x c++ -std=gnu++11 -fsyntax-only -pedantic -verify=ext,expected %s // RUN: %clang_cc1 -x c++ -std=gnu++11 -fsyntax-only -pedantic -verify=ext,expected %s
// RUN: %clang_cc1 -x c -std=gnu11 -fsyntax-only -pedantic -verify=ext,expected %s // RUN: %clang_cc1 -x c -std=gnu11 -fsyntax-only -pedantic -verify=ext,expected %s
// RUN: %clang_cc1 -x c++ -std=c++2b -fsyntax-only -pedantic -verify=cxx2b,expected -Wpre-c++2b-compat %s // RUN: %clang_cc1 -x c++ -std=c++23 -fsyntax-only -pedantic -verify=cxx23,expected -Wpre-c++23-compat %s
// RUN: %clang_cc1 -x c++ -std=gnu++11 -fwchar-type=short -fno-signed-wchar -fsyntax-only -pedantic -verify=ext,expected %s // RUN: %clang_cc1 -x c++ -std=gnu++11 -fwchar-type=short -fno-signed-wchar -fsyntax-only -pedantic -verify=ext,expected %s
// RUN: %clang_cc1 -x c -std=gnu11 -fwchar-type=short -fno-signed-wchar -fsyntax-only -pedantic -verify=ext,expected %s // RUN: %clang_cc1 -x c -std=gnu11 -fwchar-type=short -fno-signed-wchar -fsyntax-only -pedantic -verify=ext,expected %s
// RUN: %clang_cc1 -x c++ -std=c++17 -ftrigraphs -fsyntax-only -pedantic -verify=ext,expected -DTRIGRAPHS=1 %s // RUN: %clang_cc1 -x c++ -std=c++17 -ftrigraphs -fsyntax-only -pedantic -verify=ext,expected -DTRIGRAPHS=1 %s
const char *errors = const char *errors =
"\u{}" // expected-error {{delimited escape sequence cannot be empty}} "\u{}" // expected-error {{delimited escape sequence cannot be empty}}
"\u{" // expected-error {{expected '}'}} "\u{" // expected-error {{expected '}'}}
"\u{h}" // expected-error {{invalid digit 'h' in escape sequence}} "\u{h}" // expected-error {{invalid digit 'h' in escape sequence}}
"\x{}" // expected-error {{delimited escape sequence cannot be empty}} "\x{}" // expected-error {{delimited escape sequence cannot be empty}}
"\x{" // expected-error {{expected '}'}} "\x{" // expected-error {{expected '}'}}
"\x{h}" // expected-error {{invalid digit 'h' in escape sequence}} "\x{h}" // expected-error {{invalid digit 'h' in escape sequence}}
"\o{}" // expected-error {{delimited escape sequence cannot be empty}} "\o{}" // expected-error {{delimited escape sequence cannot be empty}}
"\o{" // expected-error {{expected '}'}} "\o{" // expected-error {{expected '}'}}
"\o" // expected-error {{expected '{' after '\o' escape sequence}} "\o" // expected-error {{expected '{' after '\o' escape sequence}}
"\o{8}" // expected-error {{invalid digit '8' in escape sequence}} "\o{8}" // expected-error {{invalid digit '8' in escape sequence}}
"\U{8}" // expected-error {{\U used with no following hex digits}} "\U{8}" // expected-error {{\U used with no following hex digits}}
; ;
void ucn(void) { void ucn(void) {
char a = '\u{1234}'; // expected-error {{character too large for enclosing character literal type}} \ char a = '\u{1234}'; // expected-error {{character too large for enclosing character literal type}} \
// ext-warning {{extension}} cxx2b-warning {{C++2b}} // ext-warning {{extension}} cxx23-warning {{C++23}}
unsigned b = U'\u{1234}'; // ext-warning {{extension}} cxx2b-warning {{C++2b}} unsigned b = U'\u{1234}'; // ext-warning {{extension}} cxx23-warning {{C++23}}
#ifdef __cplusplus #ifdef __cplusplus
unsigned b2 = U'\u{1}'; // ext-warning {{extension}} cxx2b-warning {{C++2b}} unsigned b2 = U'\u{1}'; // ext-warning {{extension}} cxx23-warning {{C++23}}
#else #else
unsigned b2 = U'\u{1}'; //expected-error {{universal character name refers to a control character}} unsigned b2 = U'\u{1}'; //expected-error {{universal character name refers to a control character}}
#endif #endif
unsigned c = U'\u{000000000001234}'; // ext-warning {{extension}} cxx2b-warning {{C++2b}} unsigned c = U'\u{000000000001234}'; // ext-warning {{extension}} cxx23-warning {{C++23}}
unsigned d = U'\u{111111111}'; //expected-error {{hex escape sequence out of range}} unsigned d = U'\u{111111111}'; //expected-error {{hex escape sequence out of range}}
} }
void hex(void) { void hex(void) {
char a = '\x{1}'; // ext-warning {{extension}} cxx2b-warning {{C++2b}} char a = '\x{1}'; // ext-warning {{extension}} cxx23-warning {{C++23}}
char b = '\x{abcdegggggabc}'; // expected-error 5{{invalid digit 'g' in escape sequence}} char b = '\x{abcdegggggabc}'; // expected-error 5{{invalid digit 'g' in escape sequence}}
char c = '\x{ff1}'; // expected-error {{hex escape sequence out of range}} char c = '\x{ff1}'; // expected-error {{hex escape sequence out of range}}
#if __WCHAR_MAX__ > 0xFFFF #if __WCHAR_MAX__ > 0xFFFF
unsigned d = L'\x{FFFFFFFF}'; // ext-warning {{extension}} cxx2b-warning {{C++2b}} unsigned d = L'\x{FFFFFFFF}'; // ext-warning {{extension}} cxx23-warning {{C++23}}
unsigned e = L'\x{100000000}'; // expected-error {{hex escape sequence out of range}} unsigned e = L'\x{100000000}'; // expected-error {{hex escape sequence out of range}}
#else #else
unsigned f = L'\x{FFFF}'; // ext-warning {{extension}} cxx2b-warning {{C++2b}} unsigned f = L'\x{FFFF}'; // ext-warning {{extension}} cxx23-warning {{C++23}}
unsigned g = L'\x{10000}'; // expected-error {{hex escape sequence out of range}} unsigned g = L'\x{10000}'; // expected-error {{hex escape sequence out of range}}
#endif #endif
unsigned h = U'\x{FFFFFFFF}'; // ext-warning {{extension}} cxx2b-warning {{C++2b}} unsigned h = U'\x{FFFFFFFF}'; // ext-warning {{extension}} cxx23-warning {{C++23}}
unsigned i = U'\x{100000000}'; // expected-error {{hex escape sequence out of range}} unsigned i = U'\x{100000000}'; // expected-error {{hex escape sequence out of range}}
} }
void octal(void) { void octal(void) {
char a = '\o{1}'; // ext-warning {{extension}} cxx2b-warning {{C++2b}} char a = '\o{1}'; // ext-warning {{extension}} cxx23-warning {{C++23}}
char b = '\o{12345678881238}'; // expected-error 4{{invalid digit '8' in escape sequence}} char b = '\o{12345678881238}'; // expected-error 4{{invalid digit '8' in escape sequence}}
char c = '\o{777}'; // //expected-error {{octal escape sequence out of range}} char c = '\o{777}'; // //expected-error {{octal escape sequence out of range}}
#if __WCHAR_MAX__ > 0xFFFF #if __WCHAR_MAX__ > 0xFFFF
unsigned d = L'\o{37777777777}'; // ext-warning {{extension}} cxx2b-warning {{C++2b}} unsigned d = L'\o{37777777777}'; // ext-warning {{extension}} cxx23-warning {{C++23}}
unsigned e = L'\o{40000000000}'; // expected-error {{octal escape sequence out of range}} unsigned e = L'\o{40000000000}'; // expected-error {{octal escape sequence out of range}}
unsigned f = L'\o{100000000000}'; // expected-error {{octal escape sequence out of range}} unsigned f = L'\o{100000000000}'; // expected-error {{octal escape sequence out of range}}
unsigned g = L'\o{200000000000}'; // expected-error {{octal escape sequence out of range}} unsigned g = L'\o{200000000000}'; // expected-error {{octal escape sequence out of range}}
#else #else
unsigned d = L'\o{177777}'; // ext-warning {{extension}} cxx2b-warning {{C++2b}} unsigned d = L'\o{177777}'; // ext-warning {{extension}} cxx23-warning {{C++23}}
unsigned e = L'\o{200000}'; // expected-error {{octal escape sequence out of range}} unsigned e = L'\o{200000}'; // expected-error {{octal escape sequence out of range}}
#endif #endif
} }
void concat(void) { void concat(void) {
(void)"\x{" "12}"; // expected-error {{expected '}'}} (void)"\x{" "12}"; // expected-error {{expected '}'}}
(void)"\u{" "12}"; // expected-error {{expected '}'}} (void)"\u{" "12}"; // expected-error {{expected '}'}}
(void)"\o{" "12}"; // expected-error {{expected '}'}} (void)"\o{" "12}"; // expected-error {{expected '}'}}
(void)"\x{12" "}"; // expected-error {{expected '}'}} (void)"\x{12" "}"; // expected-error {{expected '}'}}
(void)"\u{12" "}"; // expected-error {{expected '}'}} (void)"\u{12" "}"; // expected-error {{expected '}'}}
(void)"\o{12" "}"; // expected-error {{expected '}'}} (void)"\o{12" "}"; // expected-error {{expected '}'}}
} }
void named(void) { void named(void) {
char a = '\N{LOTUS}'; // expected-error{{character too large for enclosing character literal type}} \ char a = '\N{LOTUS}'; // expected-error{{character too large for enclosing character literal type}} \
// ext-warning {{extension}} cxx2b-warning {{C++2b}} // ext-warning {{extension}} cxx23-warning {{C++23}}
char b = '\N{DOLLAR SIGN}'; // ext-warning {{extension}} cxx2b-warning {{C++2b}} char b = '\N{DOLLAR SIGN}'; // ext-warning {{extension}} cxx23-warning {{C++23}}
char b_ = '\N{ DOL-LAR _SIGN }'; // expected-error {{' DOL-LAR _SIGN ' is not a valid Unicode character name}} \ char b_ = '\N{ DOL-LAR _SIGN }'; // expected-error {{' DOL-LAR _SIGN ' is not a valid Unicode character name}} \
// expected-note {{characters names in Unicode escape sequences are sensitive to case and whitespaces}} // expected-note {{characters names in Unicode escape sequences are sensitive to case and whitespaces}}
char c = '\N{NOTATHING}'; // expected-error {{'NOTATHING' is not a valid Unicode character name}} \ char c = '\N{NOTATHING}'; // expected-error {{'NOTATHING' is not a valid Unicode character name}} \
// expected-note 5{{did you mean}} // expected-note 5{{did you mean}}
char d = '\N{}'; // expected-error {{delimited escape sequence cannot be empty}} char d = '\N{}'; // expected-error {{delimited escape sequence cannot be empty}}
char e = '\N{'; // expected-error {{incomplete universal character name}} char e = '\N{'; // expected-error {{incomplete universal character name}}
unsigned f = L'\N{GREEK CAPITAL LETTER DELTA}'; // ext-warning {{extension}} cxx2b-warning {{C++2b}} unsigned f = L'\N{GREEK CAPITAL LETTER DELTA}'; // ext-warning {{extension}} cxx23-warning {{C++23}}
unsigned g = u'\N{LOTUS}'; // expected-error {{character too large for enclosing character literal type}} \ unsigned g = u'\N{LOTUS}'; // expected-error {{character too large for enclosing character literal type}} \
// ext-warning {{extension}} cxx2b-warning {{C++2b}} // ext-warning {{extension}} cxx23-warning {{C++23}}
unsigned h = U'\N{LOTUS}'; // ext-warning {{extension}} cxx2b-warning {{C++2b}} unsigned h = U'\N{LOTUS}'; // ext-warning {{extension}} cxx23-warning {{C++23}}
unsigned i = u'\N{GREEK CAPITAL LETTER DELTA}'; // ext-warning {{extension}} cxx2b-warning {{C++2b}} unsigned i = u'\N{GREEK CAPITAL LETTER DELTA}'; // ext-warning {{extension}} cxx23-warning {{C++23}}
char j = '\NN'; // expected-error {{expected '{' after '\N' escape sequence}} expected-warning {{multi-character character constant}} char j = '\NN'; // expected-error {{expected '{' after '\N' escape sequence}} expected-warning {{multi-character character constant}}
unsigned k = u'\N{LOTUS'; // expected-error {{incomplete universal character name}} unsigned k = u'\N{LOTUS'; // expected-error {{incomplete universal character name}}
const char* emoji = "\N{🤡}"; // expected-error {{'🤡' is not a valid Unicode character name}} \ const char* emoji = "\N{🤡}"; // expected-error {{'🤡' is not a valid Unicode character name}} \
// expected-note 5{{did you mean}} // expected-note 5{{did you mean}}
const char* nested = "\N{\N{SPARKLE}}"; // expected-error {{'\N{SPARKLE' is not a valid Unicode character name}} \ const char* nested = "\N{\N{SPARKLE}}"; // expected-error {{'\N{SPARKLE' is not a valid Unicode character name}} \
// expected-note 5{{did you mean}} // expected-note 5{{did you mean}}
} }
void separators(void) { void separators(void) {
(void)"\x{12'3}"; // expected-error {{invalid digit ''' in escape sequence}} (void)"\x{12'3}"; // expected-error {{invalid digit ''' in escape sequence}}
(void)"\u{12'3}"; // expected-error {{invalid digit ''' in escape sequence}} (void)"\u{12'3}"; // expected-error {{invalid digit ''' in escape sequence}}
(void)"\o{12'3}"; // expected-error {{invalid digit ''' in escape sequence}} (void)"\o{12'3}"; // expected-error {{invalid digit ''' in escape sequence}}
'\x{12'3'}'; // expected-error {{expected '}'}} '\x{12'3'}'; // expected-error {{expected '}'}}
// expected-error@-1 2{{expected ';'}} // expected-error@-1 2{{expected ';'}}
// expected-warning@-2 3{{expression result unused}} // expected-warning@-2 3{{expression result unused}}
} }
#if L'\N{GREEK CAPITAL LETTER GAMMA}' != L'Γ' // ext-warning {{extension}} cxx2b-warning {{C++2b}} #if L'\N{GREEK CAPITAL LETTER GAMMA}' != L'Γ' // ext-warning {{extension}} cxx23-warning {{C++23}}
#error "oh no!" #error "oh no!"
#endif #endif
#ifdef TRIGRAPHS #ifdef TRIGRAPHS
static_assert('\N??<DOLLAR SIGN??>' == '$'); // expected-warning 2{{trigraph converted}} \ static_assert('\N??<DOLLAR SIGN??>' == '$'); // expected-warning 2{{trigraph converted}} \
// ext-warning {{extension}} cxx2b-warning {{C++2b}} // ext-warning {{extension}} cxx23-warning {{C++23}}
#endif #endif

clang/test/Lexer/cxx-features.cpp

// RUN: %clang_cc1 -std=c++98 -fcxx-exceptions -verify %s // RUN: %clang_cc1 -std=c++98 -fcxx-exceptions -verify %s
// RUN: %clang_cc1 -std=c++11 -fcxx-exceptions -verify %s // RUN: %clang_cc1 -std=c++11 -fcxx-exceptions -verify %s
// RUN: %clang_cc1 -std=c++14 -fcxx-exceptions -fsized-deallocation -verify %s // RUN: %clang_cc1 -std=c++14 -fcxx-exceptions -fsized-deallocation -verify %s
// RUN: %clang_cc1 -std=c++17 -fcxx-exceptions -fsized-deallocation -verify %s // RUN: %clang_cc1 -std=c++17 -fcxx-exceptions -fsized-deallocation -verify %s
// RUN: %clang_cc1 -std=c++20 -fcxx-exceptions -fsized-deallocation -verify %s // RUN: %clang_cc1 -std=c++20 -fcxx-exceptions -fsized-deallocation -verify %s
// RUN: %clang_cc1 -std=c++2b -fcxx-exceptions -fsized-deallocation -verify %s // RUN: %clang_cc1 -std=c++23 -fcxx-exceptions -fsized-deallocation -verify %s
// //
// RUN: %clang_cc1 -std=c++17 -fcxx-exceptions -fsized-deallocation -frelaxed-template-template-args -DRELAXED_TEMPLATE_TEMPLATE_ARGS=1 -verify %s // RUN: %clang_cc1 -std=c++17 -fcxx-exceptions -fsized-deallocation -frelaxed-template-template-args -DRELAXED_TEMPLATE_TEMPLATE_ARGS=1 -verify %s
// RUN: %clang_cc1 -std=c++17 -fcxx-exceptions -fsized-deallocation -DCONCEPTS_TS=1 -verify %s // RUN: %clang_cc1 -std=c++17 -fcxx-exceptions -fsized-deallocation -DCONCEPTS_TS=1 -verify %s
// RUN: %clang_cc1 -std=c++14 -fno-rtti -fno-threadsafe-statics -verify %s -DNO_EXCEPTIONS -DNO_RTTI -DNO_THREADSAFE_STATICS -fsized-deallocation // RUN: %clang_cc1 -std=c++14 -fno-rtti -fno-threadsafe-statics -verify %s -DNO_EXCEPTIONS -DNO_RTTI -DNO_THREADSAFE_STATICS -fsized-deallocation
// RUN: %clang_cc1 -std=c++14 -fchar8_t -DNO_EXCEPTIONS -DCHAR8_T -verify -fsized-deallocation %s // RUN: %clang_cc1 -std=c++14 -fchar8_t -DNO_EXCEPTIONS -DCHAR8_T -verify -fsized-deallocation %s
// RUN: %clang_cc1 -std=c++2a -fno-char8_t -DNO_EXCEPTIONS -DNO_CHAR8_T -verify -fsized-deallocation %s // RUN: %clang_cc1 -std=c++2a -fno-char8_t -DNO_EXCEPTIONS -DNO_CHAR8_T -verify -fsized-deallocation %s
// expected-no-diagnostics // expected-no-diagnostics
// FIXME using `defined` in a macro has undefined behavior. // FIXME using `defined` in a macro has undefined behavior.
#if __cplusplus < 201103L #if __cplusplus < 201103L
#define check(macro, cxx98, cxx11, cxx14, cxx17, cxx20, cxx23) (cxx98 == 0 ? defined(__cpp_##macro) : __cpp_##macro != cxx98) #define check(macro, cxx98, cxx11, cxx14, cxx17, cxx20, cxx23) (cxx98 == 0 ? defined(__cpp_##macro) : __cpp_##macro != cxx98)
#elif __cplusplus < 201402L #elif __cplusplus < 201402L
#define check(macro, cxx98, cxx11, cxx14, cxx17, cxx20, cxx23) (cxx11 == 0 ? defined(__cpp_##macro) : __cpp_##macro != cxx11) #define check(macro, cxx98, cxx11, cxx14, cxx17, cxx20, cxx23) (cxx11 == 0 ? defined(__cpp_##macro) : __cpp_##macro != cxx11)
#elif __cplusplus < 201703L #elif __cplusplus < 201703L
#define check(macro, cxx98, cxx11, cxx14, cxx17, cxx20, cxx23) (cxx14 == 0 ? defined(__cpp_##macro) : __cpp_##macro != cxx14) #define check(macro, cxx98, cxx11, cxx14, cxx17, cxx20, cxx23) (cxx14 == 0 ? defined(__cpp_##macro) : __cpp_##macro != cxx14)
#elif __cplusplus < 202002L #elif __cplusplus < 202002L
#define check(macro, cxx98, cxx11, cxx14, cxx17, cxx20, cxx23) (cxx17 == 0 ? defined(__cpp_##macro) : __cpp_##macro != cxx17) #define check(macro, cxx98, cxx11, cxx14, cxx17, cxx20, cxx23) (cxx17 == 0 ? defined(__cpp_##macro) : __cpp_##macro != cxx17)
#elif __cplusplus == 202002L #elif __cplusplus == 202002L
#define check(macro, cxx98, cxx11, cxx14, cxx17, cxx20, cxx23) (cxx20 == 0 ? defined(__cpp_##macro) : __cpp_##macro != cxx20) #define check(macro, cxx98, cxx11, cxx14, cxx17, cxx20, cxx23) (cxx20 == 0 ? defined(__cpp_##macro) : __cpp_##macro != cxx20)
#else #else
#define check(macro, cxx98, cxx11, cxx14, cxx17, cxx20, cxx23) (cxx23 == 0 ? defined(__cpp_##macro) : __cpp_##macro != cxx23) #define check(macro, cxx98, cxx11, cxx14, cxx17, cxx20, cxx23) (cxx23 == 0 ? defined(__cpp_##macro) : __cpp_##macro != cxx23)
#endif #endif
// --- C++2b features --- // --- C++23 features ---
#if check(implicit_move, 0, 0, 0, 0, 0, 202011) #if check(implicit_move, 0, 0, 0, 0, 0, 202011)
#error "wrong value for __cpp_implicit_move" #error "wrong value for __cpp_implicit_move"
#endif #endif
#if check(size_t_suffix, 0, 0, 0, 0, 0, 202011) #if check(size_t_suffix, 0, 0, 0, 0, 0, 202011)
#error "wrong value for __cpp_size_t_suffix" #error "wrong value for __cpp_size_t_suffix"
#endif #endif
▲ Show 20 Lines • Show All 319 Lines • Show Last 20 Lines

clang/test/Lexer/size_t-literal.cpp

// RUN: %clang_cc1 -std=c++2b -fsyntax-only -verify %s // RUN: %clang_cc1 -std=c++23 -fsyntax-only -verify %s
#if 1z != 1 #if 1z != 1
#error "z suffix must be recognized by preprocessor" #error "z suffix must be recognized by preprocessor"
#endif #endif
#if 1uz != 1 #if 1uz != 1
#error "uz suffix must be recognized by preprocessor" #error "uz suffix must be recognized by preprocessor"
#endif #endif
#if !(-1z < 0) #if !(-1z < 0)
▲ Show 20 Lines • Show All 158 Lines • Show Last 20 Lines

clang/test/Modules/gmodules-deduction-guide.cpp

// REQUIRES: asserts // REQUIRES: asserts
// RUN: %clang_cc1 -std=c++2b -x c++-header -emit-pch -fmodule-format=obj -I %S/Inputs \ // RUN: %clang_cc1 -std=c++23 -x c++-header -emit-pch -fmodule-format=obj -I %S/Inputs \
// RUN: -o %t.pch %S/Inputs/gmodules-deduction-guide.h \ // RUN: -o %t.pch %S/Inputs/gmodules-deduction-guide.h \
// RUN: -mllvm -debug-only=pchcontainer &>%t-pch.ll // RUN: -mllvm -debug-only=pchcontainer &>%t-pch.ll
// RUN: cat %t-pch.ll | FileCheck %s // RUN: cat %t-pch.ll | FileCheck %s
// CHECK: ![[V0:.*]] = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "S<A>", // CHECK: ![[V0:.*]] = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "S<A>",
// CHECK: !DIDerivedType(tag: DW_TAG_typedef, name: "Type0",{{.*}}, baseType: ![[V0]]) // CHECK: !DIDerivedType(tag: DW_TAG_typedef, name: "Type0",{{.*}}, baseType: ![[V0]])

clang/test/Modules/merge-constrained-friends.cpp

// RUN: rm -rf %t // RUN: rm -rf %t
// RUN: mkdir -p %t // RUN: mkdir -p %t
// RUN: split-file %s %t // RUN: split-file %s %t
// //
// RUN: %clang_cc1 -std=c++2b %t/A.cppm -emit-module-interface -o %t/A.pcm // RUN: %clang_cc1 -std=c++23 %t/A.cppm -emit-module-interface -o %t/A.pcm
// RUN: %clang_cc1 -std=c++2b %t/Use.cpp -fprebuilt-module-path=%t -fsyntax-only -verify // RUN: %clang_cc1 -std=c++23 %t/Use.cpp -fprebuilt-module-path=%t -fsyntax-only -verify
//--- A.cppm //--- A.cppm
module; module;
export module A; export module A;
struct B {}; struct B {};
export template<int N> struct A : B { export template<int N> struct A : B {
▲ Show 20 Lines • Show All 51 Lines • Show Last 20 Lines

clang/test/OpenMP/target_update_messages.cpp

// RUN: %clang_cc1 -verify=expected,lt50,lt51 -fopenmp -fopenmp-version=45 -ferror-limit 100 -o - -std=c++11 %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,lt50,lt51 -fopenmp -fopenmp-version=45 -ferror-limit 100 -o - -std=c++11 %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,ge50,lt51 -fopenmp -fopenmp-version=50 -ferror-limit 100 -o - -std=c++11 %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,ge50,lt51 -fopenmp -fopenmp-version=50 -ferror-limit 100 -o - -std=c++11 %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,ge50,ge51 -fopenmp -fopenmp-version=51 -ferror-limit 100 -o - -std=c++11 %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,ge50,ge51 -fopenmp -fopenmp-version=51 -ferror-limit 100 -o - -std=c++11 %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,lt50,lt51 -fopenmp-simd -fopenmp-version=45 -ferror-limit 100 -o - -std=c++11 %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,lt50,lt51 -fopenmp-simd -fopenmp-version=45 -ferror-limit 100 -o - -std=c++11 %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,ge50,lt51 -fopenmp-simd -fopenmp-version=50 -ferror-limit 100 -o - -std=c++11 %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,ge50,lt51 -fopenmp-simd -fopenmp-version=50 -ferror-limit 100 -o - -std=c++11 %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,ge50,ge51 -fopenmp-simd -fopenmp-version=51 -ferror-limit 100 -o - -std=c++11 %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,ge50,ge51 -fopenmp-simd -fopenmp-version=51 -ferror-limit 100 -o - -std=c++11 %s -Wuninitialized
// RUN: %clang_cc1 -verify=expected,ge50,ge51,cxx2b -fopenmp -fopenmp-simd -fopenmp-version=51 -x c++ -std=c++2b %s -Wuninitialized // RUN: %clang_cc1 -verify=expected,ge50,ge51,cxx23 -fopenmp -fopenmp-simd -fopenmp-version=51 -x c++ -std=c++23 %s -Wuninitialized
void xxx(int argc) { void xxx(int argc) {
int x; // expected-note {{initialize the variable 'x' to silence this warning}} int x; // expected-note {{initialize the variable 'x' to silence this warning}}
#pragma omp target update to(x) #pragma omp target update to(x)
argc = x; // expected-warning {{variable 'x' is uninitialized when used here}} argc = x; // expected-warning {{variable 'x' is uninitialized when used here}}
} }
static int y; static int y;
▲ Show 20 Lines • Show All 205 Lines • ▼ Show 20 Linesstruct bar {
void func() { void func() {
#pragma omp target map(to: a) // expected-error {{incomplete type 'FOO' where a complete type is required}} #pragma omp target map(to: a) // expected-error {{incomplete type 'FOO' where a complete type is required}}
foo(); foo();
} }
}; };
#if defined(__cplusplus) && __cplusplus >= 202101L #if defined(__cplusplus) && __cplusplus >= 202101L
namespace cxx2b { namespace cxx23 {
struct S { struct S {
int operator[](auto...); int operator[](auto...);
}; };
void f() { void f() {
int test[10]; int test[10];
#pragma omp target update to(test[1]) #pragma omp target update to(test[1])
#pragma omp target update to(test[1, 2]) // cxx2b-error {{type 'int[10]' does not provide a subscript operator}} \ #pragma omp target update to(test[1, 2]) // cxx23-error {{type 'int[10]' does not provide a subscript operator}} \
// cxx2b-error {{expected at least one 'to' clause or 'from' clause specified to '#pragma omp target update'}} // cxx23-error {{expected at least one 'to' clause or 'from' clause specified to '#pragma omp target update'}}
#pragma omp target update to(test [1:1:1]) #pragma omp target update to(test [1:1:1])
#pragma omp target update to(test [1, 2:1:1]) // cxx2b-error {{expected ']'}} // expected-note {{'['}} \ #pragma omp target update to(test [1, 2:1:1]) // cxx23-error {{expected ']'}} // expected-note {{'['}} \
// cxx2b-error {{expected at least one 'to' clause or 'from' clause specified to '#pragma omp target update'}} // cxx23-error {{expected at least one 'to' clause or 'from' clause specified to '#pragma omp target update'}}
#pragma omp target update to(test [1, 2:]) // cxx2b-error {{expected ']'}} // expected-note {{'['}} \ #pragma omp target update to(test [1, 2:]) // cxx23-error {{expected ']'}} // expected-note {{'['}} \
// cxx2b-error {{expected at least one 'to' clause or 'from' clause specified to '#pragma omp target update'}} // cxx23-error {{expected at least one 'to' clause or 'from' clause specified to '#pragma omp target update'}}
#pragma omp target update to(test[1, 2 ::]) // cxx2b-error {{expected ']'}} // expected-note {{'['}} \ #pragma omp target update to(test[1, 2 ::]) // cxx23-error {{expected ']'}} // expected-note {{'['}} \
// cxx2b-error {{expected at least one 'to' clause or 'from' clause specified to '#pragma omp target update'}} // cxx23-error {{expected at least one 'to' clause or 'from' clause specified to '#pragma omp target update'}}
#pragma omp target update to(test[]) // cxx2b-error {{type 'int[10]' does not provide a subscript operator}} \ #pragma omp target update to(test[]) // cxx23-error {{type 'int[10]' does not provide a subscript operator}} \
// cxx2b-error {{expected at least one 'to' clause or 'from' clause specified to '#pragma omp target update'}} // cxx23-error {{expected at least one 'to' clause or 'from' clause specified to '#pragma omp target update'}}
S s; S s;
(void)s[0]; (void)s[0];
(void)s[]; (void)s[];
(void)s[1, 2]; (void)s[1, 2];
} }
} }
#endif #endif

clang/test/Parser/cxx-concepts-requires-clause.cpp

// RUN: %clang_cc1 -std=c++2a -x c++ %s -verify // RUN: %clang_cc1 -std=c++20 -x c++ %s -verify
// RUN: %clang_cc1 -std=c++2b -x c++ %s -verify // RUN: %clang_cc1 -std=c++23 -x c++ %s -verify
// Test parsing of the optional requires-clause in a template-declaration. // Test parsing of the optional requires-clause in a template-declaration.
template <typename T> requires true template <typename T> requires true
void foo() { } void foo() { }
template <typename T> requires (!0) template <typename T> requires (!0)
struct A { struct A {
▲ Show 20 Lines • Show All 150 Lines • ▼ Show 20 Lines
auto lambda1 = [] (auto x) requires (sizeof(decltype(x)) == 1) { }; auto lambda1 = [] (auto x) requires (sizeof(decltype(x)) == 1) { };
auto lambda2 = [] (auto x) constexpr -> int requires (sizeof(decltype(x)) == 1) { return 0; }; auto lambda2 = [] (auto x) constexpr -> int requires (sizeof(decltype(x)) == 1) { return 0; };
auto lambda3 = []<auto> requires(sizeof(char) == 1){}; auto lambda3 = []<auto> requires(sizeof(char) == 1){};
auto lambda4 = [] requires(sizeof(char) == 1){}; // expected-error {{expected body of lambda expression}} auto lambda4 = [] requires(sizeof(char) == 1){}; // expected-error {{expected body of lambda expression}}
#if __cplusplus <= 202002L #if __cplusplus <= 202002L
// expected-warning@-2{{lambda without a parameter clause is a C++2b extension}} // expected-warning@-2{{lambda without a parameter clause is a C++23 extension}}
#endif #endif

clang/test/Parser/cxx0x-lambda-expressions.cpp

// RUN: %clang_cc1 -fsyntax-only -Wno-unused-value -verify -std=c++11 -Wno-c99-designator %s // RUN: %clang_cc1 -fsyntax-only -Wno-unused-value -verify -std=c++11 -Wno-c99-designator %s
// RUN: %clang_cc1 -fsyntax-only -Wno-unused-value -verify -std=c++2a -Wno-c99-designator %s // RUN: %clang_cc1 -fsyntax-only -Wno-unused-value -verify -std=c++20 -Wno-c99-designator %s
// RUN: %clang_cc1 -fsyntax-only -Wno-unused-value -verify -std=c++2b -Wno-c99-designator %s // RUN: %clang_cc1 -fsyntax-only -Wno-unused-value -verify -std=c++23 -Wno-c99-designator %s
enum E { e }; enum E { e };
constexpr int id(int n) { return n; } constexpr int id(int n) { return n; }
class C { class C {
int f() { int f() {
Show All 14 Lines int f() {
[&,foo] () {}; [&,foo] () {};
[this] () {}; [this] () {};
[] () -> class C { return C(); }; [] () -> class C { return C(); };
[] () -> enum E { return e; }; [] () -> enum E { return e; };
[] -> int { return 0; }; [] -> int { return 0; };
[] mutable -> int { return 0; }; [] mutable -> int { return 0; };
#if __cplusplus <= 202002L #if __cplusplus <= 202002L
// expected-warning@-3 {{lambda without a parameter clause is a C++2b extension}} // expected-warning@-3 {{lambda without a parameter clause is a C++23 extension}}
// expected-warning@-3 {{is a C++2b extension}} // expected-warning@-3 {{is a C++23 extension}}
#endif #endif
[](int) -> {}; // PR13652 expected-error {{expected a type}} [](int) -> {}; // PR13652 expected-error {{expected a type}}
return 1; return 1;
} }
void designator_or_lambda() { void designator_or_lambda() {
typedef int T; typedef int T;
const int b = 0; const int b = 0;
▲ Show 20 Lines • Show All 59 Lines • ▼ Show 20 Lines#endif
r += 2; r += 2;
return x + 2; return x + 2;
} (); } ();
} }
void attributes() { void attributes() {
[] __attribute__((noreturn)){}; [] __attribute__((noreturn)){};
#if __cplusplus <= 202002L #if __cplusplus <= 202002L
// expected-warning@-2 {{is a C++2b extension}} // expected-warning@-2 {{is a C++23 extension}}
#endif #endif
[]() [[]] []() [[]]
mutable {}; // expected-error {{expected body of lambda expression}} mutable {}; // expected-error {{expected body of lambda expression}}
[]() [[]] {}; []() [[]] {};
[]() [[]] -> void {}; []() [[]] -> void {};
[]() mutable [[]] -> void {}; []() mutable [[]] -> void {};
[]() mutable noexcept [[]] -> void {}; []() mutable noexcept [[]] -> void {};
// Testing GNU-style attributes on lambdas -- the attribute is specified // Testing GNU-style attributes on lambdas -- the attribute is specified
// before the mutable specifier instead of after (unlike C++11). // before the mutable specifier instead of after (unlike C++11).
[]() __attribute__((noreturn)) mutable { while(1); }; []() __attribute__((noreturn)) mutable { while(1); };
[]() mutable []() mutable
__attribute__((noreturn)) { while(1); }; // expected-error {{expected body of lambda expression}} __attribute__((noreturn)) { while(1); }; // expected-error {{expected body of lambda expression}}
// Testing support for P2173 on adding attributes to the declaration // Testing support for P2173 on adding attributes to the declaration
// rather than the type. // rather than the type.
[][[]](){}; [][[]](){};
#if __cplusplus <= 202002L #if __cplusplus <= 202002L
// expected-warning@-2 {{an attribute specifier sequence in this position is a C++2b extension}} // expected-warning@-2 {{an attribute specifier sequence in this position is a C++23 extension}}
#endif #endif
#if __cplusplus > 201703L #if __cplusplus > 201703L
[]<typename>[[]](){}; []<typename>[[]](){};
#if __cplusplus <= 202002L #if __cplusplus <= 202002L
// expected-warning@-2 {{an attribute specifier sequence in this position is a C++2b extension}} // expected-warning@-2 {{an attribute specifier sequence in this position is a C++23 extension}}
#endif #endif
#endif #endif
[][[]]{}; [][[]]{};
#if __cplusplus <= 202002L #if __cplusplus <= 202002L
// expected-warning@-2 {{an attribute specifier sequence in this position is a C++2b extension}} // expected-warning@-2 {{an attribute specifier sequence in this position is a C++23 extension}}
#endif #endif
} }
void missing_parens() { void missing_parens() {
[] mutable {}; [] mutable {};
[] noexcept {}; [] noexcept {};
#if __cplusplus <= 202002L #if __cplusplus <= 202002L
// expected-warning@-3 {{is a C++2b extension}} // expected-warning@-3 {{is a C++23 extension}}
// expected-warning@-3 {{is a C++2b extension}} // expected-warning@-3 {{is a C++23 extension}}
#endif #endif
} }
}; };
template <typename> template <typename>
void PR22122() { void PR22122() {
[](int) -> {}; // expected-error {{expected a type}} [](int) -> {}; // expected-error {{expected a type}}
} }
Show All 25 Lines

clang/test/Parser/cxx1z-constexpr-lambdas.cpp

// RUN: %clang_cc1 -std=c++2b %s -verify // RUN: %clang_cc1 -std=c++23 %s -verify
// RUN: %clang_cc1 -std=c++20 %s -verify // RUN: %clang_cc1 -std=c++20 %s -verify
// RUN: %clang_cc1 -std=c++17 %s -verify // RUN: %clang_cc1 -std=c++17 %s -verify
// RUN: %clang_cc1 -std=c++14 %s -verify // RUN: %clang_cc1 -std=c++14 %s -verify
// RUN: %clang_cc1 -std=c++11 %s -verify // RUN: %clang_cc1 -std=c++11 %s -verify
auto XL0 = [] constexpr { return true; }; auto XL0 = [] constexpr { return true; };
#if __cplusplus <= 201402L #if __cplusplus <= 201402L
// expected-warning@-2 {{is a C++17 extension}} // expected-warning@-2 {{is a C++17 extension}}
#endif #endif
#if __cplusplus <= 202002L #if __cplusplus <= 202002L
// expected-warning@-5 {{lambda without a parameter clause is a C++2b extension}} // expected-warning@-5 {{lambda without a parameter clause is a C++23 extension}}
#endif #endif
auto XL1 = []() mutable // auto XL1 = []() mutable //
mutable // expected-error{{cannot appear multiple times}} mutable // expected-error{{cannot appear multiple times}}
mutable {}; // expected-error{{cannot appear multiple times}} mutable {}; // expected-error{{cannot appear multiple times}}
#if __cplusplus > 201402L #if __cplusplus > 201402L
auto XL2 = [] () constexpr mutable constexpr { }; //expected-error{{cannot appear multiple times}} auto XL2 = [] () constexpr mutable constexpr { }; //expected-error{{cannot appear multiple times}}
auto L = []() mutable constexpr { }; auto L = []() mutable constexpr { };
Show All 18 Lines

clang/test/Parser/cxx2a-template-lambdas.cpp

// RUN: %clang_cc1 -std=c++2b %s -verify // RUN: %clang_cc1 -std=c++23 %s -verify
// RUN: %clang_cc1 -std=c++2a %s -verify // RUN: %clang_cc1 -std=c++20 %s -verify
auto L0 = []<> { }; //expected-error {{cannot be empty}} auto L0 = []<> { }; //expected-error {{cannot be empty}}
auto L1 = []<typename T1, typename T2> { }; auto L1 = []<typename T1, typename T2> { };
auto L2 = []<typename T1, typename T2>(T1 arg1, T2 arg2) -> T1 { }; auto L2 = []<typename T1, typename T2>(T1 arg1, T2 arg2) -> T1 { };
auto L3 = []<typename T>(auto arg) { T t; }; auto L3 = []<typename T>(auto arg) { T t; };
auto L4 = []<int I>() { }; auto L4 = []<int I>() { };
// http://llvm.org/PR49736 // http://llvm.org/PR49736
auto L5 = []<auto>(){}; auto L5 = []<auto>(){};
auto L6 = []<auto>{}; auto L6 = []<auto>{};
auto L7 = []<auto>() noexcept {}; auto L7 = []<auto>() noexcept {};
auto L8 = []<auto> noexcept {}; auto L8 = []<auto> noexcept {};
#if __cplusplus <= 202002L #if __cplusplus <= 202002L
// expected-warning@-2 {{lambda without a parameter clause is a C++2b extension}} // expected-warning@-2 {{lambda without a parameter clause is a C++23 extension}}
#endif #endif
auto L9 = []<auto> requires true {}; auto L9 = []<auto> requires true {};
auto L10 = []<auto> requires true(){}; auto L10 = []<auto> requires true(){};
auto L11 = []<auto> requires true() noexcept {}; auto L11 = []<auto> requires true() noexcept {};
auto L12 = []<auto> requires true noexcept {}; auto L12 = []<auto> requires true noexcept {};
#if __cplusplus <= 202002L #if __cplusplus <= 202002L
// expected-warning@-2 {{is a C++2b extension}} // expected-warning@-2 {{is a C++23 extension}}
#endif #endif
auto L13 = []<auto>() noexcept requires true {}; auto L13 = []<auto>() noexcept requires true {};
auto L14 = []<auto> requires true() noexcept requires true {}; auto L14 = []<auto> requires true() noexcept requires true {};
auto XL0 = []<auto> noexcept requires true {}; // expected-error {{expected body of lambda expression}} auto XL0 = []<auto> noexcept requires true {}; // expected-error {{expected body of lambda expression}}
auto XL1 = []<auto> requires true noexcept requires true {}; // expected-error {{expected body}} auto XL1 = []<auto> requires true noexcept requires true {}; // expected-error {{expected body}}
#if __cplusplus <= 202002L #if __cplusplus <= 202002L
// expected-warning@-3 {{is a C++2b extension}} // expected-warning@-3 {{is a C++23 extension}}
// expected-warning@-3 {{is a C++2b extension}} // expected-warning@-3 {{is a C++23 extension}}
#endif #endif

clang/test/Parser/cxx2b-auto-x.cpp

// RUN: %clang_cc1 -fsyntax-only -verify=expected,cxx2b -std=c++2b -Wpre-c++2b-compat %s // RUN: %clang_cc1 -fsyntax-only -verify=expected,cxx23 -std=c++23 -Wpre-c++23-compat %s
// RUN: %clang_cc1 -fsyntax-only -verify=expected,cxx20 -std=c++20 %s // RUN: %clang_cc1 -fsyntax-only -verify=expected,cxx20 -std=c++20 %s
void looks_like_decltype_auto() { void looks_like_decltype_auto() {
decltype(auto(42)) b = 42; // cxx20-error {{'auto' not allowed here}} \ decltype(auto(42)) b = 42; // cxx20-error {{'auto' not allowed here}} \
cxx2b-warning {{'auto' as a functional-style cast is incompatible with C++ standards before C++2b}} cxx23-warning {{'auto' as a functional-style cast is incompatible with C++ standards before C++23}}
decltype(long *) a = 42; // expected-error {{expected '(' for function-style cast or type construction}} \ decltype(long *) a = 42; // expected-error {{expected '(' for function-style cast or type construction}} \
expected-error {{expected expression}} expected-error {{expected expression}}
decltype(auto *) a = 42; // expected-error {{expected '(' for function-style cast or type construction}} \ decltype(auto *) a = 42; // expected-error {{expected '(' for function-style cast or type construction}} \
expected-error {{expected expression}} expected-error {{expected expression}}
decltype(auto()) c = 42; // cxx2b-error {{initializer for functional-style cast to 'auto' is empty}} \ decltype(auto()) c = 42; // cxx23-error {{initializer for functional-style cast to 'auto' is empty}} \
cxx20-error {{'auto' not allowed here}} cxx20-error {{'auto' not allowed here}}
} }
struct looks_like_declaration { struct looks_like_declaration {
int n; int n;
} a; } a;
using T = looks_like_declaration *; using T = looks_like_declaration *;
void f() { T(&a)->n = 1; } void f() { T(&a)->n = 1; }
// FIXME: They should be deemed expressions without breaking function pointer // FIXME: They should be deemed expressions without breaking function pointer
// parameter declarations with trailing return types. // parameter declarations with trailing return types.
// void g() { auto(&a)->n = 0; } // void g() { auto(&a)->n = 0; }
// void h() { auto{&a}->n = 0; } // void h() { auto{&a}->n = 0; }

clang/test/Parser/cxx2b-init-statement.cpp

// RUN: %clang_cc1 -fsyntax-only -verify=expected -std=c++2b -Wall %s // RUN: %clang_cc1 -fsyntax-only -verify=expected -std=c++23 -Wall %s
// RUN: %clang_cc1 -fsyntax-only -verify=expected,expected-cxx20 -std=c++20 -Wall %s // RUN: %clang_cc1 -fsyntax-only -verify=expected,expected-cxx20 -std=c++20 -Wall %s
namespace ns { namespace ns {
int i; int i;
enum class e {}; enum class e {};
} }
void f() { void f() {
for (using foo = int;true;); //expected-cxx20-warning {{alias declaration in this context is a C++2b extension}} for (using foo = int;true;); //expected-cxx20-warning {{alias declaration in this context is a C++23 extension}}
switch(using foo = int; 0) { //expected-cxx20-warning {{alias declaration in this context is a C++2b extension}} switch(using foo = int; 0) { //expected-cxx20-warning {{alias declaration in this context is a C++23 extension}}
case 0: break; case 0: break;
} }
if(using foo = int; false) {} //expected-cxx20-warning {{alias declaration in this context is a C++2b extension}} if(using foo = int; false) {} //expected-cxx20-warning {{alias declaration in this context is a C++23 extension}}
if (using enum ns::e; false){} // expected-error {{expected '='}} if (using enum ns::e; false){} // expected-error {{expected '='}}
for (using ns::i; true;); // expected-error {{expected '='}} for (using ns::i; true;); // expected-error {{expected '='}}
if (using ns::i; false){} // expected-error {{expected '='}} if (using ns::i; false){} // expected-error {{expected '='}}
switch(using ns::i; 0) { // expected-error {{expected '='}} switch(using ns::i; 0) { // expected-error {{expected '='}}
case 0: break; case 0: break;
} }
} }

clang/test/Parser/cxx2b-label.cpp

// RUN: %clang_cc1 -fsyntax-only -verify=expected,cxx2b -std=c++2b -Wpre-c++2b-compat %s // RUN: %clang_cc1 -fsyntax-only -verify=expected,cxx23 -std=c++23 -Wpre-c++23-compat %s
ldionneUnsubmitted
Done
ReplyInline Actions

We could also consider renaming those files.

ldionne: We could also consider renaming those files.
MordanteAuthorUnsubmitted
Done
ReplyInline Actions

I could do that but rather in a follow-up there are still files named like clang/test/Parser/cxx0x-lambda-expressions.cpp too. I'm not sure how much the Clang devs want to remove these code names.

Mordante: I could do that but rather in a follow-up there are still files named like…
// RUN: %clang_cc1 -fsyntax-only -verify=expected,cxx20 -std=c++20 %s // RUN: %clang_cc1 -fsyntax-only -verify=expected,cxx20 -std=c++20 %s
void test_label_in_func() { void test_label_in_func() {
label1: label1:
int x; int x;
label2: label2:
x = 1; x = 1;
label3: label4: label5: label3: label4: label5:
} // cxx20-warning {{label at end of compound statement is a C++2b extension}} \ } // cxx20-warning {{label at end of compound statement is a C++23 extension}} \
cxx2b-warning {{label at end of compound statement is incompatible with C++ standards before C++2b}} cxx23-warning {{label at end of compound statement is incompatible with C++ standards before C++23}}
int test_label_in_switch(int v) { int test_label_in_switch(int v) {
switch (v) { switch (v) {
case 1: case 1:
return 1; return 1;
case 2: case 2:
return 2; return 2;
case 3: case 4: case 5: case 3: case 4: case 5:
} // cxx20-warning {{label at end of compound statement is a C++2b extension}} \ } // cxx20-warning {{label at end of compound statement is a C++23 extension}} \
cxx2b-warning {{label at end of compound statement is incompatible with C++ standards before C++2b}} cxx23-warning {{label at end of compound statement is incompatible with C++ standards before C++23}}
switch (v) { switch (v) {
case 6: case 6:
return 6; return 6;
default: default:
} // cxx20-warning {{label at end of compound statement is a C++2b extension}} \ } // cxx20-warning {{label at end of compound statement is a C++23 extension}} \
cxx2b-warning {{label at end of compound statement is incompatible with C++ standards before C++2b}} cxx23-warning {{label at end of compound statement is incompatible with C++ standards before C++23}}
return 0; return 0;
} }

clang/test/Parser/cxx2b-lambdas-ext-warns.cpp

// RUN: %clang_cc1 -std=c++20 %s -verify=cxx20 // RUN: %clang_cc1 -std=c++20 %s -verify=cxx20
// RUN: %clang_cc1 -std=c++2b %s -verify=cxx2b // RUN: %clang_cc1 -std=c++23 %s -verify=cxx23
// RUN: %clang_cc1 -std=c++2b -Wpre-c++2b-compat %s -verify=precxx2b // RUN: %clang_cc1 -std=c++23 -Wpre-c++23-compat %s -verify=precxx23
// RUN: %clang_cc1 -std=c++2b -pedantic %s -verify=cxx2b // RUN: %clang_cc1 -std=c++23 -pedantic %s -verify=cxx23
//cxx2b-no-diagnostics //cxx23-no-diagnostics
auto L1 = [] constexpr {}; auto L1 = [] constexpr {};
// cxx20-warning@-1 {{lambda without a parameter clause is a C++2b extension}} // cxx20-warning@-1 {{lambda without a parameter clause is a C++23 extension}}
auto L2 = []() static {}; auto L2 = []() static {};
// cxx20-warning@-1 {{static lambdas are a C++2b extension}} // cxx20-warning@-1 {{static lambdas are a C++23 extension}}
// precxx2b-warning@-2 {{static lambdas are incompatible with C++ standards before C++2b}} // precxx23-warning@-2 {{static lambdas are incompatible with C++ standards before C++23}}
auto L3 = [] static {}; auto L3 = [] static {};
// cxx20-warning@-1 {{lambda without a parameter clause is a C++2b extension}} // cxx20-warning@-1 {{lambda without a parameter clause is a C++23 extension}}
// cxx20-warning@-2 {{static lambdas are a C++2b extension}} // cxx20-warning@-2 {{static lambdas are a C++23 extension}}
// precxx2b-warning@-3 {{static lambdas are incompatible with C++ standards before C++2b}} // precxx23-warning@-3 {{static lambdas are incompatible with C++ standards before C++23}}

clang/test/Parser/cxx2b-lambdas.cpp

// RUN: %clang_cc1 -std=c++2b %s -verify // RUN: %clang_cc1 -std=c++23 %s -verify
auto LL0 = [] {}; auto LL0 = [] {};
auto LL1 = []() {}; auto LL1 = []() {};
auto LL2 = []() mutable {}; auto LL2 = []() mutable {};
auto LL3 = []() constexpr {}; auto LL3 = []() constexpr {};
auto L0 = [] constexpr {}; auto L0 = [] constexpr {};
auto L1 = [] mutable {}; auto L1 = [] mutable {};
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

clang/test/Parser/cxx2b-subscript.cpp

// RUN: %clang_cc1 -fsyntax-only -verify=expected,cxx2b -std=c++2b %s // RUN: %clang_cc1 -fsyntax-only -verify=expected,cxx23 -std=c++23 %s
// RUN: %clang_cc1 -fsyntax-only -verify=expected,cxx20 -std=c++20 %s // RUN: %clang_cc1 -fsyntax-only -verify=expected,cxx20 -std=c++20 %s
//cxx2b-no-diagnostics //cxx23-no-diagnostics
struct S { struct S {
constexpr int operator[](int i) { constexpr int operator[](int i) {
return i; return i;
} }
constexpr int operator[](int a, int b) { // cxx20-error {{overloaded 'operator[]' cannot have more than one parameter before C++2b}} constexpr int operator[](int a, int b) { // cxx20-error {{overloaded 'operator[]' cannot have more than one parameter before C++23}}
return a + b; return a + b;
} }
constexpr int operator[]() { // cxx20-error {{overloaded 'operator[]' cannot have no parameter before C++2b}} constexpr int operator[]() { // cxx20-error {{overloaded 'operator[]' cannot have no parameter before C++23}}
return 42; return 42;
} }
}; };
struct Defaults { struct Defaults {
constexpr int operator[](int i = 0) { // cxx20-error {{overloaded 'operator[]' cannot have a defaulted parameter before C++2b}} constexpr int operator[](int i = 0) { // cxx20-error {{overloaded 'operator[]' cannot have a defaulted parameter before C++23}}
return 0; return 0;
} }
constexpr int operator[](int a, int b, int c = 0) { // cxx20-error {{overloaded 'operator[]' cannot have a defaulted parameter before C++2b}}\ constexpr int operator[](int a, int b, int c = 0) { // cxx20-error {{overloaded 'operator[]' cannot have a defaulted parameter before C++23}}\
// cxx20-error {{cannot have more than one parameter before C++2b}} // cxx20-error {{cannot have more than one parameter before C++23}}
return 0; return 0;
} }
}; };
template <typename... T> template <typename... T>
struct T1 { struct T1 {
constexpr auto operator[](T &&...arg); // cxx20-error {{overloaded 'operator[]' cannot have no parameter before C++2b}} \ constexpr auto operator[](T &&...arg); // cxx20-error {{overloaded 'operator[]' cannot have no parameter before C++23}} \
// cxx20-error {{overloaded 'operator[]' cannot have more than one parameter before C++2b}} // cxx20-error {{overloaded 'operator[]' cannot have more than one parameter before C++23}}
}; };
T1<> t10; // cxx20-note {{requested here}} T1<> t10; // cxx20-note {{requested here}}
T1<int, int> t12; // cxx20-note {{requested here}} T1<int, int> t12; // cxx20-note {{requested here}}
T1<int> t11; T1<int> t11;
struct Variadic { struct Variadic {
constexpr int operator[](auto &&...arg) { return 0; } constexpr int operator[](auto &&...arg) { return 0; }
}; };
void f() { void f() {
S s; S s;
(void)s[0]; (void)s[0];
(void)s[1, 2]; // cxx20-warning {{left operand of comma operator has no effect}}\ (void)s[1, 2]; // cxx20-warning {{left operand of comma operator has no effect}}\
// cxx20-warning {{top-level comma expression in array subscript is deprecated in C++20 and unsupported in C++2b}} // cxx20-warning {{top-level comma expression in array subscript is deprecated in C++20 and unsupported in C++23}}
(void)S{}[]; // cxx20-error {{expected expression}} (void)S{}[]; // cxx20-error {{expected expression}}
(void)Defaults{}[1]; (void)Defaults{}[1];
(void)Defaults{}[]; // cxx20-error {{expected expression}} (void)Defaults{}[]; // cxx20-error {{expected expression}}
(void)Defaults{}[1, 2]; // cxx20-warning {{left operand of comma operator has no effect}}\ (void)Defaults{}[1, 2]; // cxx20-warning {{left operand of comma operator has no effect}}\
// cxx20-warning {{top-level comma expression in array subscript is deprecated in C++20 and unsupported in C++2b}} // cxx20-warning {{top-level comma expression in array subscript is deprecated in C++20 and unsupported in C++23}}
Variadic{}[]; // cxx20-error {{expected expression}} Variadic{}[]; // cxx20-error {{expected expression}}
Variadic{}[1]; Variadic{}[1];
Variadic{}[1, 2]; // cxx20-warning {{left operand of comma operator has no effect}}\ Variadic{}[1, 2]; // cxx20-warning {{left operand of comma operator has no effect}}\
// cxx20-warning {{top-level comma expression in array subscript is deprecated in C++20 and unsupported in C++2b}} // cxx20-warning {{top-level comma expression in array subscript is deprecated in C++20 and unsupported in C++23}}
} }

clang/test/Parser/switch-recovery.cpp

Show First 20 Lines • Show All 155 Lines • ▼ Show 20 Lines switch (x) {
} }
} }
} }
void missing_statement_case(int x) { void missing_statement_case(int x) {
switch (x) { switch (x) {
case 1: case 1:
case 0: case 0:
} // expected-warning {{label at end of compound statement is a C++2b extension}} } // expected-warning {{label at end of compound statement is a C++23 extension}}
} }
void missing_statement_default(int x) { void missing_statement_default(int x) {
switch (x) { switch (x) {
case 0: case 0:
default: default:
} // expected-warning {{label at end of compound statement is a C++2b extension}} } // expected-warning {{label at end of compound statement is a C++23 extension}}
} }
void pr19022_1() { void pr19022_1() {
switch (int x) // expected-error {{variable declaration in condition must have an initializer}} switch (int x) // expected-error {{variable declaration in condition must have an initializer}}
case v: ; // expected-error {{use of undeclared identifier 'v'}} case v: ; // expected-error {{use of undeclared identifier 'v'}}
} }
void pr19022_1a(int x) { void pr19022_1a(int x) {
switch(x) { switch(x) {
case 1 // expected-error{{expected ':' after 'case'}} case 1 // expected-error{{expected ':' after 'case'}}
} // expected-warning {{label at end of compound statement is a C++2b extension}} } // expected-warning {{label at end of compound statement is a C++23 extension}}
} }
void pr19022_1b(int x) { void pr19022_1b(int x) {
switch(x) { switch(x) {
case v // expected-error{{use of undeclared identifier 'v'}} \ case v // expected-error{{use of undeclared identifier 'v'}} \
// expected-error{{expected ':' after 'case'}} // expected-error{{expected ':' after 'case'}}
} // expected-error{{expected statement}} } // expected-error{{expected statement}}
} }
Show All 15 Linesint pr19022_4(int x) {
case 1 : return x; // expected-error{{duplicate case value '1'}} case 1 : return x; // expected-error{{duplicate case value '1'}}
} }
} }
void pr19022_5(int x) { void pr19022_5(int x) {
switch(x) { switch(x) {
case 1: case // expected-error{{expected ':' after 'case'}} case 1: case // expected-error{{expected ':' after 'case'}}
} // expected-error{{expected expression}} \ } // expected-error{{expected expression}} \
// expected-warning {{label at end of compound statement is a C++2b extension}} // expected-warning {{label at end of compound statement is a C++23 extension}}
} }
namespace pr19022 { namespace pr19022 {
int baz5() {} int baz5() {}
bool bar0() { bool bar0() {
switch (int foo0) //expected-error{{variable declaration in condition must have an initializer}} switch (int foo0) //expected-error{{variable declaration in condition must have an initializer}}
case bar5: ; // expected-error{{use of undeclared identifier 'bar5'}} case bar5: ; // expected-error{{use of undeclared identifier 'bar5'}}
} }
Show All 10 Lines

clang/test/Preprocessor/ext-pp-directive.c

// For C // For C
// RUN: %clang_cc1 -std=c99 -fsyntax-only -verify=pre-c2x-pedantic -pedantic %s // RUN: %clang_cc1 -std=c99 -fsyntax-only -verify=pre-c2x-pedantic -pedantic %s
// RUN: %clang_cc1 -std=c2x -fsyntax-only -verify=pre-c2x-compat -Wpre-c2x-compat %s // RUN: %clang_cc1 -std=c2x -fsyntax-only -verify=pre-c2x-compat -Wpre-c2x-compat %s
// RUN: not %clang_cc1 -std=c99 -fsyntax-only -verify %s // RUN: not %clang_cc1 -std=c99 -fsyntax-only -verify %s
// RUN: not %clang_cc1 -std=c2x -fsyntax-only -verify -pedantic %s // RUN: not %clang_cc1 -std=c2x -fsyntax-only -verify -pedantic %s
// RUN: not %clang_cc1 -std=c2x -fsyntax-only -verify %s // RUN: not %clang_cc1 -std=c2x -fsyntax-only -verify %s
// For C++ // For C++
// RUN: %clang_cc1 -x c++ -fsyntax-only -verify=pre-cpp2b-pedantic -pedantic %s // RUN: %clang_cc1 -x c++ -fsyntax-only -verify=pre-cpp23-pedantic -pedantic %s
// RUN: %clang_cc1 -x c++ -std=c++2b -fsyntax-only -verify=pre-cpp2b-compat -Wpre-c++2b-compat %s // RUN: %clang_cc1 -x c++ -std=c++23 -fsyntax-only -verify=pre-cpp23-compat -Wpre-c++23-compat %s
// RUN: not %clang_cc1 -x c++ -fsyntax-only -verify %s // RUN: not %clang_cc1 -x c++ -fsyntax-only -verify %s
// RUN: not %clang_cc1 -x c++ -std=c++2b -fsyntax-only -verify -pedantic %s // RUN: not %clang_cc1 -x c++ -std=c++23 -fsyntax-only -verify -pedantic %s
// RUN: not %clang_cc1 -x c++ -std=c++2b -fsyntax-only -verify %s // RUN: not %clang_cc1 -x c++ -std=c++23 -fsyntax-only -verify %s
int x; int x;
#if 1 #if 1
#elifdef A // #1 #elifdef A // #1
#endif #endif
// For C // For C
// pre-c2x-pedantic-warning@#1 {{use of a '#elifdef' directive is a C2x extension}} // pre-c2x-pedantic-warning@#1 {{use of a '#elifdef' directive is a C2x extension}}
// pre-c2x-compat-warning@#1 {{use of a '#elifdef' directive is incompatible with C standards before C2x}} // pre-c2x-compat-warning@#1 {{use of a '#elifdef' directive is incompatible with C standards before C2x}}
// For C++ // For C++
// pre-cpp2b-pedantic-warning@#1 {{use of a '#elifdef' directive is a C++2b extension}} // pre-cpp23-pedantic-warning@#1 {{use of a '#elifdef' directive is a C++23 extension}}
// pre-cpp2b-compat-warning@#1 {{use of a '#elifdef' directive is incompatible with C++ standards before C++2b}} // pre-cpp23-compat-warning@#1 {{use of a '#elifdef' directive is incompatible with C++ standards before C++23}}
#if 1 #if 1
#elifndef B // #2 #elifndef B // #2
#endif #endif
// For C // For C
// pre-c2x-pedantic-warning@#2 {{use of a '#elifndef' directive is a C2x extension}} // pre-c2x-pedantic-warning@#2 {{use of a '#elifndef' directive is a C2x extension}}
// pre-c2x-compat-warning@#2 {{use of a '#elifndef' directive is incompatible with C standards before C2x}} // pre-c2x-compat-warning@#2 {{use of a '#elifndef' directive is incompatible with C standards before C2x}}
// For C++ // For C++
// pre-cpp2b-pedantic-warning@#2 {{use of a '#elifndef' directive is a C++2b extension}} // pre-cpp23-pedantic-warning@#2 {{use of a '#elifndef' directive is a C++23 extension}}
// pre-cpp2b-compat-warning@#2 {{use of a '#elifndef' directive is incompatible with C++ standards before C++2b}} // pre-cpp23-compat-warning@#2 {{use of a '#elifndef' directive is incompatible with C++ standards before C++23}}
#if 0 #if 0
#elifdef C #elifdef C
#endif #endif
// For C // For C
// pre-c2x-pedantic-warning@-3 {{use of a '#elifdef' directive is a C2x extension}} // pre-c2x-pedantic-warning@-3 {{use of a '#elifdef' directive is a C2x extension}}
// pre-c2x-compat-warning@-4 {{use of a '#elifdef' directive is incompatible with C standards before C2x}} // pre-c2x-compat-warning@-4 {{use of a '#elifdef' directive is incompatible with C standards before C2x}}
// For C++ // For C++
// pre-cpp2b-pedantic-warning@-7 {{use of a '#elifdef' directive is a C++2b extension}} // pre-cpp23-pedantic-warning@-7 {{use of a '#elifdef' directive is a C++23 extension}}
// pre-cpp2b-compat-warning@-8 {{use of a '#elifdef' directive is incompatible with C++ standards before C++2b}} // pre-cpp23-compat-warning@-8 {{use of a '#elifdef' directive is incompatible with C++ standards before C++23}}
#if 0 #if 0
#elifndef D #elifndef D
#endif #endif
// For C // For C
// pre-c2x-pedantic-warning@-3 {{use of a '#elifndef' directive is a C2x extension}} // pre-c2x-pedantic-warning@-3 {{use of a '#elifndef' directive is a C2x extension}}
// pre-c2x-compat-warning@-4 {{use of a '#elifndef' directive is incompatible with C standards before C2x}} // pre-c2x-compat-warning@-4 {{use of a '#elifndef' directive is incompatible with C standards before C2x}}
// For C++ // For C++
// pre-cpp2b-pedantic-warning@-7 {{use of a '#elifndef' directive is a C++2b extension}} // pre-cpp23-pedantic-warning@-7 {{use of a '#elifndef' directive is a C++23 extension}}
// pre-cpp2b-compat-warning@-8 {{use of a '#elifndef' directive is incompatible with C++ standards before C++2b}} // pre-cpp23-compat-warning@-8 {{use of a '#elifndef' directive is incompatible with C++ standards before C++23}}
#warning foo #warning foo
// For C // For C
// pre-c2x-pedantic-warning@-2 {{#warning is a C2x extension}} // pre-c2x-pedantic-warning@-2 {{#warning is a C2x extension}}
// pre-c2x-pedantic-warning@-3 {{foo}} // pre-c2x-pedantic-warning@-3 {{foo}}
// pre-c2x-compat-warning@-4 {{#warning is incompatible with C standards before C2x}} // pre-c2x-compat-warning@-4 {{#warning is incompatible with C standards before C2x}}
// pre-c2x-compat-warning@-5 {{foo}} // pre-c2x-compat-warning@-5 {{foo}}
// For C++ // For C++
// pre-cpp2b-pedantic-warning@-8 {{#warning is a C++2b extension}} // pre-cpp23-pedantic-warning@-8 {{#warning is a C++23 extension}}
// pre-cpp2b-pedantic-warning@-9 {{foo}} // pre-cpp23-pedantic-warning@-9 {{foo}}
// pre-cpp2b-compat-warning@-10 {{#warning is incompatible with C++ standards before C++2b}} // pre-cpp23-compat-warning@-10 {{#warning is incompatible with C++ standards before C++23}}
// pre-cpp2b-compat-warning@-11 {{foo}} // pre-cpp23-compat-warning@-11 {{foo}}

clang/test/Preprocessor/init.c

// RUN: %clang_cc1 -E -dM -x assembler-with-cpp < /dev/null | FileCheck -match-full-lines -check-prefix ASM %s // RUN: %clang_cc1 -E -dM -x assembler-with-cpp < /dev/null | FileCheck -match-full-lines -check-prefix ASM %s
// //
// ASM:#define __ASSEMBLER__ 1 // ASM:#define __ASSEMBLER__ 1
// //
// //
// RUN: %clang_cc1 -fblocks -E -dM < /dev/null | FileCheck -match-full-lines -check-prefix BLOCKS %s // RUN: %clang_cc1 -fblocks -E -dM < /dev/null | FileCheck -match-full-lines -check-prefix BLOCKS %s
// //
// BLOCKS:#define __BLOCKS__ 1 // BLOCKS:#define __BLOCKS__ 1
// BLOCKS:#define __block __attribute__((__blocks__(byref))) // BLOCKS:#define __block __attribute__((__blocks__(byref)))
// //
// //
// RUN: %clang_cc1 -x c++ -fgnuc-version=4.2.1 -std=c++2b -E -dM < /dev/null | FileCheck -match-full-lines -check-prefix CXX2B %s // RUN: %clang_cc1 -x c++ -fgnuc-version=4.2.1 -std=c++23 -E -dM < /dev/null | FileCheck -match-full-lines -check-prefix CXX2B %s
// //
// CXX2B:#define __GNUG__ 4 // CXX2B:#define __GNUG__ 4
// CXX2B:#define __GXX_EXPERIMENTAL_CXX0X__ 1 // CXX2B:#define __GXX_EXPERIMENTAL_CXX0X__ 1
// CXX2B:#define __GXX_RTTI 1 // CXX2B:#define __GXX_RTTI 1
// CXX2B:#define __GXX_WEAK__ 1 // CXX2B:#define __GXX_WEAK__ 1
// CXX2B:#define __cplusplus 202101L // CXX2B:#define __cplusplus 202101L
// CXX2B:#define __private_extern__ extern // CXX2B:#define __private_extern__ extern
// //
▲ Show 20 Lines • Show All 107 Lines • ▼ Show 20 Lines
// RUN: %clang_cc1 -E -dM -triple=x86_64-apple-darwin < /dev/null | FileCheck -match-full-lines -check-prefix C-DEFAULT %s // RUN: %clang_cc1 -E -dM -triple=x86_64-apple-darwin < /dev/null | FileCheck -match-full-lines -check-prefix C-DEFAULT %s
// RUN: %clang_cc1 -E -dM -triple=armv7a-apple-darwin < /dev/null | FileCheck -match-full-lines -check-prefix C-DEFAULT %s // RUN: %clang_cc1 -E -dM -triple=armv7a-apple-darwin < /dev/null | FileCheck -match-full-lines -check-prefix C-DEFAULT %s
// //
// C-DEFAULT:#define __STDC_VERSION__ 201710L // C-DEFAULT:#define __STDC_VERSION__ 201710L
// //
// RUN: %clang_cc1 -ffreestanding -E -dM < /dev/null | FileCheck -match-full-lines -check-prefix FREESTANDING %s // RUN: %clang_cc1 -ffreestanding -E -dM < /dev/null | FileCheck -match-full-lines -check-prefix FREESTANDING %s
// FREESTANDING:#define __STDC_HOSTED__ 0 // FREESTANDING:#define __STDC_HOSTED__ 0
// //
// RUN: %clang_cc1 -x c++ -fgnuc-version=4.2.1 -std=gnu++2b -E -dM < /dev/null | FileCheck -match-full-lines -check-prefix GXX2B %s // RUN: %clang_cc1 -x c++ -fgnuc-version=4.2.1 -std=gnu++23 -E -dM < /dev/null | FileCheck -match-full-lines -check-prefix GXX2B %s
// //
// GXX2B:#define __GNUG__ 4 // GXX2B:#define __GNUG__ 4
// GXX2B:#define __GXX_WEAK__ 1 // GXX2B:#define __GXX_WEAK__ 1
// GXX2B:#define __cplusplus 202101L // GXX2B:#define __cplusplus 202101L
// GXX2B:#define __private_extern__ extern // GXX2B:#define __private_extern__ extern
// //
// 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++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 // 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
▲ Show 20 Lines • Show All 2,462 Lines • Show Last 20 Lines

clang/test/Preprocessor/macro_vaopt_check.cpp

// RUN: %clang_cc1 %s -Eonly -verify -Wno-all -Wno-c++2b-extensions -pedantic -std=c++20 // RUN: %clang_cc1 %s -Eonly -verify -Wno-all -Wno-c++23-extensions -pedantic -std=c++20
// RUN: %clang_cc1 %s -Eonly -verify -Wno-all -Wno-c++2b-extensions -pedantic -std=c++11 // RUN: %clang_cc1 %s -Eonly -verify -Wno-all -Wno-c++23-extensions -pedantic -std=c++11
// RUN: %clang_cc1 -x c %s -Eonly -verify -Wno-all -Wno-c2x-extensions -pedantic -std=c99 // RUN: %clang_cc1 -x c %s -Eonly -verify -Wno-all -Wno-c2x-extensions -pedantic -std=c99
//expected-error@+1{{missing '('}} //expected-error@+1{{missing '('}}
#define V1(...) __VA_OPT__ #define V1(...) __VA_OPT__
#undef V1 #undef V1
// OK // OK
#define V1(...) __VA_OPT__ () #define V1(...) __VA_OPT__ ()
#undef V1 #undef V1
▲ Show 20 Lines • Show All 66 Lines • Show Last 20 Lines

clang/test/Preprocessor/predefined-win-macros.c

Show First 20 Lines • Show All 46 Lines • ▼ Show 20 Lines
// CHECK-MS-NOT: GXX // CHECK-MS-NOT: GXX
// RUN: %clang_cc1 %s -x c++ -E -dM -triple i686-pc-win32 -fms-extensions -fms-compatibility \ // RUN: %clang_cc1 %s -x c++ -E -dM -triple i686-pc-win32 -fms-extensions -fms-compatibility \
// RUN: -fms-compatibility-version=19.00 -std=c++20 -o - | FileCheck -match-full-lines %s --check-prefix=CHECK-MS-CPP20 // RUN: -fms-compatibility-version=19.00 -std=c++20 -o - | FileCheck -match-full-lines %s --check-prefix=CHECK-MS-CPP20
// CHECK-MS-CPP20: #define _MSC_VER 1900 // CHECK-MS-CPP20: #define _MSC_VER 1900
// CHECK-MS-CPP20: #define _MSVC_LANG 202002L // CHECK-MS-CPP20: #define _MSVC_LANG 202002L
// RUN: %clang_cc1 %s -x c++ -E -dM -triple i686-pc-win32 -fms-extensions -fms-compatibility \ // RUN: %clang_cc1 %s -x c++ -E -dM -triple i686-pc-win32 -fms-extensions -fms-compatibility \
// RUN: -fms-compatibility-version=19.00 -std=c++2b -o - | FileCheck -match-full-lines %s --check-prefix=CHECK-MS-CPP2B // RUN: -fms-compatibility-version=19.00 -std=c++23 -o - | FileCheck -match-full-lines %s --check-prefix=CHECK-MS-CPP2B
// CHECK-MS-CPP2B: #define _MSC_VER 1900 // CHECK-MS-CPP2B: #define _MSC_VER 1900
// CHECK-MS-CPP2B: #define _MSVC_LANG 202004L // CHECK-MS-CPP2B: #define _MSVC_LANG 202004L
// RUN: %clang_cc1 -triple i386-windows %s -E -dM -o - \ // RUN: %clang_cc1 -triple i386-windows %s -E -dM -o - \
// RUN: | FileCheck -match-full-lines %s --check-prefix=CHECK-X86-WIN // RUN: | FileCheck -match-full-lines %s --check-prefix=CHECK-X86-WIN
// CHECK-X86-WIN-NOT: #define WIN32 1 // CHECK-X86-WIN-NOT: #define WIN32 1
// CHECK-X86-WIN-NOT: #define WIN64 1 // CHECK-X86-WIN-NOT: #define WIN64 1
▲ Show 20 Lines • Show All 70 Lines • Show Last 20 Lines

clang/test/Preprocessor/suggest-typoed-directive.c

// RUN: %clang_cc1 -fsyntax-only -verify=pre-c2x-cpp2b %s // RUN: %clang_cc1 -fsyntax-only -verify=pre-c2x-cpp23 %s
// RUN: %clang_cc1 -std=c2x -fsyntax-only -verify=c2x-cpp2b %s // RUN: %clang_cc1 -std=c2x -fsyntax-only -verify=c2x-cpp23 %s
// RUN: %clang_cc1 -x c++ -std=c++2b -fsyntax-only -verify=c2x-cpp2b %s // RUN: %clang_cc1 -x c++ -std=c++23 -fsyntax-only -verify=c2x-cpp23 %s
// RUN: %clang_cc1 -x c++ -std=c++2b -fsyntax-only %s -fdiagnostics-parseable-fixits 2>&1 | FileCheck %s // RUN: %clang_cc1 -x c++ -std=c++23 -fsyntax-only %s -fdiagnostics-parseable-fixits 2>&1 | FileCheck %s
// id: pre-c2x-cpp2b-warning@+12 {{invalid preprocessing directive, did you mean '#if'?}} // id: pre-c2x-cpp23-warning@+12 {{invalid preprocessing directive, did you mean '#if'?}}
// ifd: pre-c2x-cpp2b-warning@+12 {{invalid preprocessing directive, did you mean '#if'?}} // ifd: pre-c2x-cpp23-warning@+12 {{invalid preprocessing directive, did you mean '#if'?}}
// ifde: pre-c2x-cpp2b-warning@+12 {{invalid preprocessing directive, did you mean '#ifdef'?}} // ifde: pre-c2x-cpp23-warning@+12 {{invalid preprocessing directive, did you mean '#ifdef'?}}
// elf: pre-c2x-cpp2b-warning@+12 {{invalid preprocessing directive, did you mean '#elif'?}} // elf: pre-c2x-cpp23-warning@+12 {{invalid preprocessing directive, did you mean '#elif'?}}
// elsif: pre-c2x-cpp2b-warning@+12 {{invalid preprocessing directive, did you mean '#elif'?}} // elsif: pre-c2x-cpp23-warning@+12 {{invalid preprocessing directive, did you mean '#elif'?}}
// elseif: pre-c2x-cpp2b-warning@+12 {{invalid preprocessing directive, did you mean '#elif'?}} // elseif: pre-c2x-cpp23-warning@+12 {{invalid preprocessing directive, did you mean '#elif'?}}
// elfidef: not suggested to '#elifdef' // elfidef: not suggested to '#elifdef'
// elfindef: not suggested to '#elifdef' // elfindef: not suggested to '#elifdef'
// elfinndef: not suggested to '#elifndef' // elfinndef: not suggested to '#elifndef'
// els: pre-c2x-cpp2b-warning@+12 {{invalid preprocessing directive, did you mean '#else'?}} // els: pre-c2x-cpp23-warning@+12 {{invalid preprocessing directive, did you mean '#else'?}}
// endi: pre-c2x-cpp2b-warning@+12 {{invalid preprocessing directive, did you mean '#endif'?}} // endi: pre-c2x-cpp23-warning@+12 {{invalid preprocessing directive, did you mean '#endif'?}}
#ifdef UNDEFINED #ifdef UNDEFINED
#id #id
#ifd #ifd
#ifde #ifde
# elf # elf
# elsif # elsif
#elseif #elseif
#elfidef #elfidef
#elfindef #elfindef
#elfinndef #elfinndef
#els #els
#endi #endi
#endif #endif
// id: c2x-cpp2b-warning@-12 {{invalid preprocessing directive, did you mean '#if'?}} // id: c2x-cpp23-warning@-12 {{invalid preprocessing directive, did you mean '#if'?}}
// ifd: c2x-cpp2b-warning@-12 {{invalid preprocessing directive, did you mean '#if'?}} // ifd: c2x-cpp23-warning@-12 {{invalid preprocessing directive, did you mean '#if'?}}
// ifde: c2x-cpp2b-warning@-12 {{invalid preprocessing directive, did you mean '#ifdef'?}} // ifde: c2x-cpp23-warning@-12 {{invalid preprocessing directive, did you mean '#ifdef'?}}
// elf: c2x-cpp2b-warning@-12 {{invalid preprocessing directive, did you mean '#elif'?}} // elf: c2x-cpp23-warning@-12 {{invalid preprocessing directive, did you mean '#elif'?}}
// elsif: c2x-cpp2b-warning@-12 {{invalid preprocessing directive, did you mean '#elif'?}} // elsif: c2x-cpp23-warning@-12 {{invalid preprocessing directive, did you mean '#elif'?}}
// elseif: c2x-cpp2b-warning@-12 {{invalid preprocessing directive, did you mean '#elif'?}} // elseif: c2x-cpp23-warning@-12 {{invalid preprocessing directive, did you mean '#elif'?}}
// elfidef: c2x-cpp2b-warning@-12 {{invalid preprocessing directive, did you mean '#elifdef'?}} // elfidef: c2x-cpp23-warning@-12 {{invalid preprocessing directive, did you mean '#elifdef'?}}
// elfindef: c2x-cpp2b-warning@-12 {{invalid preprocessing directive, did you mean '#elifdef'?}} // elfindef: c2x-cpp23-warning@-12 {{invalid preprocessing directive, did you mean '#elifdef'?}}
// elfinndef: c2x-cpp2b-warning@-12 {{invalid preprocessing directive, did you mean '#elifndef'?}} // elfinndef: c2x-cpp23-warning@-12 {{invalid preprocessing directive, did you mean '#elifndef'?}}
// els: c2x-cpp2b-warning@-12 {{invalid preprocessing directive, did you mean '#else'?}} // els: c2x-cpp23-warning@-12 {{invalid preprocessing directive, did you mean '#else'?}}
// endi: c2x-cpp2b-warning@-12 {{invalid preprocessing directive, did you mean '#endif'?}} // endi: c2x-cpp23-warning@-12 {{invalid preprocessing directive, did you mean '#endif'?}}
// CHECK: fix-it:{{.*}}:{[[@LINE-24]]:2-[[@LINE-24]]:4}:"if" // CHECK: fix-it:{{.*}}:{[[@LINE-24]]:2-[[@LINE-24]]:4}:"if"
// CHECK: fix-it:{{.*}}:{[[@LINE-24]]:2-[[@LINE-24]]:5}:"if" // CHECK: fix-it:{{.*}}:{[[@LINE-24]]:2-[[@LINE-24]]:5}:"if"
// CHECK: fix-it:{{.*}}:{[[@LINE-24]]:2-[[@LINE-24]]:6}:"ifdef" // CHECK: fix-it:{{.*}}:{[[@LINE-24]]:2-[[@LINE-24]]:6}:"ifdef"
// CHECK: fix-it:{{.*}}:{[[@LINE-24]]:3-[[@LINE-24]]:6}:"elif" // CHECK: fix-it:{{.*}}:{[[@LINE-24]]:3-[[@LINE-24]]:6}:"elif"
// CHECK: fix-it:{{.*}}:{[[@LINE-24]]:4-[[@LINE-24]]:9}:"elif" // CHECK: fix-it:{{.*}}:{[[@LINE-24]]:4-[[@LINE-24]]:9}:"elif"
// CHECK: fix-it:{{.*}}:{[[@LINE-24]]:2-[[@LINE-24]]:8}:"elif" // CHECK: fix-it:{{.*}}:{[[@LINE-24]]:2-[[@LINE-24]]:8}:"elif"
// CHECK: fix-it:{{.*}}:{[[@LINE-24]]:2-[[@LINE-24]]:9}:"elifdef" // CHECK: fix-it:{{.*}}:{[[@LINE-24]]:2-[[@LINE-24]]:9}:"elifdef"
Show All 12 Lines

clang/test/Preprocessor/ucn-pp-identifier.c

// RUN: %clang_cc1 %s -fsyntax-only -std=c99 -pedantic -verify=expected,ext -Wundef -DTRIGRAPHS=1 // RUN: %clang_cc1 %s -fsyntax-only -std=c99 -pedantic -verify=expected,ext -Wundef -DTRIGRAPHS=1
// RUN: %clang_cc1 %s -fsyntax-only -x c++ -pedantic -verify=expected,ext -Wundef -fno-trigraphs // RUN: %clang_cc1 %s -fsyntax-only -x c++ -pedantic -verify=expected,ext -Wundef -fno-trigraphs
// RUN: %clang_cc1 %s -fsyntax-only -x c++ -std=c++2b -pedantic -ftrigraphs -DTRIGRAPHS=1 -verify=expected,cxx2b -Wundef -Wpre-c++2b-compat // RUN: %clang_cc1 %s -fsyntax-only -x c++ -std=c++23 -pedantic -ftrigraphs -DTRIGRAPHS=1 -verify=expected,cxx23 -Wundef -Wpre-c++23-compat
// RUN: %clang_cc1 %s -fsyntax-only -x c++ -pedantic -verify=expected,ext -Wundef -ftrigraphs -DTRIGRAPHS=1 // RUN: %clang_cc1 %s -fsyntax-only -x c++ -pedantic -verify=expected,ext -Wundef -ftrigraphs -DTRIGRAPHS=1
// RUN: not %clang_cc1 %s -fsyntax-only -std=c99 -pedantic -Wundef 2>&1 | FileCheck -strict-whitespace %s // RUN: not %clang_cc1 %s -fsyntax-only -std=c99 -pedantic -Wundef 2>&1 | FileCheck -strict-whitespace %s
#define \u00FC #define \u00FC
#define a\u00FD() 0 #define a\u00FD() 0
#ifndef \u00FC #ifndef \u00FC
#error "This should never happen" #error "This should never happen"
#endif #endif
#if a\u00FD() #if a\u00FD()
#error "This should never happen" #error "This should never happen"
#endif #endif
#if a\U000000FD() #if a\U000000FD()
#error "This should never happen" #error "This should never happen"
#endif #endif
#if a\u{FD}() // ext-warning {{extension}} cxx2b-warning {{before C++2b}} #if a\u{FD}() // ext-warning {{extension}} cxx23-warning {{before C++23}}
#error "This should never happen" #error "This should never happen"
#endif #endif
#if \uarecool // expected-warning{{incomplete universal character name; treating as '\' followed by identifier}} expected-error {{invalid token at start of a preprocessor expression}} #if \uarecool // expected-warning{{incomplete universal character name; treating as '\' followed by identifier}} expected-error {{invalid token at start of a preprocessor expression}}
#endif #endif
#if \uwerecool // expected-warning{{\u used with no following hex digits; treating as '\' followed by identifier}} expected-error {{invalid token at start of a preprocessor expression}} #if \uwerecool // expected-warning{{\u used with no following hex digits; treating as '\' followed by identifier}} expected-error {{invalid token at start of a preprocessor expression}}
#endif #endif
#if \U0001000 // expected-warning{{incomplete universal character name; treating as '\' followed by identifier}} expected-error {{invalid token at start of a preprocessor expression}} #if \U0001000 // expected-warning{{incomplete universal character name; treating as '\' followed by identifier}} expected-error {{invalid token at start of a preprocessor expression}}
#endif #endif
// Make sure we reject disallowed UCNs // Make sure we reject disallowed UCNs
#define \ufffe // expected-error {{macro name must be an identifier}} #define \ufffe // expected-error {{macro name must be an identifier}}
#define \U10000000 // expected-error {{macro name must be an identifier}} #define \U10000000 // expected-error {{macro name must be an identifier}}
#define \u0061 // expected-error {{character 'a' cannot be specified by a universal character name}} expected-error {{macro name must be an identifier}} #define \u0061 // expected-error {{character 'a' cannot be specified by a universal character name}} expected-error {{macro name must be an identifier}}
#define \u{fffe} // expected-error {{macro name must be an identifier}} \ #define \u{fffe} // expected-error {{macro name must be an identifier}} \
// ext-warning {{extension}} cxx2b-warning {{before C++2b}} // ext-warning {{extension}} cxx23-warning {{before C++23}}
#define \N{ALERT} // expected-error {{universal character name refers to a control character}} \ #define \N{ALERT} // expected-error {{universal character name refers to a control character}} \
// expected-error {{macro name must be an identifier}} \ // expected-error {{macro name must be an identifier}} \
// ext-warning {{extension}} cxx2b-warning {{before C++2b}} // ext-warning {{extension}} cxx23-warning {{before C++23}}
#define \N{WASTEBASKET} // expected-error {{macro name must be an identifier}} \ #define \N{WASTEBASKET} // expected-error {{macro name must be an identifier}} \
// ext-warning {{extension}} cxx2b-warning {{before C++2b}} // ext-warning {{extension}} cxx23-warning {{before C++23}}
#define a\u0024 #define a\u0024
#if \u0110 // expected-warning {{is not defined, evaluates to 0}} #if \u0110 // expected-warning {{is not defined, evaluates to 0}}
#endif #endif
#define \u0110 1 / 0 #define \u0110 1 / 0
#if \u0110 // expected-error {{division by zero in preprocessor expression}} #if \u0110 // expected-error {{division by zero in preprocessor expression}}
▲ Show 20 Lines • Show All 85 Lines • ▼ Show 20 Lines
#define CONCAT(A, B) A##B #define CONCAT(A, B) A##B
int CONCAT(\N{GREEK int CONCAT(\N{GREEK
, CAPITALLETTERALPHA}); , CAPITALLETTERALPHA});
// expected-error@-2 {{expected}} \ // expected-error@-2 {{expected}} \
// expected-warning@-2 {{incomplete delimited universal character name}} // expected-warning@-2 {{incomplete delimited universal character name}}
int \N{\ int \N{\
LATIN CAPITAL LETTER A WITH GRAVE}; LATIN CAPITAL LETTER A WITH GRAVE};
//ext-warning@-2 {{extension}} cxx2b-warning@-2 {{before C++2b}} //ext-warning@-2 {{extension}} cxx23-warning@-2 {{before C++23}}
#ifdef TRIGRAPHS #ifdef TRIGRAPHS
int \N??<GREEK CAPITAL LETTER ALPHA??> = 0; // cxx2b-warning {{before C++2b}} \ int \N??<GREEK CAPITAL LETTER ALPHA??> = 0; // cxx23-warning {{before C++23}} \
//ext-warning {{extension}}\ //ext-warning {{extension}}\
// expected-warning 2{{trigraph converted}} // expected-warning 2{{trigraph converted}}
int a\N{LATIN CAPITAL LETTER A WITH GRAVE??>; // expected-warning {{trigraph converted}} int a\N{LATIN CAPITAL LETTER A WITH GRAVE??>; // expected-warning {{trigraph converted}}
#endif #endif
#ifndef TRIGRAPHS #ifndef TRIGRAPHS
int a\N{LATIN CAPITAL LETTER A WITH GRAVE??>; int a\N{LATIN CAPITAL LETTER A WITH GRAVE??>;
// expected-warning@-1 {{trigraph ignored}}\ // expected-warning@-1 {{trigraph ignored}}\
// expected-warning@-1 {{incomplete}}\ // expected-warning@-1 {{incomplete}}\
// expected-error@-1 {{expected ';' after top level declarator}} // expected-error@-1 {{expected ';' after top level declarator}}
#endif #endif

clang/test/Sema/gnu-asm-pmf.cpp

// RUN: %clang_cc1 -triple x86_64-unknown-windows-msvc -std=c++2b -fsyntax-only %s -verify // RUN: %clang_cc1 -triple x86_64-unknown-windows-msvc -std=c++23 -fsyntax-only %s -verify
// RUN: %clang_cc1 -triple x86_64-unknown-windows-itanium -std=c++2b -fsyntax-only %s -verify // RUN: %clang_cc1 -triple x86_64-unknown-windows-itanium -std=c++23 -fsyntax-only %s -verify
struct S { struct S {
void operator()(); void operator()();
}; };
struct T { struct T {
virtual void operator()(); virtual void operator()();
}; };
Show All 39 Lines

clang/test/Sema/stmtexpr-init.c

// RUN: %clang_cc1 -verify -fsyntax-only %s // RUN: %clang_cc1 -verify -fsyntax-only %s
static int *z[1] = {({ static int _x = 70; &_x; })}; // expected-error {{statement expression not allowed at file scope}} static int *z[1] = {({ static int _x = 70; &_x; })}; // expected-error {{statement expression not allowed at file scope}}
void T1(void) { void T1(void) {
int *x[1] = {({ static int _x = 10; &_x; })}; // expected-no-error int *x[1] = {({ static int _x = 10; &_x; })}; // expected-no-error
/* Before commit /* Before commit
683e83c5 [Clang][C++2b] P2242R3: Non-literal variables [...] in constexpr 683e83c5 [Clang][C++23] P2242R3: Non-literal variables [...] in constexpr
(i.e in clang-14 and earlier) (i.e in clang-14 and earlier)
this was silently accepted, but generated incorrect code. this was silently accepted, but generated incorrect code.
*/ */
static int *y[1] = {({ static int _x = 20; &_x; })}; // expected-error {{initializer element is not a compile-time constant}} static int *y[1] = {({ static int _x = 20; &_x; })}; // expected-error {{initializer element is not a compile-time constant}}
} }

clang/test/SemaCXX/P1155.cpp

// RUN: %clang_cc1 -std=c++2b -fsyntax-only -fcxx-exceptions -verify %s // RUN: %clang_cc1 -std=c++23 -fsyntax-only -fcxx-exceptions -verify %s
// RUN: %clang_cc1 -std=c++20 -fsyntax-only -fcxx-exceptions -verify %s // RUN: %clang_cc1 -std=c++20 -fsyntax-only -fcxx-exceptions -verify %s
// RUN: %clang_cc1 -std=c++11 -fsyntax-only -fcxx-exceptions -verify %s // RUN: %clang_cc1 -std=c++11 -fsyntax-only -fcxx-exceptions -verify %s
// expected-no-diagnostics // expected-no-diagnostics
// Throwing // Throwing
namespace test_throwing { namespace test_throwing {
class Widget { class Widget {
public: public:
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

clang/test/SemaCXX/constant-expression-cxx11.cpp

// RUN: %clang_cc1 -std=c++2b -fsyntax-only -verify=expected,cxx20_2b,cxx2b -triple x86_64-linux -Wno-string-plus-int -Wno-pointer-arith -Wno-zero-length-array -Wno-c99-designator -fcxx-exceptions -pedantic %s -Wno-comment -Wno-tautological-pointer-compare -Wno-bool-conversion // RUN: %clang_cc1 -std=c++23 -fsyntax-only -verify=expected,cxx20_23,cxx23 -triple x86_64-linux -Wno-string-plus-int -Wno-pointer-arith -Wno-zero-length-array -Wno-c99-designator -fcxx-exceptions -pedantic %s -Wno-comment -Wno-tautological-pointer-compare -Wno-bool-conversion
// RUN: %clang_cc1 -std=c++20 -fsyntax-only -verify=expected,cxx11_20,cxx20_2b -triple x86_64-linux -Wno-string-plus-int -Wno-pointer-arith -Wno-zero-length-array -Wno-c99-designator -fcxx-exceptions -pedantic %s -Wno-comment -Wno-tautological-pointer-compare -Wno-bool-conversion // RUN: %clang_cc1 -std=c++20 -fsyntax-only -verify=expected,cxx11_20,cxx20_23 -triple x86_64-linux -Wno-string-plus-int -Wno-pointer-arith -Wno-zero-length-array -Wno-c99-designator -fcxx-exceptions -pedantic %s -Wno-comment -Wno-tautological-pointer-compare -Wno-bool-conversion
// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify=expected,cxx11_20,cxx11 -triple x86_64-linux -Wno-string-plus-int -Wno-pointer-arith -Wno-zero-length-array -Wno-c99-designator -fcxx-exceptions -pedantic %s -Wno-comment -Wno-tautological-pointer-compare -Wno-bool-conversion // RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify=expected,cxx11_20,cxx11 -triple x86_64-linux -Wno-string-plus-int -Wno-pointer-arith -Wno-zero-length-array -Wno-c99-designator -fcxx-exceptions -pedantic %s -Wno-comment -Wno-tautological-pointer-compare -Wno-bool-conversion
namespace StaticAssertFoldTest { namespace StaticAssertFoldTest {
int x; int x;
static_assert(++x, "test"); // expected-error {{not an integral constant expression}} static_assert(++x, "test"); // expected-error {{not an integral constant expression}}
// cxx20_2b-note@-1 {{cannot modify an object that is visible outside that expression}} // cxx20_23-note@-1 {{cannot modify an object that is visible outside that expression}}
static_assert(false, "test"); // expected-error {{test}} static_assert(false, "test"); // expected-error {{test}}
} }
int array[(long)(char *)0]; // expected-warning {{variable length arrays are a C99 feature}} \ int array[(long)(char *)0]; // expected-warning {{variable length arrays are a C99 feature}} \
// expected-warning {{variable length array folded to constant array as an extension}} \ // expected-warning {{variable length array folded to constant array as an extension}} \
// expected-note {{cast that performs the conversions of a reinterpret_cast is not allowed in a constant expression}} // expected-note {{cast that performs the conversions of a reinterpret_cast is not allowed in a constant expression}}
▲ Show 20 Lines • Show All 337 Lines • ▼ Show 20 Lines int g : (S*)(void*)(sptr) == sptr; // \
expected-warning {{not an integral constant expression}} \ expected-warning {{not an integral constant expression}} \
expected-note {{cast from 'void *' is not allowed in a constant expression}} expected-note {{cast from 'void *' is not allowed in a constant expression}}
}; };
extern char externalvar[]; extern char externalvar[];
constexpr bool constaddress = (void *)externalvar == (void *)0x4000UL; // expected-error {{must be initialized by a constant expression}} expected-note {{reinterpret_cast}} constexpr bool constaddress = (void *)externalvar == (void *)0x4000UL; // expected-error {{must be initialized by a constant expression}} expected-note {{reinterpret_cast}}
constexpr bool litaddress = "foo" == "foo"; // expected-error {{must be initialized by a constant expression}} constexpr bool litaddress = "foo" == "foo"; // expected-error {{must be initialized by a constant expression}}
// expected-note@-1 {{comparison of addresses of literals has unspecified value}} // expected-note@-1 {{comparison of addresses of literals has unspecified value}}
// cxx20_2b-warning@-2 {{comparison between two arrays is deprecated}} // cxx20_23-warning@-2 {{comparison between two arrays is deprecated}}
static_assert(0 != "foo", ""); static_assert(0 != "foo", "");
} }
namespace MaterializeTemporary { namespace MaterializeTemporary {
constexpr int f(const int &r) { return r; } constexpr int f(const int &r) { return r; }
constexpr int n = f(1); constexpr int n = f(1);
▲ Show 20 Lines • Show All 1,400 Lines • ▼ Show 20 Lines#undef ASSERT
// expected-note{{in call to 'get(arr, 0)'}} // expected-note{{in call to 'get(arr, 0)'}}
} }
namespace std { struct type_info; } namespace std { struct type_info; }
namespace TypeId { namespace TypeId {
struct A { virtual ~A(); }; struct A { virtual ~A(); };
A f(); A f();
A &g(); // cxx20_2b-note {{declared here}} A &g(); // cxx20_23-note {{declared here}}
constexpr auto &x = typeid(f()); constexpr auto &x = typeid(f());
constexpr auto &y = typeid(g()); // expected-error{{constant expression}} constexpr auto &y = typeid(g()); // expected-error{{constant expression}}
// cxx11-note@-1 {{typeid applied to expression of polymorphic type 'A' is not allowed in a constant expression}} // cxx11-note@-1 {{typeid applied to expression of polymorphic type 'A' is not allowed in a constant expression}}
// expected-warning@-2 {{expression with side effects will be evaluated despite being used as an operand to 'typeid'}} // expected-warning@-2 {{expression with side effects will be evaluated despite being used as an operand to 'typeid'}}
// cxx20_2b-note@-3 {{non-constexpr function 'g' cannot be used in a constant expression}} // cxx20_23-note@-3 {{non-constexpr function 'g' cannot be used in a constant expression}}
} }
namespace PR14203 { namespace PR14203 {
struct duration { struct duration {
constexpr duration() {} constexpr duration() {}
constexpr operator int() const { return 0; } constexpr operator int() const { return 0; }
}; };
// These are valid per P0859R0 (moved as DR). // These are valid per P0859R0 (moved as DR).
▲ Show 20 Lines • Show All 122 Lines • ▼ Show 20 Linesnamespace VirtualFromBase {
}; };
// Virtual f(), not OK. // Virtual f(), not OK.
constexpr X<X<S1>> xxs1; constexpr X<X<S1>> xxs1;
constexpr X<S1> *p = const_cast<X<X<S1>>*>(&xxs1); constexpr X<S1> *p = const_cast<X<X<S1>>*>(&xxs1);
static_assert(p->f() == sizeof(X<S1>), ""); static_assert(p->f() == sizeof(X<S1>), "");
// cxx11-error@-1 {{not an integral constant expression}} // cxx11-error@-1 {{not an integral constant expression}}
// cxx11-note@-2 {{call to virtual function}} // cxx11-note@-2 {{call to virtual function}}
// cxx20_2b-error@-3 {{static assertion failed}} // cxx20_23-error@-3 {{static assertion failed}}
// cxx20_2b-note@-4 {{8 == 16}} // cxx20_23-note@-4 {{8 == 16}}
// Non-virtual f(), OK. // Non-virtual f(), OK.
constexpr X<X<S2>> xxs2; constexpr X<X<S2>> xxs2;
constexpr X<S2> *q = const_cast<X<X<S2>>*>(&xxs2); constexpr X<S2> *q = const_cast<X<X<S2>>*>(&xxs2);
static_assert(q->f() == sizeof(S2), ""); // cxx20_2b-error {{static assertion failed}} \ static_assert(q->f() == sizeof(S2), ""); // cxx20_23-error {{static assertion failed}} \
// cxx20_2b-note {{16 == 8}} // cxx20_23-note {{16 == 8}}
} }
namespace ConstexprConstructorRecovery { namespace ConstexprConstructorRecovery {
class X { class X {
public: public:
enum E : short { enum E : short {
headers = 0x1, headers = 0x1,
middlefile = 0x2, middlefile = 0x2,
Show All 9 Lines
namespace Lifetime { namespace Lifetime {
void f() { void f() {
constexpr int &n = n; // expected-error {{constant expression}} expected-note {{use of reference outside its lifetime}} expected-warning {{not yet bound to a value}} constexpr int &n = n; // expected-error {{constant expression}} expected-note {{use of reference outside its lifetime}} expected-warning {{not yet bound to a value}}
constexpr int m = m; // expected-error {{constant expression}} expected-note {{read of object outside its lifetime}} constexpr int m = m; // expected-error {{constant expression}} expected-note {{read of object outside its lifetime}}
} }
constexpr int &get(int &&n) { return n; } constexpr int &get(int &&n) { return n; }
// cxx2b-error@-1 {{non-const lvalue reference to type 'int' cannot bind to a temporary of type 'int'}} // cxx23-error@-1 {{non-const lvalue reference to type 'int' cannot bind to a temporary of type 'int'}}
constexpr int &&get_rv(int &&n) { return static_cast<int&&>(n); } constexpr int &&get_rv(int &&n) { return static_cast<int&&>(n); }
struct S { struct S {
int &&r; int &&r;
int &s; int &s;
int t; int t;
constexpr S() : r(get_rv(0)), s(get(0)), t(r) {} // cxx11_20-note {{read of object outside its lifetime}} constexpr S() : r(get_rv(0)), s(get(0)), t(r) {} // cxx11_20-note {{read of object outside its lifetime}}
constexpr S(int) : r(get_rv(0)), s(get(0)), t(s) {} // cxx11_20-note {{read of object outside its lifetime}} constexpr S(int) : r(get_rv(0)), s(get(0)), t(s) {} // cxx11_20-note {{read of object outside its lifetime}}
}; };
▲ Show 20 Lines • Show All 310 Lines • ▼ Show 20 Lines struct { // expected-warning {{extension}}
union { // expected-warning {{extension}} union { // expected-warning {{extension}}
int n; int n;
}; };
}; };
}; };
constexpr D d(0); // cxx11-error {{constant expression}} cxx11-note {{derived class}} constexpr D d(0); // cxx11-error {{constant expression}} cxx11-note {{derived class}}
struct E : virtual A { using A::A; }; // expected-note {{here}} struct E : virtual A { using A::A; }; // expected-note {{here}}
// cxx20_2b-note@-1 {{struct with virtual base class is not a literal type}} // cxx20_23-note@-1 {{struct with virtual base class is not a literal type}}
// We wrap a function around this to avoid implicit zero-initialization // We wrap a function around this to avoid implicit zero-initialization
// happening first; the zero-initialization step would produce the same // happening first; the zero-initialization step would produce the same
// error and defeat the point of this test. // error and defeat the point of this test.
void f() { void f() {
constexpr E e(0); // cxx11-error {{constant expression}} cxx11-note {{derived class}} constexpr E e(0); // cxx11-error {{constant expression}} cxx11-note {{derived class}}
// cxx20_2b-error@-1 {{constexpr variable cannot have non-literal type}} // cxx20_23-error@-1 {{constexpr variable cannot have non-literal type}}
} }
// FIXME: This produces a note with no source location. // FIXME: This produces a note with no source location.
//constexpr E e(0); //constexpr E e(0);
struct W { constexpr W(int n) : w(n) {} int w; }; struct W { constexpr W(int n) : w(n) {} int w; };
struct X : W { using W::W; int x = 2; }; struct X : W { using W::W; int x = 2; };
struct Y : X { using X::X; int y = 3; }; struct Y : X { using X::X; int y = 3; };
struct Z : Y { using Y::Y; int z = 4; }; struct Z : Y { using Y::Y; int z = 4; };
▲ Show 20 Lines • Show All 199 Lines • Show Last 20 Lines

clang/test/SemaCXX/constant-expression-cxx14.cpp

// RUN: %clang_cc1 -std=c++2b -fsyntax-only -verify=expected,cxx20_2b,cxx2b %s -fcxx-exceptions -triple=x86_64-linux-gnu // RUN: %clang_cc1 -std=c++23 -fsyntax-only -verify=expected,cxx20_23,cxx23 %s -fcxx-exceptions -triple=x86_64-linux-gnu
// RUN: %clang_cc1 -std=c++20 -fsyntax-only -verify=expected,cxx14_20,cxx20_2b,cxx20 %s -fcxx-exceptions -triple=x86_64-linux-gnu // RUN: %clang_cc1 -std=c++20 -fsyntax-only -verify=expected,cxx14_20,cxx20_23,cxx20 %s -fcxx-exceptions -triple=x86_64-linux-gnu
// RUN: %clang_cc1 -std=c++14 -fsyntax-only -verify=expected,cxx14_20,cxx14 %s -fcxx-exceptions -triple=x86_64-linux-gnu // RUN: %clang_cc1 -std=c++14 -fsyntax-only -verify=expected,cxx14_20,cxx14 %s -fcxx-exceptions -triple=x86_64-linux-gnu
struct S { struct S {
// dummy ctor to make this a literal type // dummy ctor to make this a literal type
constexpr S(int); constexpr S(int);
S(); S();
Show All 30 Linesconstexpr int g(int k) {
const int n = 9; const int n = 9;
int k2 = k * k; int k2 = k * k;
int k3 = k2 * k; int k3 = k2 * k;
return 3 * k3 + 5 * k2 + n * k - 20; return 3 * k3 + 5 * k2 + n * k - 20;
} }
static_assert(g(2) == 42, ""); static_assert(g(2) == 42, "");
constexpr int h(int n) { // expected-error {{constexpr function never produces a constant expression}} constexpr int h(int n) { // expected-error {{constexpr function never produces a constant expression}}
static const int m = n; // expected-note {{control flows through the definition of a static variable}} \ static const int m = n; // expected-note {{control flows through the definition of a static variable}} \
// cxx14_20-warning {{definition of a static variable in a constexpr function is a C++2b extension}} // cxx14_20-warning {{definition of a static variable in a constexpr function is a C++23 extension}}
return m; return m;
} }
constexpr int i(int n) { // expected-error {{constexpr function never produces a constant expression}} constexpr int i(int n) { // expected-error {{constexpr function never produces a constant expression}}
thread_local const int m = n; // expected-note {{control flows through the definition of a thread_local variable}} \ thread_local const int m = n; // expected-note {{control flows through the definition of a thread_local variable}} \
// cxx14_20-warning {{definition of a thread_local variable in a constexpr function is a C++2b extension}} // cxx14_20-warning {{definition of a thread_local variable in a constexpr function is a C++23 extension}}
return m; return m;
} }
// if-statements can be used in constexpr functions. // if-statements can be used in constexpr functions.
constexpr int j(int k) { constexpr int j(int k) {
if (k == 5) if (k == 5)
return 1; return 1;
if (k == 1) if (k == 1)
▲ Show 20 Lines • Show All 161 Lines • ▼ Show 20 Linesnamespace subobject {
struct C : B {}; struct C : B {};
union D { constexpr D() : c() {} constexpr D(int n) : n(n) {} C c; int n; }; union D { constexpr D() : c() {} constexpr D(int n) : n(n) {} C c; int n; };
constexpr void f(D &d) { constexpr void f(D &d) {
d.c.a.y = 3; d.c.a.y = 3;
// expected-note@-1 {{cannot modify an object that is visible outside}} // expected-note@-1 {{cannot modify an object that is visible outside}}
// expected-note@-2 {{assignment to member 'c' of union with active member 'n'}} // expected-note@-2 {{assignment to member 'c' of union with active member 'n'}}
} }
constexpr bool check(D &d) { return d.c.a.y == 3; } constexpr bool check(D &d) { return d.c.a.y == 3; }
// cxx20_2b-note@-1 {{read of member 'y' of union with active member 'x'}} // cxx20_23-note@-1 {{read of member 'y' of union with active member 'x'}}
constexpr bool g() { D d; f(d); return d.c.a.y == 3; } constexpr bool g() { D d; f(d); return d.c.a.y == 3; }
static_assert(g(), ""); static_assert(g(), "");
D d; D d;
constexpr bool h() { f(d); return check(d); } // expected-note {{in call}} constexpr bool h() { f(d); return check(d); } // expected-note {{in call}}
static_assert(h(), ""); // expected-error {{constant expression}} expected-note {{in call}} static_assert(h(), ""); // expected-error {{constant expression}} expected-note {{in call}}
constexpr bool i() { D d(0); f(d); return check(d); } // expected-note {{in call}} constexpr bool i() { D d(0); f(d); return check(d); } // expected-note {{in call}}
static_assert(i(), ""); // expected-error {{constant expression}} expected-note {{in call}} static_assert(i(), ""); // expected-error {{constant expression}} expected-note {{in call}}
constexpr bool j() { D d; d.c.a.x = 3; return check(d); } // cxx14-note {{assignment to member 'x' of union with active member 'y'}} constexpr bool j() { D d; d.c.a.x = 3; return check(d); } // cxx14-note {{assignment to member 'x' of union with active member 'y'}}
// cxx20_2b-note@-1 {{in call to 'check(d)'}} // cxx20_23-note@-1 {{in call to 'check(d)'}}
static_assert(j(), ""); // expected-error {{constant expression}} expected-note {{in call}} static_assert(j(), ""); // expected-error {{constant expression}} expected-note {{in call}}
} }
namespace lifetime { namespace lifetime {
constexpr int &&id(int &&n) { return static_cast<int&&>(n); } constexpr int &&id(int &&n) { return static_cast<int&&>(n); }
constexpr int &&dead() { return id(0); } // expected-note {{temporary created here}} constexpr int &&dead() { return id(0); } // expected-note {{temporary created here}}
constexpr int bad() { int &&n = dead(); n = 1; return n; } // expected-note {{assignment to temporary whose lifetime has ended}} constexpr int bad() { int &&n = dead(); n = 1; return n; } // expected-note {{assignment to temporary whose lifetime has ended}}
static_assert(bad(), ""); // expected-error {{constant expression}} expected-note {{in call}} static_assert(bad(), ""); // expected-error {{constant expression}} expected-note {{in call}}
Show All 12 Linesnamespace null {
constexpr int test(int *p) { constexpr int test(int *p) {
return *p = 123; // expected-note {{assignment to dereferenced null pointer}} return *p = 123; // expected-note {{assignment to dereferenced null pointer}}
} }
static_assert(test(0), ""); // expected-error {{constant expression}} expected-note {{in call}} static_assert(test(0), ""); // expected-error {{constant expression}} expected-note {{in call}}
} }
namespace incdec { namespace incdec {
template<typename T> constexpr T &ref(T &&r) { return r; } template<typename T> constexpr T &ref(T &&r) { return r; }
// cxx2b-error@-1 {{non-const lvalue reference to type 'int' cannot bind to a temporary of type 'int'}} // cxx23-error@-1 {{non-const lvalue reference to type 'int' cannot bind to a temporary of type 'int'}}
template<typename T> constexpr T postinc(T &&r) { return (r++, r); } template<typename T> constexpr T postinc(T &&r) { return (r++, r); }
template<typename T> constexpr T postdec(T &&r) { return (r--, r); } template<typename T> constexpr T postdec(T &&r) { return (r--, r); }
template int &ref<int>(int &&); template int &ref<int>(int &&);
// cxx2b-note@-1 {{in instantiation of function template specialization}} // cxx23-note@-1 {{in instantiation of function template specialization}}
static_assert(postinc(0) == 1, ""); static_assert(postinc(0) == 1, "");
static_assert(postdec(0) == -1, ""); static_assert(postdec(0) == -1, "");
#if __cplusplus <= 202002L #if __cplusplus <= 202002L
static_assert(++ref(0) == 1, ""); static_assert(++ref(0) == 1, "");
static_assert(ref(0)++ == 0, ""); static_assert(ref(0)++ == 0, "");
static_assert(--ref(0) == -1, ""); static_assert(--ref(0) == -1, "");
static_assert(ref(0)-- == 0, ""); static_assert(ref(0)-- == 0, "");
▲ Show 20 Lines • Show All 52 Lines • ▼ Show 20 Lines#endif
union U { union U {
int a, b; int a, b;
}; };
constexpr int f(U u) { constexpr int f(U u) {
return ++u.b; // expected-note {{increment of member 'b' of union with active member 'a'}} return ++u.b; // expected-note {{increment of member 'b' of union with active member 'a'}}
} }
constexpr int wrong_member = f({0}); // expected-error {{constant}} expected-note {{in call to 'f({.a = 0})'}} constexpr int wrong_member = f({0}); // expected-error {{constant}} expected-note {{in call to 'f({.a = 0})'}}
constexpr int vol = --ref<volatile int>(0); // expected-error {{constant}} expected-note {{decrement of volatile-qualified}} constexpr int vol = --ref<volatile int>(0); // expected-error {{constant}} expected-note {{decrement of volatile-qualified}}
// cxx20_2b-warning@-1 {{decrement of object of volatile-qualified type 'volatile int' is deprecated}} // cxx20_23-warning@-1 {{decrement of object of volatile-qualified type 'volatile int' is deprecated}}
constexpr int incr(int k) { constexpr int incr(int k) {
int x = k; int x = k;
if (x++ == 100) if (x++ == 100)
return x; return x;
return incr(x); return incr(x);
} }
static_assert(incr(0) == 101, ""); static_assert(incr(0) == 101, "");
▲ Show 20 Lines • Show All 515 Lines • ▼ Show 20 Linesnamespace VirtualFromBase {
// Virtual f(), not OK. // Virtual f(), not OK.
constexpr X<X<S2>> xxs2; constexpr X<X<S2>> xxs2;
constexpr X<S2> *q = const_cast<X<X<S2>>*>(&xxs2); constexpr X<S2> *q = const_cast<X<X<S2>>*>(&xxs2);
static_assert(q->f() == sizeof(X<S2>), ""); // cxx14-error {{constant expression}} cxx14-note {{virtual function}} static_assert(q->f() == sizeof(X<S2>), ""); // cxx14-error {{constant expression}} cxx14-note {{virtual function}}
} }
namespace Lifetime { namespace Lifetime {
constexpr int &get(int &&r) { return r; } constexpr int &get(int &&r) { return r; }
// cxx2b-error@-1 {{non-const lvalue reference to type 'int' cannot bind to a temporary of type 'int'}} // cxx23-error@-1 {{non-const lvalue reference to type 'int' cannot bind to a temporary of type 'int'}}
constexpr int f() { constexpr int f() {
int &r = get(123); int &r = get(123);
return r; return r;
// cxx14_20-note@-1 {{read of object outside its lifetime}} // cxx14_20-note@-1 {{read of object outside its lifetime}}
} }
static_assert(f() == 123, ""); // expected-error {{constant expression}} cxx14_20-note {{in call}} static_assert(f() == 123, ""); // expected-error {{constant expression}} cxx14_20-note {{in call}}
constexpr int g() { constexpr int g() {
▲ Show 20 Lines • Show All 388 Lines • Show Last 20 Lines

clang/test/SemaCXX/constant-expression-cxx2b.cpp

// RUN: %clang_cc1 -std=c++20 -fsyntax-only -verify=expected,cxx2a %s -fcxx-exceptions -triple=x86_64-linux-gnu -Wno-c++2b-extensions // RUN: %clang_cc1 -std=c++20 -fsyntax-only -verify=expected,cxx2a %s -fcxx-exceptions -triple=x86_64-linux-gnu -Wno-c++23-extensions
// RUN: %clang_cc1 -std=c++2b -fsyntax-only -verify=expected,cxx2b %s -fcxx-exceptions -triple=x86_64-linux-gnu -Wpre-c++2b-compat // RUN: %clang_cc1 -std=c++23 -fsyntax-only -verify=expected,cxx23 %s -fcxx-exceptions -triple=x86_64-linux-gnu -Wpre-c++23-compat
struct NonLiteral { // cxx2a-note {{'NonLiteral' is not literal}} \ struct NonLiteral { // cxx2a-note {{'NonLiteral' is not literal}} \
// cxx2b-note 2{{'NonLiteral' is not literal}} // cxx23-note 2{{'NonLiteral' is not literal}}
NonLiteral() {} NonLiteral() {}
}; };
struct Constexpr{}; struct Constexpr{};
#if __cplusplus > 202002L #if __cplusplus > 202002L
constexpr int f(int n) { // expected-error {{constexpr function never produces a constant expression}} constexpr int f(int n) { // expected-error {{constexpr function never produces a constant expression}}
static const int m = n; // expected-note {{control flows through the definition of a static variable}} \ static const int m = n; // expected-note {{control flows through the definition of a static variable}} \
// cxx2b-warning {{definition of a static variable in a constexpr function is incompatible with C++ standards before C++2b}} // cxx23-warning {{definition of a static variable in a constexpr function is incompatible with C++ standards before C++23}}
return m; return m;
} }
constexpr int g(int n) { // expected-error {{constexpr function never produces a constant expression}} constexpr int g(int n) { // expected-error {{constexpr function never produces a constant expression}}
thread_local const int m = n; // expected-note {{control flows through the definition of a thread_local variable}} \ thread_local const int m = n; // expected-note {{control flows through the definition of a thread_local variable}} \
// cxx2b-warning {{definition of a thread_local variable in a constexpr function is incompatible with C++ standards before C++2b}} // cxx23-warning {{definition of a thread_local variable in a constexpr function is incompatible with C++ standards before C++23}}
return m; return m;
} }
constexpr int c_thread_local(int n) { // expected-error {{constexpr function never produces a constant expression}} constexpr int c_thread_local(int n) { // expected-error {{constexpr function never produces a constant expression}}
static _Thread_local int m = 0; // expected-note {{control flows through the definition of a thread_local variable}} \ static _Thread_local int m = 0; // expected-note {{control flows through the definition of a thread_local variable}} \
// cxx2b-warning {{definition of a static variable in a constexpr function is incompatible with C++ standards before C++2b}} // cxx23-warning {{definition of a static variable in a constexpr function is incompatible with C++ standards before C++23}}
return m; return m;
} }
constexpr int gnu_thread_local(int n) { // expected-error {{constexpr function never produces a constant expression}} constexpr int gnu_thread_local(int n) { // expected-error {{constexpr function never produces a constant expression}}
static __thread int m = 0; // expected-note {{control flows through the definition of a thread_local variable}} \ static __thread int m = 0; // expected-note {{control flows through the definition of a thread_local variable}} \
// cxx2b-warning {{definition of a static variable in a constexpr function is incompatible with C++ standards before C++2b}} // cxx23-warning {{definition of a static variable in a constexpr function is incompatible with C++ standards before C++23}}
return m; return m;
} }
constexpr int h(int n) { // expected-error {{constexpr function never produces a constant expression}} constexpr int h(int n) { // expected-error {{constexpr function never produces a constant expression}}
static const int m = n; // expected-note {{control flows through the definition of a static variable}} \ static const int m = n; // expected-note {{control flows through the definition of a static variable}} \
// cxx2b-warning {{definition of a static variable in a constexpr function is incompatible with C++ standards before C++2b}} // cxx23-warning {{definition of a static variable in a constexpr function is incompatible with C++ standards before C++23}}
return &m - &m; return &m - &m;
} }
constexpr int i(int n) { // expected-error {{constexpr function never produces a constant expression}} constexpr int i(int n) { // expected-error {{constexpr function never produces a constant expression}}
thread_local const int m = n; // expected-note {{control flows through the definition of a thread_local variable}} \ thread_local const int m = n; // expected-note {{control flows through the definition of a thread_local variable}} \
// cxx2b-warning {{definition of a thread_local variable in a constexpr function is incompatible with C++ standards before C++2b}} // cxx23-warning {{definition of a thread_local variable in a constexpr function is incompatible with C++ standards before C++23}}
return &m - &m; return &m - &m;
} }
constexpr int j(int n) { constexpr int j(int n) {
if (!n) if (!n)
return 0; return 0;
static const int m = n; // cxx2b-warning {{definition of a static variable in a constexpr function is incompatible with C++ standards before C++2b}} static const int m = n; // cxx23-warning {{definition of a static variable in a constexpr function is incompatible with C++ standards before C++23}}
return m; return m;
} }
constexpr int j0 = j(0); constexpr int j0 = j(0);
constexpr int k(int n) { constexpr int k(int n) {
if (!n) if (!n)
return 0; return 0;
thread_local const int m = n; // cxx2b-warning {{definition of a thread_local variable in a constexpr function is incompatible with C++ standards before C++2b}} thread_local const int m = n; // cxx23-warning {{definition of a thread_local variable in a constexpr function is incompatible with C++ standards before C++23}}
return m; return m;
} }
constexpr int k0 = k(0); constexpr int k0 = k(0);
constexpr int j_evaluated(int n) { constexpr int j_evaluated(int n) {
if (!n) if (!n)
return 0; return 0;
static const int m = n; // expected-note {{control flows through the definition of a static variable}} \ static const int m = n; // expected-note {{control flows through the definition of a static variable}} \
// cxx2b-warning {{definition of a static variable in a constexpr function is incompatible with C++ standards before C++2b}} // cxx23-warning {{definition of a static variable in a constexpr function is incompatible with C++ standards before C++23}}
return m; return m;
} }
constexpr int je = j_evaluated(1); // expected-error {{constexpr variable 'je' must be initialized by a constant expression}} \ constexpr int je = j_evaluated(1); // expected-error {{constexpr variable 'je' must be initialized by a constant expression}} \
// expected-note {{in call}} // expected-note {{in call}}
constexpr int k_evaluated(int n) { constexpr int k_evaluated(int n) {
if (!n) if (!n)
return 0; return 0;
thread_local const int m = n; // expected-note {{control flows through the definition of a thread_local variable}} \ thread_local const int m = n; // expected-note {{control flows through the definition of a thread_local variable}} \
// cxx2b-warning {{definition of a thread_local variable in a constexpr function is incompatible with C++ standards before C++2b}} // cxx23-warning {{definition of a thread_local variable in a constexpr function is incompatible with C++ standards before C++23}}
return m; return m;
} }
constexpr int ke = k_evaluated(1); // expected-error {{constexpr variable 'ke' must be initialized by a constant expression}} \ constexpr int ke = k_evaluated(1); // expected-error {{constexpr variable 'ke' must be initialized by a constant expression}} \
// expected-note {{in call}} // expected-note {{in call}}
constexpr int static_constexpr() { constexpr int static_constexpr() {
static constexpr int m = 42; // cxx2b-warning {{definition of a static variable in a constexpr function is incompatible with C++ standards before C++2b}} static constexpr int m = 42; // cxx23-warning {{definition of a static variable in a constexpr function is incompatible with C++ standards before C++23}}
static constexpr Constexpr foo; // cxx2b-warning {{definition of a static variable in a constexpr function is incompatible with C++ standards before C++2b}} static constexpr Constexpr foo; // cxx23-warning {{definition of a static variable in a constexpr function is incompatible with C++ standards before C++23}}
return m; return m;
} }
constexpr int thread_local_constexpr() { constexpr int thread_local_constexpr() {
thread_local constexpr int m = 42; // cxx2b-warning {{definition of a thread_local variable in a constexpr function is incompatible with C++ standards before C++2b}} thread_local constexpr int m = 42; // cxx23-warning {{definition of a thread_local variable in a constexpr function is incompatible with C++ standards before C++23}}
thread_local constexpr Constexpr foo; // cxx2b-warning {{definition of a thread_local variable in a constexpr function is incompatible with C++ standards before C++2b}} thread_local constexpr Constexpr foo; // cxx23-warning {{definition of a thread_local variable in a constexpr function is incompatible with C++ standards before C++23}}
return m; return m;
} }
constexpr int non_literal(bool b) { constexpr int non_literal(bool b) {
if (!b) if (!b)
return 0; return 0;
NonLiteral n; // cxx2b-warning {{definition of a variable of non-literal type in a constexpr function is incompatible with C++ standards before C++2b}} NonLiteral n; // cxx23-warning {{definition of a variable of non-literal type in a constexpr function is incompatible with C++ standards before C++23}}
} }
constexpr int non_literal_1 = non_literal(false); constexpr int non_literal_1 = non_literal(false);
namespace eval_goto { namespace eval_goto {
constexpr int f(int x) { constexpr int f(int x) {
if (x) { if (x) {
return 0; return 0;
} else { } else {
goto test; // expected-note {{subexpression not valid in a constant expression}} \ goto test; // expected-note {{subexpression not valid in a constant expression}} \
// cxx2b-warning {{use of this statement in a constexpr function is incompatible with C++ standards before C++2b}} // cxx23-warning {{use of this statement in a constexpr function is incompatible with C++ standards before C++23}}
} }
test: test:
return 0; return 0;
} }
int a = f(0); int a = f(0);
constexpr int b = f(0); // expected-error {{must be initialized by a constant expression}} \ constexpr int b = f(0); // expected-error {{must be initialized by a constant expression}} \
// expected-note {{in call to 'f(0)'}} // expected-note {{in call to 'f(0)'}}
constexpr int c = f(1); constexpr int c = f(1);
constexpr int label() { constexpr int label() {
test: // cxx2b-warning {{use of this statement in a constexpr function is incompatible with C++ standards before C++2b}} test: // cxx23-warning {{use of this statement in a constexpr function is incompatible with C++ standards before C++23}}
return 0; return 0;
} }
constexpr int d = label(); constexpr int d = label();
} // namespace eval_goto } // namespace eval_goto
#endif #endif
// Test that explicitly constexpr lambdas behave correctly, // Test that explicitly constexpr lambdas behave correctly,
// This is to be contrasted with the test for implicitly constexpr lambdas below. // This is to be contrasted with the test for implicitly constexpr lambdas below.
int test_in_lambdas() { int test_in_lambdas() {
auto a = []() constexpr { auto a = []() constexpr {
static const int m = 32; // cxx2b-warning {{definition of a static variable in a constexpr function is incompatible with C++ standards before C++2b}} static const int m = 32; // cxx23-warning {{definition of a static variable in a constexpr function is incompatible with C++ standards before C++23}}
return m; return m;
}; };
auto b = [](int n) constexpr { auto b = [](int n) constexpr {
if (!n) if (!n)
return 0; return 0;
static const int m = n; // cxx2b-warning {{definition of a static variable in a constexpr function is incompatible with C++ standards before C++2b}} static const int m = n; // cxx23-warning {{definition of a static variable in a constexpr function is incompatible with C++ standards before C++23}}
return m; return m;
} }
(1); (1);
auto c = [](int n) constexpr { auto c = [](int n) constexpr {
if (!n) if (!n)
return 0; return 0;
else else
goto test; // expected-note {{subexpression not valid in a constant expression}} \ goto test; // expected-note {{subexpression not valid in a constant expression}} \
// cxx2b-warning {{use of this statement in a constexpr function is incompatible with C++ standards before C++2b}} // cxx23-warning {{use of this statement in a constexpr function is incompatible with C++ standards before C++23}}
test: test:
return 1; return 1;
}; };
c(0); c(0);
constexpr auto c_error = c(1); // expected-error {{constexpr variable 'c_error' must be initialized by a constant expression}} \ constexpr auto c_error = c(1); // expected-error {{constexpr variable 'c_error' must be initialized by a constant expression}} \
// expected-note {{in call to}} // expected-note {{in call to}}
auto non_literal = [](bool b) constexpr { auto non_literal = [](bool b) constexpr {
if (!b) if (!b)
NonLiteral n; // cxx2b-note {{non-literal type 'NonLiteral' cannot be used in a constant expression}} \ NonLiteral n; // cxx23-note {{non-literal type 'NonLiteral' cannot be used in a constant expression}} \
// cxx2a-error {{variable of non-literal type 'NonLiteral' cannot be defined in a constexpr function before C++2b}} \ // cxx2a-error {{variable of non-literal type 'NonLiteral' cannot be defined in a constexpr function before C++23}} \
// cxx2b-warning {{definition of a variable of non-literal type in a constexpr function is incompatible with C++ standards before C++2b}} // cxx23-warning {{definition of a variable of non-literal type in a constexpr function is incompatible with C++ standards before C++23}}
return 0; return 0;
}; };
#if __cplusplus > 202002L #if __cplusplus > 202002L
constexpr auto non_literal_ko = non_literal(false); // cxx2b-error {{constexpr variable 'non_literal_ko' must be initialized by a constant expression}} \ constexpr auto non_literal_ko = non_literal(false); // cxx23-error {{constexpr variable 'non_literal_ko' must be initialized by a constant expression}} \
// cxx2b-note {{in call}} // cxx23-note {{in call}}
constexpr auto non_literal_ok = non_literal(true); constexpr auto non_literal_ok = non_literal(true);
#endif #endif
} }
// Test whether lambdas are correctly treated as implicitly constexpr under the // Test whether lambdas are correctly treated as implicitly constexpr under the
// relaxed C++23 rules (and similarly as not implicitly constexpr under the // relaxed C++23 rules (and similarly as not implicitly constexpr under the
// C++20 rules). // C++20 rules).
int test_lambdas_implicitly_constexpr() { int test_lambdas_implicitly_constexpr() {
auto b = [](int n) { // cxx2a-note 2{{declared here}} auto b = [](int n) { // cxx2a-note 2{{declared here}}
if (!n) if (!n)
return 0; return 0;
static const int m = n; // cxx2b-note {{control flows through the definition of a static variable}} static const int m = n; // cxx23-note {{control flows through the definition of a static variable}}
return m; return m;
}; };
auto b1 = b(1); auto b1 = b(1);
constexpr auto b2 = b(0); // cxx2a-error {{must be initialized by a constant expression}} \ constexpr auto b2 = b(0); // cxx2a-error {{must be initialized by a constant expression}} \
// cxx2a-note {{non-constexpr function}} // cxx2a-note {{non-constexpr function}}
constexpr auto b3 = b(1); // expected-error{{constexpr variable 'b3' must be initialized by a constant expression}} \ constexpr auto b3 = b(1); // expected-error{{constexpr variable 'b3' must be initialized by a constant expression}} \
// cxx2a-note {{non-constexpr function}} \ // cxx2a-note {{non-constexpr function}} \
// cxx2b-note {{in call}} // cxx23-note {{in call}}
auto c = [](int n) { // cxx2a-note 2{{declared here}} auto c = [](int n) { // cxx2a-note 2{{declared here}}
if (!n) if (!n)
return 0; return 0;
else else
goto test; // cxx2b-note {{subexpression not valid in a constant expression}} goto test; // cxx23-note {{subexpression not valid in a constant expression}}
test: test:
return 1; return 1;
}; };
c(0); c(0);
constexpr auto c_ok = c(0); // cxx2a-error {{must be initialized by a constant expression}} \ constexpr auto c_ok = c(0); // cxx2a-error {{must be initialized by a constant expression}} \
// cxx2a-note {{non-constexpr function}} // cxx2a-note {{non-constexpr function}}
constexpr auto c_error = c(1); // expected-error {{constexpr variable 'c_error' must be initialized by a constant expression}} \ constexpr auto c_error = c(1); // expected-error {{constexpr variable 'c_error' must be initialized by a constant expression}} \
// cxx2a-note {{non-constexpr function}} \ // cxx2a-note {{non-constexpr function}} \
// cxx2b-note {{in call to}} // cxx23-note {{in call to}}
auto non_literal = [](bool b) { // cxx2a-note 2{{declared here}} auto non_literal = [](bool b) { // cxx2a-note 2{{declared here}}
if (b) if (b)
NonLiteral n; // cxx2b-note {{non-literal type 'NonLiteral' cannot be used in a constant expression}} NonLiteral n; // cxx23-note {{non-literal type 'NonLiteral' cannot be used in a constant expression}}
return 0; return 0;
}; };
constexpr auto non_literal_ko = non_literal(true); // expected-error {{constexpr variable 'non_literal_ko' must be initialized by a constant expression}} \ constexpr auto non_literal_ko = non_literal(true); // expected-error {{constexpr variable 'non_literal_ko' must be initialized by a constant expression}} \
// cxx2a-note {{non-constexpr function}} \ // cxx2a-note {{non-constexpr function}} \
// cxx2b-note {{in call}} // cxx23-note {{in call}}
constexpr auto non_literal_ok = non_literal(false); // cxx2a-error {{must be initialized by a constant expression}} \ constexpr auto non_literal_ok = non_literal(false); // cxx2a-error {{must be initialized by a constant expression}} \
// cxx2a-note {{non-constexpr function}} // cxx2a-note {{non-constexpr function}}
} }
template <typename T> template <typename T>
constexpr auto dependent_var_def_lambda() { constexpr auto dependent_var_def_lambda() {
return [](bool b) { // cxx2a-note {{declared here}} return [](bool b) { // cxx2a-note {{declared here}}
if (!b) if (!b)
T t; T t;
return 0; return 0;
}; };
} }
constexpr auto non_literal_valid_in_cxx2b = dependent_var_def_lambda<NonLiteral>()(true); // \ constexpr auto non_literal_valid_in_cxx23 = dependent_var_def_lambda<NonLiteral>()(true); // \
// cxx2a-error {{constexpr variable 'non_literal_valid_in_cxx2b' must be initialized by a constant expression}} \ // cxx2a-error {{constexpr variable 'non_literal_valid_in_cxx23' must be initialized by a constant expression}} \
// cxx2a-note {{non-constexpr function}} // cxx2a-note {{non-constexpr function}}
constexpr double evaluate_static_constexpr() { constexpr double evaluate_static_constexpr() {
struct Constexpr{ struct Constexpr{
constexpr double f() const { constexpr double f() const {
return 42; return 42;
} }
}; };
thread_local constexpr Constexpr t; // cxx2b-warning {{before C++2b}} thread_local constexpr Constexpr t; // cxx23-warning {{before C++23}}
static constexpr Constexpr s; // cxx2b-warning {{before C++2b}} static constexpr Constexpr s; // cxx23-warning {{before C++23}}
return t.f() + s.f(); return t.f() + s.f();
} }
static_assert(evaluate_static_constexpr() == 84); static_assert(evaluate_static_constexpr() == 84);

clang/test/SemaCXX/conversion-function.cpp

// RUN: %clang_cc1 -std=c++2b -fsyntax-only -verify=expected -triple %itanium_abi_triple -Wbind-to-temporary-copy %s // RUN: %clang_cc1 -std=c++23 -fsyntax-only -verify=expected -triple %itanium_abi_triple -Wbind-to-temporary-copy %s
// RUN: %clang_cc1 -std=c++20 -fsyntax-only -verify=expected -triple %itanium_abi_triple -Wbind-to-temporary-copy %s // RUN: %clang_cc1 -std=c++20 -fsyntax-only -verify=expected -triple %itanium_abi_triple -Wbind-to-temporary-copy %s
// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify=expected,cxx98_11,cxx11 -triple %itanium_abi_triple -Wbind-to-temporary-copy %s // RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify=expected,cxx98_11,cxx11 -triple %itanium_abi_triple -Wbind-to-temporary-copy %s
// RUN: %clang_cc1 -std=c++98 -fsyntax-only -verify=expected,cxx98_11,cxx98 -triple %itanium_abi_triple -Wbind-to-temporary-copy %s // RUN: %clang_cc1 -std=c++98 -fsyntax-only -verify=expected,cxx98_11,cxx98 -triple %itanium_abi_triple -Wbind-to-temporary-copy %s
class X { class X {
public: public:
operator bool(); operator bool();
operator int() const; operator int() const;
▲ Show 20 Lines • Show All 478 Lines • Show Last 20 Lines

clang/test/SemaCXX/coroutines.cpp

// This file contains references to sections of the Coroutines TS, which can be // This file contains references to sections of the Coroutines TS, which can be
// found at http://wg21.link/coroutines. // found at http://wg21.link/coroutines.
// RUN: %clang_cc1 -std=c++2b -fsyntax-only -verify=expected,cxx20_2b,cxx2b %s -fcxx-exceptions -fexceptions -Wunused-result // RUN: %clang_cc1 -std=c++23 -fsyntax-only -verify=expected,cxx20_23,cxx23 %s -fcxx-exceptions -fexceptions -Wunused-result
// RUN: %clang_cc1 -std=c++20 -fsyntax-only -verify=expected,cxx14_20,cxx20_2b %s -fcxx-exceptions -fexceptions -Wunused-result // RUN: %clang_cc1 -std=c++20 -fsyntax-only -verify=expected,cxx14_20,cxx20_23 %s -fcxx-exceptions -fexceptions -Wunused-result
void no_coroutine_traits_bad_arg_await() { void no_coroutine_traits_bad_arg_await() {
co_await a; // expected-error {{include <coroutine>}} co_await a; // expected-error {{include <coroutine>}}
// expected-error@-1 {{use of undeclared identifier 'a'}} // expected-error@-1 {{use of undeclared identifier 'a'}}
} }
void no_coroutine_traits_bad_arg_yield() { void no_coroutine_traits_bad_arg_yield() {
co_yield a; // expected-error {{include <coroutine>}} co_yield a; // expected-error {{include <coroutine>}}
▲ Show 20 Lines • Show All 914 Lines • ▼ Show 20 Lines struct promise_type {
suspend_always initial_suspend() { return {}; } suspend_always initial_suspend() { return {}; }
suspend_always final_suspend() noexcept { return {}; } suspend_always final_suspend() noexcept { return {}; }
void return_void() {} void return_void() {}
void unhandled_exception(); void unhandled_exception();
}; };
}; };
extern "C" int f(mismatch_gro_type_tag2) { extern "C" int f(mismatch_gro_type_tag2) {
// cxx2b-error@-1 {{cannot initialize return object of type 'int' with an rvalue of type 'void *'}} // cxx23-error@-1 {{cannot initialize return object of type 'int' with an rvalue of type 'void *'}}
// cxx14_20-error@-2 {{cannot initialize return object of type 'int' with an lvalue of type 'void *'}} // cxx14_20-error@-2 {{cannot initialize return object of type 'int' with an lvalue of type 'void *'}}
co_return; //expected-note {{function is a coroutine due to use of 'co_return' here}} co_return; //expected-note {{function is a coroutine due to use of 'co_return' here}}
} }
struct mismatch_gro_type_tag3 {}; struct mismatch_gro_type_tag3 {};
template <> template <>
struct std::coroutine_traits<int, mismatch_gro_type_tag3> { struct std::coroutine_traits<int, mismatch_gro_type_tag3> {
struct promise_type { struct promise_type {
▲ Show 20 Lines • Show All 81 Lines • ▼ Show 20 Linesstruct await_ready_explicit_bool {
void await_resume(); void await_resume();
}; };
template <class SuspendTy> template <class SuspendTy>
struct await_suspend_type_test { struct await_suspend_type_test {
bool await_ready(); bool await_ready();
// expected-error@+2 {{return type of 'await_suspend' is required to be 'void' or 'bool' (have 'bool &')}} // expected-error@+2 {{return type of 'await_suspend' is required to be 'void' or 'bool' (have 'bool &')}}
// expected-error@+1 {{return type of 'await_suspend' is required to be 'void' or 'bool' (have 'bool &&')}} // expected-error@+1 {{return type of 'await_suspend' is required to be 'void' or 'bool' (have 'bool &&')}}
SuspendTy await_suspend(std::coroutine_handle<>); SuspendTy await_suspend(std::coroutine_handle<>);
// cxx20_2b-warning@-1 {{volatile-qualified return type 'const volatile bool' is deprecated}} // cxx20_23-warning@-1 {{volatile-qualified return type 'const volatile bool' is deprecated}}
void await_resume(); void await_resume();
}; };
void test_bad_suspend() { void test_bad_suspend() {
{ {
// FIXME: The actual error emitted here is terrible, and no number of notes can save it. // FIXME: The actual error emitted here is terrible, and no number of notes can save it.
bad_await_ready_return a; bad_await_ready_return a;
// expected-error@+1 {{value of type 'void' is not contextually convertible to 'bool'}} // expected-error@+1 {{value of type 'void' is not contextually convertible to 'bool'}}
co_await a; // expected-note {{call to 'await_ready' implicitly required by coroutine function here}} co_await a; // expected-note {{call to 'await_ready' implicitly required by coroutine function here}}
} }
{ {
bad_await_suspend_return b; bad_await_suspend_return b;
co_await b; // expected-note {{call to 'await_suspend' implicitly required by coroutine function here}} co_await b; // expected-note {{call to 'await_suspend' implicitly required by coroutine function here}}
} }
{ {
await_ready_explicit_bool c; await_ready_explicit_bool c;
co_await c; // OK co_await c; // OK
} }
{ {
await_suspend_type_test<bool &&> a; await_suspend_type_test<bool &&> a;
await_suspend_type_test<bool &> b; await_suspend_type_test<bool &> b;
await_suspend_type_test<const void> c; await_suspend_type_test<const void> c;
await_suspend_type_test<const volatile bool> d; // cxx20_2b-note {{in instantiation of template class}} await_suspend_type_test<const volatile bool> d; // cxx20_23-note {{in instantiation of template class}}
co_await a; // expected-note {{call to 'await_suspend' implicitly required by coroutine function here}} co_await a; // expected-note {{call to 'await_suspend' implicitly required by coroutine function here}}
co_await b; // expected-note {{call to 'await_suspend' implicitly required by coroutine function here}} co_await b; // expected-note {{call to 'await_suspend' implicitly required by coroutine function here}}
co_await c; // OK co_await c; // OK
co_await d; // OK co_await d; // OK
} }
} }
template <int ID = 0> template <int ID = 0>
▲ Show 20 Lines • Show All 71 Lines • ▼ Show 20 Linesstruct TestType {
CoroMemberTag test_asserts(int *) const { CoroMemberTag test_asserts(int *) const {
auto TC = co_yield 0; auto TC = co_yield 0;
static_assert(TC.MatchesArgs<const TestType &>, ""); // expected-error {{static assertion failed}} static_assert(TC.MatchesArgs<const TestType &>, ""); // expected-error {{static assertion failed}}
static_assert(TC.MatchesArgs<const TestType &>, ""); // expected-error {{static assertion failed}} static_assert(TC.MatchesArgs<const TestType &>, ""); // expected-error {{static assertion failed}}
static_assert(TC.MatchesArgs<const TestType &, int *>, ""); static_assert(TC.MatchesArgs<const TestType &, int *>, "");
} }
CoroMemberTag test_qual(int *, const float &&, volatile void *volatile) const { CoroMemberTag test_qual(int *, const float &&, volatile void *volatile) const {
// cxx20_2b-warning@-1 {{volatile-qualified parameter type}} // cxx20_23-warning@-1 {{volatile-qualified parameter type}}
auto TC = co_yield 0; auto TC = co_yield 0;
static_assert(TC.MatchesArgs<const TestType &, int *, const float &&, volatile void *volatile>, ""); static_assert(TC.MatchesArgs<const TestType &, int *, const float &&, volatile void *volatile>, "");
} }
CoroMemberTag test_qual() const volatile { CoroMemberTag test_qual() const volatile {
auto TC = co_yield 0; auto TC = co_yield 0;
static_assert(TC.MatchesArgs<const volatile TestType &>, ""); static_assert(TC.MatchesArgs<const volatile TestType &>, "");
} }
▲ Show 20 Lines • Show All 82 Lines • ▼ Show 20 Linesstruct DepTestType {
CoroMemberTag test_qual() { CoroMemberTag test_qual() {
auto TC = co_yield 0; auto TC = co_yield 0;
static_assert(TC.template MatchesArgs<DepTestType &>, ""); static_assert(TC.template MatchesArgs<DepTestType &>, "");
static_assert(!TC.template MatchesArgs<DepTestType>, ""); static_assert(!TC.template MatchesArgs<DepTestType>, "");
static_assert(!TC.template MatchesArgs<DepTestType *>, ""); static_assert(!TC.template MatchesArgs<DepTestType *>, "");
} }
CoroMemberTag test_qual(int *, const float &&, volatile void *volatile) const { CoroMemberTag test_qual(int *, const float &&, volatile void *volatile) const {
// cxx20_2b-warning@-1 {{volatile-qualified parameter type}} // cxx20_23-warning@-1 {{volatile-qualified parameter type}}
auto TC = co_yield 0; auto TC = co_yield 0;
static_assert(TC.template MatchesArgs<const DepTestType &, int *, const float &&, volatile void *volatile>, ""); static_assert(TC.template MatchesArgs<const DepTestType &, int *, const float &&, volatile void *volatile>, "");
} }
CoroMemberTag test_qual() const volatile { CoroMemberTag test_qual() const volatile {
auto TC = co_yield 0; auto TC = co_yield 0;
static_assert(TC.template MatchesArgs<const volatile DepTestType &>, ""); static_assert(TC.template MatchesArgs<const volatile DepTestType &>, "");
} }
▲ Show 20 Lines • Show All 226 Lines • Show Last 20 Lines

clang/test/SemaCXX/cxx2a-consteval-default-params.cpp

// RUN: %clang_cc1 -fsyntax-only -verify -std=c++20 %s // RUN: %clang_cc1 -fsyntax-only -verify -std=c++20 %s
// RUN: %clang_cc1 -fsyntax-only -verify -std=c++2b %s // RUN: %clang_cc1 -fsyntax-only -verify -std=c++23 %s
consteval int undefined(); // expected-note 4 {{declared here}} consteval int undefined(); // expected-note 4 {{declared here}}
void check_lambdas_unused( void check_lambdas_unused(
int a = [] int a = []
{ {
// The body of a lambda is not a subexpression of the lambda // The body of a lambda is not a subexpression of the lambda
// so this is immediately evaluated even if the parameter // so this is immediately evaluated even if the parameter
▲ Show 20 Lines • Show All 71 Lines • Show Last 20 Lines

clang/test/SemaCXX/cxx2b-ast-print.cpp

// RUN: %clang_cc1 -std=c++2b -fsyntax-only -ast-print %s | FileCheck %s // RUN: %clang_cc1 -std=c++23 -fsyntax-only -ast-print %s | FileCheck %s
template <template <class...> class C> template <template <class...> class C>
void test_auto_expr(long long y, auto &&z) { void test_auto_expr(long long y, auto &&z) {
int x[] = {3, 4}; int x[] = {3, 4};
// CHECK{LITERAL}: (int)(x[1]) // CHECK{LITERAL}: (int)(x[1])
void(auto(x[1])); void(auto(x[1]));
// CHECK{LITERAL}: (int){x[1]} // CHECK{LITERAL}: (int){x[1]}
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

clang/test/SemaCXX/cxx2b-consteval-if.cpp

// RUN: %clang_cc1 -std=c++2b -verify %s // RUN: %clang_cc1 -std=c++23 -verify %s
namespace PR52206 { namespace PR52206 {
constexpr auto f() { constexpr auto f() {
if consteval { return 0; } if consteval { return 0; }
if !consteval { return 0.0; } // expected-error {{'auto' in return type deduced as 'double' here but deduced as 'int' in earlier return statement}} if !consteval { return 0.0; } // expected-error {{'auto' in return type deduced as 'double' here but deduced as 'int' in earlier return statement}}
} }
constexpr auto g() { constexpr auto g() {
▲ Show 20 Lines • Show All 47 Lines • Show Last 20 Lines

clang/test/SemaCXX/cxx2b-designated-initializers.cpp

// RUN: %clang_cc1 -std=c++2b -fsyntax-only -verify %s // RUN: %clang_cc1 -std=c++23 -fsyntax-only -verify %s
namespace PR61118 { namespace PR61118 {
union S { union S {
struct { struct {
int a; int a;
}; };
}; };
Show All 12 Lines

clang/test/SemaCXX/cxx2b-init-statement.cpp

// RUN: %clang_cc1 -verify -std=c++2b -Wall -Wshadow %s // RUN: %clang_cc1 -verify -std=c++23 -Wall -Wshadow %s
void f() { void f() {
for (using foo = int;true;) {} //expected-warning {{unused type alias 'foo'}} for (using foo = int;true;) {} //expected-warning {{unused type alias 'foo'}}
switch(using foo = int; 0) { //expected-warning {{unused type alias 'foo'}} switch(using foo = int; 0) { //expected-warning {{unused type alias 'foo'}}
case 0: break; case 0: break;
} }
Show All 19 Lines

clang/test/SemaCXX/cxx2b-overloaded-operator-pedantic.cpp

// RUN: %clang_cc1 -verify -std=c++2b -pedantic %s // RUN: %clang_cc1 -verify -std=c++23 -pedantic %s
// RUN: %clang_cc1 -verify=compat -std=c++2b -Wpre-c++2b-compat %s // RUN: %clang_cc1 -verify=compat -std=c++23 -Wpre-c++23-compat %s
// expected-no-diagnostics // expected-no-diagnostics
struct GH61582 { struct GH61582 {
// We accidentally would issue this diagnostic in pedantic mode; show that we // We accidentally would issue this diagnostic in pedantic mode; show that we
// only issue it when enabling the compat warnings now. // only issue it when enabling the compat warnings now.
void operator[](int, int); // compat-warning {{overloaded 'operator[]' with more than one parameter is a C++2b extension}} void operator[](int, int); // compat-warning {{overloaded 'operator[]' with more than one parameter is a C++23 extension}}
}; };

clang/test/SemaCXX/cxx2b-overloaded-operator.cpp

// RUN: %clang_cc1 -verify -std=c++2b %s // RUN: %clang_cc1 -verify -std=c++23 %s
namespace N { namespace N {
void empty() { void empty() {
struct S { struct S {
int operator[](); // expected-note{{not viable: requires 0 arguments, but 1 was provided}} int operator[](); // expected-note{{not viable: requires 0 arguments, but 1 was provided}}
}; };
▲ Show 20 Lines • Show All 110 Lines • Show Last 20 Lines

clang/test/SemaCXX/cxx2b-p2266-disable-with-msvc-compat.cpp

// RUN: %clang_cc1 -std=c++2b -fsyntax-only -verify=cxx2b,new %s // RUN: %clang_cc1 -std=c++23 -fsyntax-only -verify=cxx23,new %s
// RUN: %clang_cc1 -std=c++2b -fsyntax-only -fms-compatibility -verify=cxx2b,old %s // RUN: %clang_cc1 -std=c++23 -fsyntax-only -fms-compatibility -verify=cxx23,old %s
// RUN: %clang_cc1 -std=c++20 -fsyntax-only -verify=cxx20,old %s // RUN: %clang_cc1 -std=c++20 -fsyntax-only -verify=cxx20,old %s
// FIXME: This is a test for a temporary workaround where we disable simpler implicit moves // FIXME: This is a test for a temporary workaround where we disable simpler implicit moves
// in the STL when compiling with -fms-compatibility, because of issues with the // in the STL when compiling with -fms-compatibility, because of issues with the
// implementation there. // implementation there.
// Feel free to delete this file when the workaround is not needed anymore. // Feel free to delete this file when the workaround is not needed anymore.
#if __INCLUDE_LEVEL__ == 0 #if __INCLUDE_LEVEL__ == 0
#if __cpluscplus > 202002L && __cpp_implicit_move < 202011L #if __cpluscplus > 202002L && __cpp_implicit_move < 202011L
#error "__cpp_implicit_move not defined correctly" #error "__cpp_implicit_move not defined correctly"
#endif #endif
struct nocopy { struct nocopy {
nocopy(nocopy &&); nocopy(nocopy &&);
}; };
int &&mt1(int &&x) { return x; } // cxx20-error {{cannot bind to lvalue}} int &&mt1(int &&x) { return x; } // cxx20-error {{cannot bind to lvalue}}
int &mt2(int &&x) { return x; } // cxx2b-error {{cannot bind to a temporary}} int &mt2(int &&x) { return x; } // cxx23-error {{cannot bind to a temporary}}
nocopy mt3(nocopy x) { return x; } nocopy mt3(nocopy x) { return x; }
namespace { namespace {
int &&mt1(int &&x) { return x; } // cxx20-error {{cannot bind to lvalue}} int &&mt1(int &&x) { return x; } // cxx20-error {{cannot bind to lvalue}}
int &mt2(int &&x) { return x; } // cxx2b-error {{cannot bind to a temporary}} int &mt2(int &&x) { return x; } // cxx23-error {{cannot bind to a temporary}}
nocopy mt3(nocopy x) { return x; } nocopy mt3(nocopy x) { return x; }
} // namespace } // namespace
namespace foo { namespace foo {
int &&mt1(int &&x) { return x; } // cxx20-error {{cannot bind to lvalue}} int &&mt1(int &&x) { return x; } // cxx20-error {{cannot bind to lvalue}}
int &mt2(int &&x) { return x; } // cxx2b-error {{cannot bind to a temporary}} int &mt2(int &&x) { return x; } // cxx23-error {{cannot bind to a temporary}}
namespace std { namespace std {
int &&mt1(int &&x) { return x; } // cxx20-error {{cannot bind to lvalue}} int &&mt1(int &&x) { return x; } // cxx20-error {{cannot bind to lvalue}}
int &mt2(int &&x) { return x; } // cxx2b-error {{cannot bind to a temporary}} int &mt2(int &&x) { return x; } // cxx23-error {{cannot bind to a temporary}}
nocopy mt3(nocopy x) { return x; } nocopy mt3(nocopy x) { return x; }
} // namespace std } // namespace std
} // namespace foo } // namespace foo
namespace std { namespace std {
int &&mt1(int &&x) { return x; } // cxx20-error {{cannot bind to lvalue}} int &&mt1(int &&x) { return x; } // cxx20-error {{cannot bind to lvalue}}
int &mt2(int &&x) { return x; } // cxx2b-error {{cannot bind to a temporary}} int &mt2(int &&x) { return x; } // cxx23-error {{cannot bind to a temporary}}
nocopy mt3(nocopy x) { return x; } nocopy mt3(nocopy x) { return x; }
namespace { namespace {
int &&mt1(int &&x) { return x; } // cxx20-error {{cannot bind to lvalue}} int &&mt1(int &&x) { return x; } // cxx20-error {{cannot bind to lvalue}}
int &mt2(int &&x) { return x; } // cxx2b-error {{cannot bind to a temporary}} int &mt2(int &&x) { return x; } // cxx23-error {{cannot bind to a temporary}}
nocopy mt3(nocopy x) { return x; } nocopy mt3(nocopy x) { return x; }
} // namespace } // namespace
namespace foo { namespace foo {
int &&mt1(int &&x) { return x; } // cxx20-error {{cannot bind to lvalue}} int &&mt1(int &&x) { return x; } // cxx20-error {{cannot bind to lvalue}}
int &mt2(int &&x) { return x; } // cxx2b-error {{cannot bind to a temporary}} int &mt2(int &&x) { return x; } // cxx23-error {{cannot bind to a temporary}}
nocopy mt3(nocopy x) { return x; } nocopy mt3(nocopy x) { return x; }
} // namespace foo } // namespace foo
} // namespace std } // namespace std
#include __FILE__ #include __FILE__
#define SYSTEM #define SYSTEM
#include __FILE__ #include __FILE__
#elif !defined(SYSTEM) #elif !defined(SYSTEM)
int &&ut1(int &&x) { return x; } // cxx20-error {{cannot bind to lvalue}} int &&ut1(int &&x) { return x; } // cxx20-error {{cannot bind to lvalue}}
int &ut2(int &&x) { return x; } // cxx2b-error {{cannot bind to a temporary}} int &ut2(int &&x) { return x; } // cxx23-error {{cannot bind to a temporary}}
nocopy ut3(nocopy x) { return x; } nocopy ut3(nocopy x) { return x; }
namespace { namespace {
int &&ut1(int &&x) { return x; } // cxx20-error {{cannot bind to lvalue}} int &&ut1(int &&x) { return x; } // cxx20-error {{cannot bind to lvalue}}
int &ut2(int &&x) { return x; } // cxx2b-error {{cannot bind to a temporary}} int &ut2(int &&x) { return x; } // cxx23-error {{cannot bind to a temporary}}
nocopy ut3(nocopy x) { return x; } nocopy ut3(nocopy x) { return x; }
} // namespace } // namespace
namespace foo { namespace foo {
int &&ut1(int &&x) { return x; } // cxx20-error {{cannot bind to lvalue}} int &&ut1(int &&x) { return x; } // cxx20-error {{cannot bind to lvalue}}
int &ut2(int &&x) { return x; } // cxx2b-error {{cannot bind to a temporary}} int &ut2(int &&x) { return x; } // cxx23-error {{cannot bind to a temporary}}
nocopy ut3(nocopy x) { return x; } nocopy ut3(nocopy x) { return x; }
namespace std { namespace std {
int &&ut1(int &&x) { return x; } // cxx20-error {{cannot bind to lvalue}} int &&ut1(int &&x) { return x; } // cxx20-error {{cannot bind to lvalue}}
int &ut2(int &&x) { return x; } // cxx2b-error {{cannot bind to a temporary}} int &ut2(int &&x) { return x; } // cxx23-error {{cannot bind to a temporary}}
nocopy ut3(nocopy x) { return x; } nocopy ut3(nocopy x) { return x; }
} // namespace std } // namespace std
} // namespace foo } // namespace foo
namespace std { namespace std {
int &&ut1(int &&x) { return x; } // cxx20-error {{cannot bind to lvalue}} int &&ut1(int &&x) { return x; } // cxx20-error {{cannot bind to lvalue}}
int &ut2(int &&x) { return x; } // cxx2b-error {{cannot bind to a temporary}} int &ut2(int &&x) { return x; } // cxx23-error {{cannot bind to a temporary}}
nocopy ut3(nocopy x) { return x; } nocopy ut3(nocopy x) { return x; }
namespace { namespace {
int &&ut1(int &&x) { return x; } // cxx20-error {{cannot bind to lvalue}} int &&ut1(int &&x) { return x; } // cxx20-error {{cannot bind to lvalue}}
int &ut2(int &&x) { return x; } // cxx2b-error {{cannot bind to a temporary}} int &ut2(int &&x) { return x; } // cxx23-error {{cannot bind to a temporary}}
nocopy ut3(nocopy x) { return x; } nocopy ut3(nocopy x) { return x; }
} // namespace } // namespace
namespace foo { namespace foo {
int &&ut1(int &&x) { return x; } // cxx20-error {{cannot bind to lvalue}} int &&ut1(int &&x) { return x; } // cxx20-error {{cannot bind to lvalue}}
int &ut2(int &&x) { return x; } // cxx2b-error {{cannot bind to a temporary}} int &ut2(int &&x) { return x; } // cxx23-error {{cannot bind to a temporary}}
nocopy ut3(nocopy x) { return x; } nocopy ut3(nocopy x) { return x; }
} // namespace foo } // namespace foo
} // namespace std } // namespace std
#else #else
#pragma GCC system_header #pragma GCC system_header
int &&st1(int &&x) { return x; } // cxx20-error {{cannot bind to lvalue}} int &&st1(int &&x) { return x; } // cxx20-error {{cannot bind to lvalue}}
int &st2(int &&x) { return x; } // cxx2b-error {{cannot bind to a temporary}} int &st2(int &&x) { return x; } // cxx23-error {{cannot bind to a temporary}}
nocopy st3(nocopy x) { return x; } nocopy st3(nocopy x) { return x; }
namespace { namespace {
int &&st1(int &&x) { return x; } // cxx20-error {{cannot bind to lvalue}} int &&st1(int &&x) { return x; } // cxx20-error {{cannot bind to lvalue}}
int &st2(int &&x) { return x; } // cxx2b-error {{cannot bind to a temporary}} int &st2(int &&x) { return x; } // cxx23-error {{cannot bind to a temporary}}
nocopy st3(nocopy x) { return x; } nocopy st3(nocopy x) { return x; }
} // namespace } // namespace
namespace foo { namespace foo {
int &&st1(int &&x) { return x; } // cxx20-error {{cannot bind to lvalue}} int &&st1(int &&x) { return x; } // cxx20-error {{cannot bind to lvalue}}
int &st2(int &&x) { return x; } // cxx2b-error {{cannot bind to a temporary}} int &st2(int &&x) { return x; } // cxx23-error {{cannot bind to a temporary}}
nocopy st3(nocopy x) { return x; } nocopy st3(nocopy x) { return x; }
namespace std { namespace std {
int &&st1(int &&x) { return x; } // cxx20-error {{cannot bind to lvalue}} int &&st1(int &&x) { return x; } // cxx20-error {{cannot bind to lvalue}}
int &st2(int &&x) { return x; } // cxx2b-error {{cannot bind to a temporary}} int &st2(int &&x) { return x; } // cxx23-error {{cannot bind to a temporary}}
nocopy st3(nocopy x) { return x; } nocopy st3(nocopy x) { return x; }
} // namespace std } // namespace std
} // namespace foo } // namespace foo
namespace std { namespace std {
int &&st1(int &&x) { return x; } // old-error {{cannot bind to lvalue}} int &&st1(int &&x) { return x; } // old-error {{cannot bind to lvalue}}
int &st2(int &&x) { return x; } // new-error {{cannot bind to a temporary}} int &st2(int &&x) { return x; } // new-error {{cannot bind to a temporary}}
Show All 17 Lines

clang/test/SemaCXX/deduced-return-type-cxx14.cpp

// RUN: %clang_cc1 -std=c++2b -fsyntax-only -verify=expected,cxx20_2b,cxx2b %s // RUN: %clang_cc1 -std=c++23 -fsyntax-only -verify=expected,cxx20_23,cxx23 %s
// RUN: %clang_cc1 -std=c++2b -fsyntax-only -verify=expected,cxx20_2b,cxx2b %s -fdelayed-template-parsing -DDELAYED_TEMPLATE_PARSING // RUN: %clang_cc1 -std=c++23 -fsyntax-only -verify=expected,cxx20_23,cxx23 %s -fdelayed-template-parsing -DDELAYED_TEMPLATE_PARSING
// RUN: %clang_cc1 -std=c++20 -fsyntax-only -verify=expected,cxx14_20,cxx20_2b %s // RUN: %clang_cc1 -std=c++20 -fsyntax-only -verify=expected,cxx14_20,cxx20_23 %s
// RUN: %clang_cc1 -std=c++20 -fsyntax-only -verify=expected,cxx14_20,cxx20_2b %s -fdelayed-template-parsing -DDELAYED_TEMPLATE_PARSING // RUN: %clang_cc1 -std=c++20 -fsyntax-only -verify=expected,cxx14_20,cxx20_23 %s -fdelayed-template-parsing -DDELAYED_TEMPLATE_PARSING
// RUN: %clang_cc1 -std=c++14 -fsyntax-only -verify=expected,cxx14_20,cxx14 %s // RUN: %clang_cc1 -std=c++14 -fsyntax-only -verify=expected,cxx14_20,cxx14 %s
// RUN: %clang_cc1 -std=c++14 -fsyntax-only -verify=expected,cxx14_20,cxx14 %s -fdelayed-template-parsing -DDELAYED_TEMPLATE_PARSING // RUN: %clang_cc1 -std=c++14 -fsyntax-only -verify=expected,cxx14_20,cxx14 %s -fdelayed-template-parsing -DDELAYED_TEMPLATE_PARSING
auto f(); // expected-note {{previous}} auto f(); // expected-note {{previous}}
int f(); // expected-error {{differ only in their return type}} int f(); // expected-error {{differ only in their return type}}
auto &g(); auto &g();
▲ Show 20 Lines • Show All 110 Lines • ▼ Show 20 Linesconst auto void_ret_4() {
return 0; // expected-error {{'auto' in return type deduced as 'int' here but deduced as 'void' in earlier return statement}} return 0; // expected-error {{'auto' in return type deduced as 'int' here but deduced as 'void' in earlier return statement}}
} }
namespace Templates { namespace Templates {
template<typename T> auto f1() { template<typename T> auto f1() {
return T() + 1; return T() + 1;
} }
template<typename T> auto &f2(T &&v) { return v; } template<typename T> auto &f2(T &&v) { return v; }
// cxx2b-error@-1 {{non-const lvalue reference to type 'int' cannot bind to a temporary of type 'int'}} // cxx23-error@-1 {{non-const lvalue reference to type 'int' cannot bind to a temporary of type 'int'}}
// cxx2b-error@-2 {{non-const lvalue reference to type 'double' cannot bind to a temporary of type 'double'}} // cxx23-error@-2 {{non-const lvalue reference to type 'double' cannot bind to a temporary of type 'double'}}
// cxx2b-note@-3 {{candidate template ignored: substitution failure [with T = double]}} // cxx23-note@-3 {{candidate template ignored: substitution failure [with T = double]}}
int a = f1<int>(); int a = f1<int>();
const int &b = f2(0); // cxx2b-note {{in instantiation of function template specialization 'Templates::f2<int>' requested here}} const int &b = f2(0); // cxx23-note {{in instantiation of function template specialization 'Templates::f2<int>' requested here}}
double d; double d;
float &c = f2(0.0); // expected-error {{non-const lvalue reference to type 'float' cannot bind to a value of unrelated type 'double'}} float &c = f2(0.0); // expected-error {{non-const lvalue reference to type 'float' cannot bind to a value of unrelated type 'double'}}
// cxx2b-note@-1 {{in instantiation of function template specialization 'Templates::f2<double>' requested here}} // cxx23-note@-1 {{in instantiation of function template specialization 'Templates::f2<double>' requested here}}
template<typename T> auto fwd_decl(); // expected-note {{declared here}} template<typename T> auto fwd_decl(); // expected-note {{declared here}}
int e = fwd_decl<int>(); // expected-error {{cannot be used before it is defined}} int e = fwd_decl<int>(); // expected-error {{cannot be used before it is defined}}
template<typename T> auto fwd_decl() { return 0; } template<typename T> auto fwd_decl() { return 0; }
int f = fwd_decl<int>(); int f = fwd_decl<int>();
template <typename T> template <typename T>
auto fwd_decl(); // expected-note {{candidate template ignored: could not match 'auto ()' against 'int ()'}} auto fwd_decl(); // expected-note {{candidate template ignored: could not match 'auto ()' against 'int ()'}}
int g = fwd_decl<char>(); int g = fwd_decl<char>();
auto (*p)() = f1; // expected-error {{variable 'p' with type 'auto (*)()' has incompatible initializer of type '<overloaded function type>'}} auto (*p)() = f1; // expected-error {{variable 'p' with type 'auto (*)()' has incompatible initializer of type '<overloaded function type>'}}
auto (*q)() = f1<int>; // ok auto (*q)() = f1<int>; // ok
typedef decltype(f2(1.2)) dbl; // cxx14_20-note {{previous}} typedef decltype(f2(1.2)) dbl; // cxx14_20-note {{previous}}
// cxx2b-error@-1 {{no matching function for call to 'f2'}} // cxx23-error@-1 {{no matching function for call to 'f2'}}
typedef float dbl; // cxx14_20-error {{typedef redefinition with different types ('float' vs 'decltype(f2(1.2))' (aka 'double &'))}} typedef float dbl; // cxx14_20-error {{typedef redefinition with different types ('float' vs 'decltype(f2(1.2))' (aka 'double &'))}}
extern template auto fwd_decl<double>(); extern template auto fwd_decl<double>();
int k1 = fwd_decl<double>(); int k1 = fwd_decl<double>();
extern template int fwd_decl<char>(); // expected-error {{does not refer to a function template}} extern template int fwd_decl<char>(); // expected-error {{does not refer to a function template}}
int k2 = fwd_decl<char>(); int k2 = fwd_decl<char>();
template <typename T> auto instantiate() { T::error; } // expected-error {{has no members}} \ template <typename T> auto instantiate() { T::error; } // expected-error {{has no members}} \
▲ Show 20 Lines • Show All 132 Lines • ▼ Show 20 Linesnamespace Constexpr {
template<typename T> struct X { constexpr auto f() {} }; // PR18746 template<typename T> struct X { constexpr auto f() {} }; // PR18746
template<typename T> struct Y { constexpr T f() {} }; // expected-note {{control reached end of constexpr function}} template<typename T> struct Y { constexpr T f() {} }; // expected-note {{control reached end of constexpr function}}
void f() { void f() {
X<int>().f(); X<int>().f();
Y<void>().f(); Y<void>().f();
constexpr int q = Y<int>().f(); // expected-error {{must be initialized by a constant expression}} expected-note {{in call to '&Y<int>()->f()'}} constexpr int q = Y<int>().f(); // expected-error {{must be initialized by a constant expression}} expected-note {{in call to '&Y<int>()->f()'}}
} }
struct NonLiteral { ~NonLiteral(); } nl; // cxx14-note {{user-provided destructor}} struct NonLiteral { ~NonLiteral(); } nl; // cxx14-note {{user-provided destructor}}
// cxx20_2b-note@-1 {{'NonLiteral' is not literal because its destructor is not constexpr}} // cxx20_23-note@-1 {{'NonLiteral' is not literal because its destructor is not constexpr}}
constexpr auto f2(int n) { return nl; } // expected-error {{return type 'struct NonLiteral' is not a literal type}} constexpr auto f2(int n) { return nl; } // expected-error {{return type 'struct NonLiteral' is not a literal type}}
} }
// It's not really clear whether these are valid, but this matches g++. // It's not really clear whether these are valid, but this matches g++.
using size_t = decltype(sizeof(0)); using size_t = decltype(sizeof(0));
auto operator new(size_t n, const char*); // expected-error {{must return type 'void *'}} auto operator new(size_t n, const char*); // expected-error {{must return type 'void *'}}
auto operator delete(void *, const char*); // expected-error {{must return type 'void'}} auto operator delete(void *, const char*); // expected-error {{must return type 'void'}}
▲ Show 20 Lines • Show All 332 Lines • Show Last 20 Lines

clang/test/SemaCXX/lambda-capture-type-deduction.cpp

// RUN: %clang_cc1 -std=c++2b -verify -fsyntax-only %s // RUN: %clang_cc1 -std=c++23 -verify -fsyntax-only %s
template <typename T, typename U> template <typename T, typename U>
constexpr bool is_same = false; constexpr bool is_same = false;
template <typename T> template <typename T>
constexpr bool is_same<T, T> = true; constexpr bool is_same<T, T> = true;
void f() { void f() {
▲ Show 20 Lines • Show All 239 Lines • Show Last 20 Lines

clang/test/SemaCXX/lambda-expressions.cpp

Show First 20 Lines • Show All 703 Lines • ▼ Show 20 Lines
}()); }());
} // namespace GH60936 } // namespace GH60936
#endif #endif
// Call operator attributes refering to a variable should // Call operator attributes refering to a variable should
// be properly handled after D124351 // be properly handled after D124351
constexpr int i = 2; constexpr int i = 2;
void foo() { void foo() {
(void)[=][[gnu::aligned(i)]] () {}; // expected-warning{{C++2b extension}} (void)[=][[gnu::aligned(i)]] () {}; // expected-warning{{C++23 extension}}
// CHECK: AlignedAttr // CHECK: AlignedAttr
// CHECK-NEXT: ConstantExpr // CHECK-NEXT: ConstantExpr
// CHECK-NEXT: value: Int 2 // CHECK-NEXT: value: Int 2
} }

clang/test/SemaCXX/lambda-unevaluated.cpp

// RUN: %clang_cc1 -std=c++20 %s -Wno-c++2b-extensions -verify // RUN: %clang_cc1 -std=c++20 %s -Wno-c++23-extensions -verify
// RUN: %clang_cc1 -std=c++2b %s -verify // RUN: %clang_cc1 -std=c++23 %s -verify
template <auto> struct Nothing {}; template <auto> struct Nothing {};
Nothing<[]() { return 0; }()> nothing; Nothing<[]() { return 0; }()> nothing;
template <typename> struct NothingT {}; template <typename> struct NothingT {};
Nothing<[]() { return 0; }> nothingT; Nothing<[]() { return 0; }> nothingT;
▲ Show 20 Lines • Show All 138 Lines • Show Last 20 Lines

clang/test/SemaCXX/libcxx_is_trivially_equality_comparable_hack.cpp

// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only -verify -std=gnu++20 -fms-extensions -Wno-microsoft %s // RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only -verify -std=gnu++20 -fms-extensions -Wno-microsoft %s
// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only -verify -std=gnu++2b -fms-extensions -Wno-microsoft %s // RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only -verify -std=gnu++23 -fms-extensions -Wno-microsoft %s
template <class T, class U> template <class T, class U>
struct Same { struct Same {
static constexpr auto value = __is_same(T, U); static constexpr auto value = __is_same(T, U);
}; };
template <class T> template <class T>
struct __is_trivially_equality_comparable { // expected-warning{{keyword '__is_trivially_equality_comparable' will be made available as an identifier for the remainder of the translation unit}} struct __is_trivially_equality_comparable { // expected-warning{{keyword '__is_trivially_equality_comparable' will be made available as an identifier for the remainder of the translation unit}}
using type = T; using type = T;
}; };
using A = Same<__is_trivially_equality_comparable<int>::type, __is_trivially_equality_comparable<int>::type>; using A = Same<__is_trivially_equality_comparable<int>::type, __is_trivially_equality_comparable<int>::type>;

clang/test/SemaCXX/overloaded-operator-decl.cpp

Show First 20 Lines • Show All 45 Lines • ▼ Show 20 Lines
struct PR10839 { struct PR10839 {
operator int; // expected-error{{'operator int' cannot be the name of a variable or data member}} operator int; // expected-error{{'operator int' cannot be the name of a variable or data member}}
int operator+; // expected-error{{'operator+' cannot be the name of a variable or data member}} int operator+; // expected-error{{'operator+' cannot be the name of a variable or data member}}
}; };
namespace PR14120 { namespace PR14120 {
struct A { struct A {
static void operator()(int& i) { ++i; } // expected-warning{{is a C++2b extension}} static void operator()(int& i) { ++i; } // expected-warning{{is a C++23 extension}}
}; };
void f() { void f() {
int i = 0; int i = 0;
A()(i); A()(i);
} }
} }

clang/test/SemaCXX/return-stack-addr.cpp

// RUN: %clang_cc1 -std=c++2b -fsyntax-only -verify=expected,cxx2b %s // RUN: %clang_cc1 -std=c++23 -fsyntax-only -verify=expected,cxx23 %s
// RUN: %clang_cc1 -std=c++20 -fsyntax-only -verify=expected,cxx11_20 %s // RUN: %clang_cc1 -std=c++20 -fsyntax-only -verify=expected,cxx11_20 %s
// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify=expected,cxx11_20,cxx11 %s // RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify=expected,cxx11_20,cxx11 %s
int* ret_local() { int* ret_local() {
int x = 1; int x = 1;
return &x; // expected-warning {{address of stack memory}} return &x; // expected-warning {{address of stack memory}}
} }
Show All 15 Lines
int* ret_local_array_element_const_index() { int* ret_local_array_element_const_index() {
int x[10]; int x[10];
return &x[2]; // expected-warning {{address of stack memory}} return &x[2]; // expected-warning {{address of stack memory}}
} }
int& ret_local_ref() { int& ret_local_ref() {
int x = 1; int x = 1;
return x; // cxx11_20-warning {{reference to stack memory}} return x; // cxx11_20-warning {{reference to stack memory}}
// cxx2b-error@-1 {{non-const lvalue reference to type 'int' cannot bind to a temporary of type 'int'}} // cxx23-error@-1 {{non-const lvalue reference to type 'int' cannot bind to a temporary of type 'int'}}
} }
int* ret_local_addrOf() { int* ret_local_addrOf() {
int x = 1; int x = 1;
return &*&x; // expected-warning {{address of stack memory}} return &*&x; // expected-warning {{address of stack memory}}
} }
int* ret_local_addrOf_paren() { int* ret_local_addrOf_paren() {
▲ Show 20 Lines • Show All 109 Lines • ▼ Show 20 Lines
void ret_from_lambda() { void ret_from_lambda() {
int a; int a;
int &b = a; int &b = a;
(void) [&]() -> int& { return a; }; (void) [&]() -> int& { return a; };
(void) [&]() -> int& { return b; }; (void) [&]() -> int& { return b; };
(void) [=]() mutable -> int& { return a; }; (void) [=]() mutable -> int& { return a; };
(void) [=]() mutable -> int& { return b; }; (void) [=]() mutable -> int& { return b; };
(void) [&]() -> int& { int a; return a; }; // cxx11_20-warning {{reference to stack}} (void) [&]() -> int& { int a; return a; }; // cxx11_20-warning {{reference to stack}}
// cxx2b-error@-1 {{non-const lvalue reference to type 'int' cannot bind to a temporary of type 'int'}} // cxx23-error@-1 {{non-const lvalue reference to type 'int' cannot bind to a temporary of type 'int'}}
(void) [=]() -> int& { int a; return a; }; // cxx11_20-warning {{reference to stack}} (void) [=]() -> int& { int a; return a; }; // cxx11_20-warning {{reference to stack}}
// cxx2b-error@-1 {{non-const lvalue reference to type 'int' cannot bind to a temporary of type 'int'}} // cxx23-error@-1 {{non-const lvalue reference to type 'int' cannot bind to a temporary of type 'int'}}
(void) [&]() -> int& { int &a = b; return a; }; (void) [&]() -> int& { int &a = b; return a; };
(void) [=]() mutable -> int& { int &a = b; return a; }; (void) [=]() mutable -> int& { int &a = b; return a; };
(void) [] { (void) [] {
int a; int a;
return [&] { // expected-warning {{address of stack memory associated with local variable 'a' returned}} return [&] { // expected-warning {{address of stack memory associated with local variable 'a' returned}}
return a; // expected-note {{implicitly captured by reference due to use here}} return a; // expected-note {{implicitly captured by reference due to use here}}
}; };
▲ Show 20 Lines • Show All 57 Lines • Show Last 20 Lines

clang/test/SemaCXX/size_t-literal.cpp

// RUN: %clang_cc1 -std=c++2b -triple x86_64-linux -Wpre-c++2b-compat -fsyntax-only -verify=cxx2b %s // RUN: %clang_cc1 -std=c++23 -triple x86_64-linux -Wpre-c++23-compat -fsyntax-only -verify=cxx23 %s
// RUN: %clang_cc1 -std=c++20 -triple x86_64-linux -fsyntax-only -verify=cxx20 %s // RUN: %clang_cc1 -std=c++20 -triple x86_64-linux -fsyntax-only -verify=cxx20 %s
// RUN: %clang_cc1 -std=c++2b -triple i686-linux -fsyntax-only -verify=cxx2b-32 %s // RUN: %clang_cc1 -std=c++23 -triple i686-linux -fsyntax-only -verify=cxx23-32 %s
// RUN: %clang_cc1 -x c -std=c11 -fsyntax-only -verify=c11 %s // RUN: %clang_cc1 -x c -std=c11 -fsyntax-only -verify=c11 %s
#ifdef __cplusplus #ifdef __cplusplus
typedef __SIZE_TYPE__ size_t; typedef __SIZE_TYPE__ size_t;
// Assume ptrdiff_t is the signed integer type corresponding to size_t. // Assume ptrdiff_t is the signed integer type corresponding to size_t.
typedef __PTRDIFF_TYPE__ ssize_t; typedef __PTRDIFF_TYPE__ ssize_t;
template <typename, typename> template <typename, typename>
struct is_same { static constexpr bool value = false; }; struct is_same { static constexpr bool value = false; };
template <typename T> template <typename T>
struct is_same<T, T> { static constexpr bool value = true; }; struct is_same<T, T> { static constexpr bool value = true; };
void SSizeT(void) { void SSizeT(void) {
auto a1 = 1z; auto a1 = 1z;
// cxx2b-warning@-1 {{'size_t' suffix for literals is incompatible with C++ standards before C++2b}} // cxx23-warning@-1 {{'size_t' suffix for literals is incompatible with C++ standards before C++23}}
// cxx20-warning@-2 {{'size_t' suffix for literals is a C++2b extension}} // cxx20-warning@-2 {{'size_t' suffix for literals is a C++23 extension}}
static_assert(is_same<decltype(a1), ssize_t>::value); static_assert(is_same<decltype(a1), ssize_t>::value);
auto a2 = 1Z; auto a2 = 1Z;
// cxx2b-warning@-1 {{'size_t' suffix for literals is incompatible with C++ standards before C++2b}} // cxx23-warning@-1 {{'size_t' suffix for literals is incompatible with C++ standards before C++23}}
// cxx20-warning@-2 {{'size_t' suffix for literals is a C++2b extension}} // cxx20-warning@-2 {{'size_t' suffix for literals is a C++23 extension}}
static_assert(is_same<decltype(a2), ssize_t>::value); static_assert(is_same<decltype(a2), ssize_t>::value);
} }
void SizeT(void) { void SizeT(void) {
auto a1 = 1uz; auto a1 = 1uz;
// cxx2b-warning@-1 {{'size_t' suffix for literals is incompatible with C++ standards before C++2b}} // cxx23-warning@-1 {{'size_t' suffix for literals is incompatible with C++ standards before C++23}}
// cxx20-warning@-2 {{'size_t' suffix for literals is a C++2b extension}} // cxx20-warning@-2 {{'size_t' suffix for literals is a C++23 extension}}
static_assert(is_same<decltype(a1), size_t>::value); static_assert(is_same<decltype(a1), size_t>::value);
auto a2 = 1uZ; auto a2 = 1uZ;
// cxx2b-warning@-1 {{'size_t' suffix for literals is incompatible with C++ standards before C++2b}} // cxx23-warning@-1 {{'size_t' suffix for literals is incompatible with C++ standards before C++23}}
// cxx20-warning@-2 {{'size_t' suffix for literals is a C++2b extension}} // cxx20-warning@-2 {{'size_t' suffix for literals is a C++23 extension}}
static_assert(is_same<decltype(a2), size_t>::value); static_assert(is_same<decltype(a2), size_t>::value);
auto a3 = 1Uz; auto a3 = 1Uz;
// cxx2b-warning@-1 {{'size_t' suffix for literals is incompatible with C++ standards before C++2b}} // cxx23-warning@-1 {{'size_t' suffix for literals is incompatible with C++ standards before C++23}}
// cxx20-warning@-2 {{'size_t' suffix for literals is a C++2b extension}} // cxx20-warning@-2 {{'size_t' suffix for literals is a C++23 extension}}
static_assert(is_same<decltype(a3), size_t>::value); static_assert(is_same<decltype(a3), size_t>::value);
auto a4 = 1UZ; auto a4 = 1UZ;
// cxx2b-warning@-1 {{'size_t' suffix for literals is incompatible with C++ standards before C++2b}} // cxx23-warning@-1 {{'size_t' suffix for literals is incompatible with C++ standards before C++23}}
// cxx20-warning@-2 {{'size_t' suffix for literals is a C++2b extension}} // cxx20-warning@-2 {{'size_t' suffix for literals is a C++23 extension}}
static_assert(is_same<decltype(a4), size_t>::value); static_assert(is_same<decltype(a4), size_t>::value);
auto a5 = 1zu; auto a5 = 1zu;
// cxx2b-warning@-1 {{'size_t' suffix for literals is incompatible with C++ standards before C++2b}} // cxx23-warning@-1 {{'size_t' suffix for literals is incompatible with C++ standards before C++23}}
// cxx20-warning@-2 {{'size_t' suffix for literals is a C++2b extension}} // cxx20-warning@-2 {{'size_t' suffix for literals is a C++23 extension}}
static_assert(is_same<decltype(a5), size_t>::value); static_assert(is_same<decltype(a5), size_t>::value);
auto a6 = 1Zu; auto a6 = 1Zu;
// cxx2b-warning@-1 {{'size_t' suffix for literals is incompatible with C++ standards before C++2b}} // cxx23-warning@-1 {{'size_t' suffix for literals is incompatible with C++ standards before C++23}}
// cxx20-warning@-2 {{'size_t' suffix for literals is a C++2b extension}} // cxx20-warning@-2 {{'size_t' suffix for literals is a C++23 extension}}
static_assert(is_same<decltype(a6), size_t>::value); static_assert(is_same<decltype(a6), size_t>::value);
auto a7 = 1zU; auto a7 = 1zU;
// cxx2b-warning@-1 {{'size_t' suffix for literals is incompatible with C++ standards before C++2b}} // cxx23-warning@-1 {{'size_t' suffix for literals is incompatible with C++ standards before C++23}}
// cxx20-warning@-2 {{'size_t' suffix for literals is a C++2b extension}} // cxx20-warning@-2 {{'size_t' suffix for literals is a C++23 extension}}
static_assert(is_same<decltype(a7), size_t>::value); static_assert(is_same<decltype(a7), size_t>::value);
auto a8 = 1ZU; auto a8 = 1ZU;
// cxx2b-warning@-1 {{'size_t' suffix for literals is incompatible with C++ standards before C++2b}} // cxx23-warning@-1 {{'size_t' suffix for literals is incompatible with C++ standards before C++23}}
// cxx20-warning@-2 {{'size_t' suffix for literals is a C++2b extension}} // cxx20-warning@-2 {{'size_t' suffix for literals is a C++23 extension}}
static_assert(is_same<decltype(a8), size_t>::value); static_assert(is_same<decltype(a8), size_t>::value);
} }
void oor(void) { void oor(void) {
#if __i386__ #if __i386__
(void)3'000'000'000z; // cxx2b-32-error {{signed 'size_t' literal is out of range of possible signed 'size_t' values}} (void)3'000'000'000z; // cxx23-32-error {{signed 'size_t' literal is out of range of possible signed 'size_t' values}}
(void)3'000'000'000uz; (void)3'000'000'000uz;
(void)5'000'000'000uz; // cxx2b-32-error {{'size_t' literal is out of range of possible 'size_t' values}} (void)5'000'000'000uz; // cxx23-32-error {{'size_t' literal is out of range of possible 'size_t' values}}
(void)0x80000000z; (void)0x80000000z;
(void)0x80000000uz; (void)0x80000000uz;
(void)0x180000000uz; //cxx2b-32-error {{'size_t' literal is out of range of possible 'size_t' values}} (void)0x180000000uz; //cxx23-32-error {{'size_t' literal is out of range of possible 'size_t' values}}
#endif #endif
} }
#else #else
void f(void) { void f(void) {
(void)1z; // c11-error {{'size_t' suffix for literals is a C++2b feature}} (void)1z; // c11-error {{'size_t' suffix for literals is a C++23 feature}}
(void)1Z; // c11-error {{'size_t' suffix for literals is a C++2b feature}} (void)1Z; // c11-error {{'size_t' suffix for literals is a C++23 feature}}
(void)1uz; // c11-error {{'size_t' suffix for literals is a C++2b feature}} (void)1uz; // c11-error {{'size_t' suffix for literals is a C++23 feature}}
(void)1uZ; // c11-error {{'size_t' suffix for literals is a C++2b feature}} (void)1uZ; // c11-error {{'size_t' suffix for literals is a C++23 feature}}
(void)1Uz; // c11-error {{'size_t' suffix for literals is a C++2b feature}} (void)1Uz; // c11-error {{'size_t' suffix for literals is a C++23 feature}}
(void)1UZ; // c11-error {{'size_t' suffix for literals is a C++2b feature}} (void)1UZ; // c11-error {{'size_t' suffix for literals is a C++23 feature}}
(void)1zu; // c11-error {{'size_t' suffix for literals is a C++2b feature}} (void)1zu; // c11-error {{'size_t' suffix for literals is a C++23 feature}}
(void)1Zu; // c11-error {{'size_t' suffix for literals is a C++2b feature}} (void)1Zu; // c11-error {{'size_t' suffix for literals is a C++23 feature}}
(void)1zU; // c11-error {{'size_t' suffix for literals is a C++2b feature}} (void)1zU; // c11-error {{'size_t' suffix for literals is a C++23 feature}}
(void)1ZU; // c11-error {{'size_t' suffix for literals is a C++2b feature}} (void)1ZU; // c11-error {{'size_t' suffix for literals is a C++23 feature}}
} }
#endif #endif

clang/test/SemaObjCXX/block-capture.mm

// RUN: %clang_cc1 -std=c++2b -fsyntax-only -fobjc-arc -fblocks -verify=cxx98_2b,cxx11_2b,cxx2b %s // RUN: %clang_cc1 -std=c++23 -fsyntax-only -fobjc-arc -fblocks -verify=cxx98_23,cxx11_23,cxx23 %s
// RUN: %clang_cc1 -std=c++20 -fsyntax-only -fobjc-arc -fblocks -verify=cxx98_2b,cxx11_2b %s // RUN: %clang_cc1 -std=c++20 -fsyntax-only -fobjc-arc -fblocks -verify=cxx98_23,cxx11_23 %s
// RUN: %clang_cc1 -std=c++11 -fsyntax-only -fobjc-arc -fblocks -verify=cxx98_2b,cxx11_2b %s // RUN: %clang_cc1 -std=c++11 -fsyntax-only -fobjc-arc -fblocks -verify=cxx98_23,cxx11_23 %s
// RUN: %clang_cc1 -std=c++98 -fsyntax-only -fobjc-arc -fblocks -Wno-c++11-extensions -verify=cxx98_2b,cxx98 %s // RUN: %clang_cc1 -std=c++98 -fsyntax-only -fobjc-arc -fblocks -Wno-c++11-extensions -verify=cxx98_23,cxx98 %s
#define TEST(T) void test_##T() { \ #define TEST(T) void test_##T() { \
__block T x; \ __block T x; \
(void)^(void) { (void)x; }; \ (void)^(void) { (void)x; }; \
} }
struct CopyOnly { struct CopyOnly {
CopyOnly(); // cxx2b-note {{not viable}} CopyOnly(); // cxx23-note {{not viable}}
CopyOnly(CopyOnly &); // cxx2b-note {{not viable}} CopyOnly(CopyOnly &); // cxx23-note {{not viable}}
}; };
TEST(CopyOnly); // cxx2b-error {{no matching constructor}} TEST(CopyOnly); // cxx23-error {{no matching constructor}}
// Both ConstCopyOnly and NonConstCopyOnly are // Both ConstCopyOnly and NonConstCopyOnly are
// "pure" C++98 tests (pretend 'delete' means 'private'). // "pure" C++98 tests (pretend 'delete' means 'private').
// However we may extend implicit moves into C++98, we must make sure the // However we may extend implicit moves into C++98, we must make sure the
// results in these are not changed. // results in these are not changed.
struct ConstCopyOnly { struct ConstCopyOnly {
ConstCopyOnly(); ConstCopyOnly();
ConstCopyOnly(ConstCopyOnly &) = delete; // cxx98-note {{marked deleted here}} ConstCopyOnly(ConstCopyOnly &) = delete; // cxx98-note {{marked deleted here}}
ConstCopyOnly(const ConstCopyOnly &); ConstCopyOnly(const ConstCopyOnly &);
}; };
TEST(ConstCopyOnly); // cxx98-error {{call to deleted constructor}} TEST(ConstCopyOnly); // cxx98-error {{call to deleted constructor}}
struct NonConstCopyOnly { struct NonConstCopyOnly {
NonConstCopyOnly(); NonConstCopyOnly();
NonConstCopyOnly(NonConstCopyOnly &); NonConstCopyOnly(NonConstCopyOnly &);
NonConstCopyOnly(const NonConstCopyOnly &) = delete; // cxx11_2b-note {{marked deleted here}} NonConstCopyOnly(const NonConstCopyOnly &) = delete; // cxx11_23-note {{marked deleted here}}
}; };
TEST(NonConstCopyOnly); // cxx11_2b-error {{call to deleted constructor}} TEST(NonConstCopyOnly); // cxx11_23-error {{call to deleted constructor}}
struct CopyNoMove { struct CopyNoMove {
CopyNoMove(); CopyNoMove();
CopyNoMove(CopyNoMove &); CopyNoMove(CopyNoMove &);
CopyNoMove(CopyNoMove &&) = delete; // cxx98_2b-note {{marked deleted here}} CopyNoMove(CopyNoMove &&) = delete; // cxx98_23-note {{marked deleted here}}
}; };
TEST(CopyNoMove); // cxx98_2b-error {{call to deleted constructor}} TEST(CopyNoMove); // cxx98_23-error {{call to deleted constructor}}
struct MoveOnly { struct MoveOnly {
MoveOnly(); MoveOnly();
MoveOnly(MoveOnly &) = delete; MoveOnly(MoveOnly &) = delete;
MoveOnly(MoveOnly &&); MoveOnly(MoveOnly &&);
}; };
TEST(MoveOnly); TEST(MoveOnly);
struct NoCopyNoMove { struct NoCopyNoMove {
NoCopyNoMove(); NoCopyNoMove();
NoCopyNoMove(NoCopyNoMove &) = delete; NoCopyNoMove(NoCopyNoMove &) = delete;
NoCopyNoMove(NoCopyNoMove &&) = delete; // cxx98_2b-note {{marked deleted here}} NoCopyNoMove(NoCopyNoMove &&) = delete; // cxx98_23-note {{marked deleted here}}
}; };
TEST(NoCopyNoMove); // cxx98_2b-error {{call to deleted constructor}} TEST(NoCopyNoMove); // cxx98_23-error {{call to deleted constructor}}
struct ConvertingRVRef { struct ConvertingRVRef {
ConvertingRVRef(); ConvertingRVRef();
ConvertingRVRef(ConvertingRVRef &) = delete; ConvertingRVRef(ConvertingRVRef &) = delete;
struct X {}; struct X {};
ConvertingRVRef(X &&); ConvertingRVRef(X &&);
operator X() const & = delete; operator X() const & = delete;
operator X() &&; operator X() &&;
}; };
TEST(ConvertingRVRef); TEST(ConvertingRVRef);
struct ConvertingCLVRef { struct ConvertingCLVRef {
ConvertingCLVRef(); ConvertingCLVRef();
ConvertingCLVRef(ConvertingCLVRef &); ConvertingCLVRef(ConvertingCLVRef &);
struct X {}; struct X {};
ConvertingCLVRef(X &&); // cxx98_2b-note {{passing argument to parameter here}} ConvertingCLVRef(X &&); // cxx98_23-note {{passing argument to parameter here}}
operator X() const &; operator X() const &;
operator X() && = delete; // cxx98_2b-note {{marked deleted here}} operator X() && = delete; // cxx98_23-note {{marked deleted here}}
}; };
TEST(ConvertingCLVRef); // cxx98_2b-error {{invokes a deleted function}} TEST(ConvertingCLVRef); // cxx98_23-error {{invokes a deleted function}}
struct SubSubMove {}; struct SubSubMove {};
struct SubMove : SubSubMove { struct SubMove : SubSubMove {
SubMove(); SubMove();
SubMove(SubMove &) = delete; SubMove(SubMove &) = delete;
SubMove(SubSubMove &&); SubMove(SubSubMove &&);
}; };
TEST(SubMove); TEST(SubMove);

clang/test/SemaOpenCLCXX/address-space-lambda.clcpp

Show First 20 Lines • Show All 57 Lines • ▼ Show 20 Lines//CHECK: |-CXXMethodDecl {{.*}} constexpr operator() 'void () {{.*}}const __constant'
__constant auto const3 = []() __constant{}; __constant auto const3 = []() __constant{};
const3(); const3();
[&] () __global {} (); //expected-error{{no matching function for call to object of type '(lambda at}} expected-note{{candidate function not viable: 'this' object is in default address space, but method expects object in address space '__global'}} [&] () __global {} (); //expected-error{{no matching function for call to object of type '(lambda at}} expected-note{{candidate function not viable: 'this' object is in default address space, but method expects object in address space '__global'}}
[&] () __private {} (); //expected-error{{no matching function for call to object of type '(lambda at}} expected-note{{candidate function not viable: 'this' object is in default address space, but method expects object in address space '__private'}} [&] () __private {} (); //expected-error{{no matching function for call to object of type '(lambda at}} expected-note{{candidate function not viable: 'this' object is in default address space, but method expects object in address space '__private'}}
[&] __private {} (); // expected-error{{no matching function for call to object of type '(lambda at}} expected-note{{candidate function not viable: 'this' object is in default address space, but method expects object in address space '__private'}} [&] __private {} (); // expected-error{{no matching function for call to object of type '(lambda at}} expected-note{{candidate function not viable: 'this' object is in default address space, but method expects object in address space '__private'}}
#if __cplusplus <= 202002L #if __cplusplus <= 202002L
// expected-warning@-2{{lambda without a parameter clause is a C++2b extension}} // expected-warning@-2{{lambda without a parameter clause is a C++23 extension}}
#endif #endif
[&] () mutable __private {} (); [&] () mutable __private {} ();
[&] () __private mutable {} (); //expected-error{{expected body of lambda expression}} [&] () __private mutable {} (); //expected-error{{expected body of lambda expression}}
} }

clang/test/SemaTemplate/deduction.cpp

// RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++11 // RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++11
// RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++1z // RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++17
// RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++2b // RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++23
// Template argument deduction with template template parameters. // Template argument deduction with template template parameters.
template<typename T, template<T> class A> template<typename T, template<T> class A>
struct X0 { struct X0 {
static const unsigned value = 0; static const unsigned value = 0;
}; };
template<template<int> class A> template<template<int> class A>
▲ Show 20 Lines • Show All 675 Lines • Show Last 20 Lines

clang/test/SemaTemplate/instantiate-subscript.cpp

// RUN: %clang_cc1 -fsyntax-only -verify %s // RUN: %clang_cc1 -fsyntax-only -verify %s
// RUN: %clang_cc1 -fsyntax-only -verify -std=c++2b %s // RUN: %clang_cc1 -fsyntax-only -verify -std=c++23 %s
struct Sub0 { struct Sub0 {
int &operator[](int); int &operator[](int);
}; };
struct Sub1 { struct Sub1 {
long &operator[](long); // expected-note{{candidate function}} long &operator[](long); // expected-note{{candidate function}}
}; };
Show All 31 Lines

clang/test/SemaTemplate/instantiation-dependence.cpp

// RUN: %clang_cc1 -std=c++2b -verify %s // RUN: %clang_cc1 -std=c++23 -verify %s
// Ensure we substitute into instantiation-dependent but non-dependent // Ensure we substitute into instantiation-dependent but non-dependent
// constructs. The poster-child for this is... // constructs. The poster-child for this is...
template<class ...> using void_t = void; template<class ...> using void_t = void;
namespace PR24076 { namespace PR24076 {
template<class T> T declval(); template<class T> T declval();
struct s {}; struct s {};
▲ Show 20 Lines • Show All 96 Lines • Show Last 20 Lines

clang/test/SemaTemplate/make_integer_seq.cpp

// RUN: %clang_cc1 -std=c++2b -fsyntax-only -triple x86_64-linux-gnu -ast-dump -verify -xc++ < %s | FileCheck %s // RUN: %clang_cc1 -std=c++23 -fsyntax-only -triple x86_64-linux-gnu -ast-dump -verify -xc++ < %s | FileCheck %s
template <class A1, A1... A2> struct A {}; template <class A1, A1... A2> struct A {};
using test1 = __make_integer_seq<A, int, 1>; using test1 = __make_integer_seq<A, int, 1>;
// CHECK: |-TypeAliasDecl 0x{{[0-9A-Fa-f]+}} <line:5:1, col:43> col:7 test1 '__make_integer_seq<A, int, 1>':'A<int, 0>' // CHECK: |-TypeAliasDecl 0x{{[0-9A-Fa-f]+}} <line:5:1, col:43> col:7 test1 '__make_integer_seq<A, int, 1>':'A<int, 0>'
// CHECK-NEXT: `-ElaboratedType 0x{{[0-9A-Fa-f]+}} '__make_integer_seq<A, int, 1>' sugar // CHECK-NEXT: `-ElaboratedType 0x{{[0-9A-Fa-f]+}} '__make_integer_seq<A, int, 1>' sugar
// CHECK-NEXT: `-TemplateSpecializationType 0x{{[0-9A-Fa-f]+}} '__make_integer_seq<A, int, 1>' sugar alias __make_integer_seq // CHECK-NEXT: `-TemplateSpecializationType 0x{{[0-9A-Fa-f]+}} '__make_integer_seq<A, int, 1>' sugar alias __make_integer_seq
// CHECK-NEXT: |-TemplateArgument template A // CHECK-NEXT: |-TemplateArgument template A
▲ Show 20 Lines • Show All 131 Lines • Show Last 20 Lines

clang/test/SemaTemplate/pr52909.cpp

// RUN: %clang_cc1 -std=c++20 -verify %s // RUN: %clang_cc1 -std=c++20 -verify %s
// RUN: %clang_cc1 -std=c++2b -verify %s // RUN: %clang_cc1 -std=c++23 -verify %s
namespace PR52905 { namespace PR52905 {
template <class> concept C = true; template <class> concept C = true;
struct A { struct A {
int begin(); int begin();
int begin() const; int begin() const;
}; };
▲ Show 20 Lines • Show All 61 Lines • Show Last 20 Lines

clang/test/SemaTemplate/type_pack_element.cpp

// RUN: %clang_cc1 -std=c++2b -fsyntax-only -triple x86_64-linux-gnu -ast-dump -verify -xc++ < %s | FileCheck %s // RUN: %clang_cc1 -std=c++23 -fsyntax-only -triple x86_64-linux-gnu -ast-dump -verify -xc++ < %s | FileCheck %s
using test1 = __type_pack_element<0, int>; using test1 = __type_pack_element<0, int>;
// CHECK: |-TypeAliasDecl 0x{{[0-9A-Fa-f]+}} <<stdin>:3:1, col:41> col:7 test1 '__type_pack_element<0, int>':'int' // CHECK: |-TypeAliasDecl 0x{{[0-9A-Fa-f]+}} <<stdin>:3:1, col:41> col:7 test1 '__type_pack_element<0, int>':'int'
// CHECK-NEXT: `-ElaboratedType 0x{{[0-9A-Fa-f]+}} '__type_pack_element<0, int>' sugar // CHECK-NEXT: `-ElaboratedType 0x{{[0-9A-Fa-f]+}} '__type_pack_element<0, int>' sugar
// CHECK-NEXT: `-TemplateSpecializationType 0x{{[0-9A-Fa-f]+}} '__type_pack_element<0, int>' sugar alias __type_pack_element // CHECK-NEXT: `-TemplateSpecializationType 0x{{[0-9A-Fa-f]+}} '__type_pack_element<0, int>' sugar alias __type_pack_element
// CHECK-NEXT: |-TemplateArgument expr // CHECK-NEXT: |-TemplateArgument expr
// CHECK-NEXT: | `-ConstantExpr 0x{{[0-9A-Fa-f]+}} <col:35> 'unsigned long' // CHECK-NEXT: | `-ConstantExpr 0x{{[0-9A-Fa-f]+}} <col:35> 'unsigned long'
// CHECK-NEXT: | |-value: Int 0 // CHECK-NEXT: | |-value: Int 0
▲ Show 20 Lines • Show All 82 Lines • Show Last 20 Lines

clang/www/OpenProjects.html

Show First 20 Lines • Show All 117 Lines • ▼ Show 20 Lines<ul>
<li>Improve parser reliability and error generation by automatically <li>Improve parser reliability and error generation by automatically
or randomly changing the input checking that clang doesn't crash and or randomly changing the input checking that clang doesn't crash and
that it doesn't generate excessive errors for small input that it doesn't generate excessive errors for small input
changes. Manipulating the input at both the text and token levels is changes. Manipulating the input at both the text and token levels is
likely to produce interesting test cases. likely to produce interesting test cases.
</ul> </ul>
</li> </li>
<li><b>Continue work on C++20, C++2b, and C2x support</b>: <li><b>Continue work on C++20, C++23, and C2x support</b>:
There are still several C++20 features to complete, and work has begun on There are still several C++20 features to complete, and work has begun on
supporting the latest language standards. Please see the supporting the latest language standards. Please see the
<a href="cxx_status.html">C++ status report page</a> to find out what is <a href="cxx_status.html">C++ status report page</a> to find out what is
missing.</li> missing.</li>
<li><b>StringRef'ize APIs</b>: A thankless but incredibly useful project is <li><b>StringRef'ize APIs</b>: A thankless but incredibly useful project is
StringRef'izing (converting to use <tt>llvm::StringRef</tt> instead of <tt>const StringRef'izing (converting to use <tt>llvm::StringRef</tt> instead of <tt>const
char *</tt> or <tt>std::string</tt>) various clang interfaces. This generally char *</tt> or <tt>std::string</tt>) various clang interfaces. This generally
Show All 34 Lines

clang/www/cxx_status.html

Show First 20 Lines • Show All 55 Lines • ▼ Show 20 Lines
<td class="full" align="center">Clang 5</td> <td class="full" align="center">Clang 5</td>
</tr> </tr>
<tr> <tr>
<td><a href="#cxx20">C++20</a></td> <td><a href="#cxx20">C++20</a></td>
<td><tt>-std=c++20</tt></td> <td><tt>-std=c++20</tt></td>
<td class="partial" align="center">Partial</td> <td class="partial" align="center">Partial</td>
</tr> </tr>
<tr> <tr>
<td><a href="#cxx23">C++2b (tentatively C++23)</a></td> <td><a href="#cxx23">C++23</a></td>
<td><tt>-std=c++2b</tt></td> <td><tt>-std=c++23</tt></td>
<td class="partial" align="center">Partial</td> <td class="partial" align="center">Partial</td>
</tr> </tr>
</table> </table>
<p>The Clang community is continually striving to improve C++ standards <p>The Clang community is continually striving to improve C++ standards
compliance between releases by submitting and tracking <a compliance between releases by submitting and tracking <a
href="cxx_dr_status.html">C++ Defect Reports</a> and implementing resolutions href="cxx_dr_status.html">C++ Defect Reports</a> and implementing resolutions
as they become available.</p> as they become available.</p>
▲ Show 20 Lines • Show All 1,211 Lines • ▼ Show 20 Lines
<p> <p>
<span id="p0482">(11): Prior to Clang 8, this feature is not enabled by <span id="p0482">(11): Prior to Clang 8, this feature is not enabled by
<tt>-std=c++20</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> </span>
</p> </p>
</details> </details>
<h2 id="cxx23">C++2b implementation status</h2> <h2 id="cxx23">C++23 implementation status</h2>
<p>Clang has support for some of the features of the C++ standard following <!-- TODO add link to the ISO Standard after it's published. -->
C++20, informally referred to as C++2b.</p> <p>Clang has support for some of the features of the ISO C++ 2023 standard.</p>
<p>You can use Clang in C++2b mode with the <code>-std=c++2b</code> option.</p> <p>You can use Clang in C++23 mode with the <code>-std=c++23</code> option.</p>
<details open> <details open>
<summary>List of features and minimum Clang version with support</summary> <summary>List of features and minimum Clang version with support</summary>
<table width="689" border="1" cellspacing="0"> <table width="689" border="1" cellspacing="0">
<tr> <tr>
<th>Language Feature</th> <th>Language Feature</th>
<th>C++2b Proposal</th> <th>C++23 Proposal</th>
<th>Available in Clang?</th> <th>Available in Clang?</th>
</tr> </tr>
<!-- Fall 2020 papers --> <!-- Fall 2020 papers -->
<tr> <tr>
<td>Literal suffix <tt>uz</tt>, <tt>z</tt> for <tt>size_t</tt>, <tt>ssize_t</tt></td> <td>Literal suffix <tt>uz</tt>, <tt>z</tt> for <tt>size_t</tt>, <tt>ssize_t</tt></td>
<td><a href="https://wg21.link/p0330r8">P0330R8</a></td> <td><a href="https://wg21.link/p0330r8">P0330R8</a></td>
<td class="full" align="center">Clang 13</td> <td class="full" align="center">Clang 13</td>
</tr> </tr>
▲ Show 20 Lines • Show All 372 Lines • Show Last 20 Lines