[clang] adds unary type transformations as compiler built-ins

[cjdb]

Summary

Adds

• __add_lvalue_reference
• __add_pointer
• __add_rvalue_reference
• __decay
• __make_signed
• __make_unsigned
• __remove_all_extents
• __remove_extent
• __remove_const
• __remove_volatile
• __remove_cv
• __remove_pointer
• __remove_reference
• __remove_cvref

These are all compiler built-in equivalents of the unary type traits
found in [[meta.trans]][1]. The compiler already has all of the
information it needs to answer these transformations, so we can skip
needing to make partial specialisations in standard library
implementations (we already do this for a lot of the query traits). This
will hopefully improve compile times, as we won't need use as much
memory in such a base part of the standard library.

[1]: http://wg21.link/meta.trans

Co-authored-by: zoecarver

[rsmith]

clang/test/SemaCXX/type-traits.cpp

2862

Consider using the trait directly instead of wrapping it in an alias.

2986

This is should have some test coverage for restrict and for at least one non-standard qualifier. (Similarly for the remove_cvref and decay tests.)

3071

You seem to be missing coverage that __remove_pointer(const int*) preserves the const.
You also seem to be missing coverage that this works on a cv-qualified pointer, eg __remove_pointer(int *const) -> int.

3099–3100

It seems strange to remove the address space qualifier here, given that this trait doesn't remove cv-qualifiers.

3269

The tests you have here for references to pointers-to-members seem excessive (throughout); I don't think there's any reason to think that a reference to pointer-to-member would be so different from a reference to any other type that would justify this level of testing of the former case.

The cases that seem interesting here are the ones for non-referenceable types, but those are covered separately below.

3391

It's weird that we permit an abominable function type to show up in the argument of a trait during template instantiation but not when written directly. That behavior should really be consistent, and I think we should consistently allow it. That is, we should allow:

static_assert(__is_same(__add_pointer(int () &), int () &));

... just like we allow it if you hide the usage of the traits inside a template. That'd make this easier to test, too: you can then put these tests with the other tests for the corresponding traits. (This should only require passing DeclaratorContext::TemplateArg to ParseTypeName instead of the default of DeclaratorContext::TypeName in the places where we parse type traits, reflecting that we want to use the rules for template arguments in these contexts.) This would also fix an incompatibility between GCC and Clang: https://godbolt.org/z/GdxThdvjz

That said, I don't think we need to block this patch on this change, so if you'd prefer to not do this now, that's fine :)

3470

This is the wrong result type, it should be long long.

3495–3496

It'd be useful to test enums with different underlying types. However, this test is not portable: if short and int are the same size, this is required to produce short, not int. It'd be good to have some test coverage of that quirk too. Perhaps this is easiest to see with a test like:

enum E : long long {};
static_assert(__is_same(__make_signed(E), long));

... which should hold in cases where long and long long are the same size and are larger than int.

3822–3825

Please also test the case where the qualifiers are attached outside the array type:

using T = int[1][2];
static_assert(__is_same(__remove_all_extents(const T), const int), "");

[cjdb]

responds to the vast majority of open feedback

clang/lib/Parse/ParseDecl.cpp

4118

Comment added, but I'd prefer to keep the function call so it keeps the logic self-contained and named.

clang/lib/Sema/SemaType.cpp

9121

Is it a conforming extension for make_signed_t<int __attribute__((ext_vector_type(2)))> to work?

9124–9125

This makes me very happy.

9126–9129

As with decay, I think it's best if we pretend restrict is a standard qualifier, either for everything or for nothing. However, I don't think that restrict is a valid contender here. Isn't it only applicable to pointers, which aren't transformed by this pair?

9136

Done, and added a test.

9150

I think this is a no-op?

clang/test/CodeGenCXX/mangle.cpp

54 ↗

(On Diff #423716)

git-clang-format seems to insist these are formatted despite the lines not being touched. I'm not fond of arguing with clang-format.

1113 ↗

(On Diff #423716)

Per offline discussion, I think this is no longer being requested?

clang/test/SemaCXX/remove_pointer.mm

7 ↗

(On Diff #423716)

The rationale here is that we can assign __remove_pointer, etc., to a using declaration, which is how they're exposed to users.

12–46 ↗

(On Diff #423716)

Not knowing a lick of ObjC this was a fun one to get working (I didn't know that @class X had to be global).

clang/test/SemaCXX/type-traits.cpp

2862

Same as in remove_pointer.mm.

3099–3100

Does int __attribute__((address_space(1))) make sense as a type? I thought it had to be a pointee.

3269

I've removed all but one pointer-to-member function.

3391

Gonna defer to a separate CL, but will get it done one day soon :-)

3495–3496

I agree, but what about when long is smaller than int?

[cjdb]

clang/test/SemaCXX/type-traits.cpp

3495–3496

Bleh, this is impossible. What I meant to ask is what happens when long and int are the same size, I think?

[cjdb]

rebases

[cjdb]

• fixes wchar_t (wasn't supported) and charX_t (all three went to an 8-bit type)
• makes underlying type for signed wchar_t int rather than wchar_t
• adds tests for these types

[cjdb]

rebases to head, adds a comment to make something clearer

clang/lib/Parse/ParseExpr.cpp

1750 ↗

(On Diff #423716)

The parser needs to treat trait< as an identifier to accommodate libstdc++'s usage of a few of these as alias templates. I've added a comment to explain why in the code.

clang/lib/Sema/SemaType.cpp

9121

Gentle ping.

clang/test/SemaCXX/type-traits.cpp

3099–3100

Gentle ping.

[aaron.ballman]

clang/test/SemaCXX/type-traits.cpp

3099–3100

Does int attribute((address_space(1))) make sense as a type? I thought it had to be a pointee.

It doesn't have to be on a pointer or a pointee type.

[rsmith]

clang/lib/AST/ASTContext.cpp

5809

This change seems surprising. Can you explain what's going on here?

10305–10306

If we now allow unsigned types to be passed in here, can we do so consistently?

This seems to do the wrong thing for a vector of scoped enumeration type. Is that a problem for the builtins?

10323–10351

(Continuation of suggested edits in comment a few lines below.)

10366–10367

Perhaps we can handle all the plain unsigned types (other than wchar_t and char, which are special) here? This would also cover the fixed-point types.

10373

Similar comments for this function as previous one.

clang/lib/AST/TypePrinter.cpp

1169–1191

Remove this line too. No point building an RAII scope with nothing in it.

clang/lib/Parse/ParseExpr.cpp

1750 ↗

(On Diff #423716)

I agree we need to treat trait< as an identifier and trait( as the builtin. My question is, why do we have inconsistent treatment of the remaining cases (trait followed by any other token)? For example, MaybeParseTypeTransformTypeSpecifier treats trait + 1 as an identifier. But this code treats it as the builtin name.

I think there are two choices that make the most sense, if they work:

1. trait( is the builtin and any other utterance is an identifier, or
2. trait< is an identifier, using trait = is an identifier, and any other utterance is the builtin.

I think I prefer option (2), given that it's defining the narrower special case. But all I'm really looking for here is a consistent story one way or the other, if it's feasible to have one.

clang/lib/Sema/SemaType.cpp

6035–6037

I don't think this comment pulls its weight any more, now that you're calling a named function for this check. Maybe just remove it?

9121

Yes, it's a conforming extension compared to C++20; the standard places no restrictions on what a program that uses a vendor extension type such as a vector type does.

On reflection, I'm not sure it would be a conforming extension to OpenCL (in which such vector types exist as part of the language standard -- in particular, ext_vector_type is intended to follow the OpenCL rules). So let's not support such things until / unless we get some direction from the OpenCL folks.

9121–9122

With the changes suggested for getCorresponding*Type, I think we can remove the BitInt special case here.

9124–9125

The comment on this producing the wrong underlying type for enums in some cases doesn't seem to be addressed. You need to produce the lowest-rank type of the given size, which is not what getIntTypeForBitwidth does.

9146–9150

You're splitting the type into unqualified type and quailfiers twice here, once in the call to getQualifiers and again in getSplitUnqualifiedType. It'd be better to only split it once.

9147

Do we really want to remove the address space here? The libc++ and libstdc++ implementations of the trait don't do that (https://godbolt.org/z/jqafYP6er) and it makes the behavior of __remove_pointer inconsistent with the behavior of __add_pointer. Can we just produce the pointee type intact, including all of its qualifiers?

9150

It's not correct to treat a Qualifiers opaque value as if it has meaning for anything other than converting back from an opaque value. The second argument here is a cvr mask, which is not the same thing.

Use Context.getQualifiedType to combine a type with some qualifiers.

9161–9169

As above, you can't use getAsOpaqueValue like this, and should avoid splitting the type twice.

Note that the pattern used here is only correct because we know that Underlying cannot be an array type.

9164

Why "in C++"? It looks like it does this in C too, which is probably appropriate. However, this is a divergence from what std::decay_t does in libc++ and libstdc++, where it does not remove __restrict.

9178–9187

Looks like you forgot to remove the old code when adding the new code?

9211–9222

As before, the way you were splitting and reconstructing types wasn't correct.

9227–9231

LLVM style is to restrict the scopes of variables as much as possible, and there's no point splitting the type if we're not going to use the result.

[rsmith]

clang/lib/Sema/SemaType.cpp

9124–9125

Specifically, the rule you need to implement for enums is that the resulting type "names the [un]signed integer type with smallest rank (6.8.5) for which sizeof(T) == sizeof(type)". So the first of [un]signed char, [un]signed short, [un]signed int, [un]signed long, [un]signed long long that is the same size as the enum, and if none of those work then an extended integer type.

For example, if int and long are the same size, then given enum E : long {};, __make_unsigned(E) is required to produce unsigned int, not unsigned long. This is not what getIntTypeForBitwidth does in general; rather, it answers the target-specific question of "which integer type would you like to be used for an integer that is N bits wide?".

[cjdb]

applies Richard's feedback (or most of it)

clang/lib/AST/ASTContext.cpp

5809

Motivated by __make_signed(wchar_t) previously returning wchar_t, and that it was seemingly inconsistent with getUnsignedWCharType below.

10305–10306

I think not, given we're not worrying about vector types right now?

clang/lib/AST/TypePrinter.cpp

1169–1191

Can we get rid of this function entirely in that case?

clang/lib/Parse/ParseExpr.cpp

1750 ↗

(On Diff #423716)

I'd like for it to be (2) as well, but based on how we do alias-declarations, I'm concerned that will have performance implications for a rare occurrence.

clang/lib/Sema/SemaType.cpp

9164

That sentence is specifically calling out that __restrict is being removed in C++ mode too. Tightened up the wording. I'm partial to __decay removing __restrict because it would be what language decay does.

[cjdb]

rebases onto main

[cjdb]

rebases

[rsmith]

clang/lib/AST/ASTContext.cpp

5809

It looks to me like this breaks the implementation of a GCC compatibility feature. In GCC 8 and before, signed wchar_t is [accepted and means wchar_t](https://godbolt.org/z/5af7n9bef) and similarly unsigned wchar_t is accepted and means unsigned int, and Clang provides that behavior here; with this change, signed wchar_t will resolve to int instead in Clang, deviating from GCC's behavior for this GCC compatibility feature.

I think I'd be happy to see that GCC compatibility feature removed entirely, especially given that GCC 9 onwards removed it, it's an error by default in Clang, and essentially no-one seems to be using it, but that should not be done in this patch, and we shouldn't change its behavior here either.

10317–10320

This isn't the correct behavior for make_unsigned. We need to pick the integer type with the lowest rank with the same size as the enumeration (see the corresponding wording). For example, if the underlying type of E is long and sizeof(long) == sizeof(int), then make_unsigned<E> is required to produce unsigned int not unsigned long.

It might be that the best approach here is for BuiltinChangeSignedness to only call getCorrespondingUnsignedType when T is a signed or unsigned integral type (notably excluding char16_t and friends -- see next comment -- but including _BitInt), and otherwise for it to look through the signed / unsigned integer types for the first one with the same size as T and pick that.

10327

Mapping char16_t -> unsigned short seems target-specific to me. If plain unsigned char is 16 bits wide, then make_unsigned<char16_t> should be unsigned char. Same for char32_t, wchar_t.

clang/lib/Parse/ParseDeclCXX.cpp

1141–1142

We don't need both of these. Just the llvm_unreachable would suffice.

clang/lib/Parse/ParseExpr.cpp

1755–1756 ↗

(On Diff #440078)

Is it feasible to also produce this warning for the corresponding case in MaybeParseTypeTransformTypeSpecifier / the callers of that function?

clang/lib/Sema/SemaType.cpp

9136

The name that's wanted by BuildPointerType is the name of the pointer variable, not the name of the type the pointer points to. Eg, for int &*p; it wants to say "p declared as a pointer to a reference". Passing in the name of the base type will mean that __add_pointer(class X&) could produce diagnostics like "X declared as a pointer to a reference", which is nonsense. Fortunately, that diagnostic is impossible here because we never pass it a reference, so you should be able to just pass a null DeclarationName instead.

9141–9142

BuildPointerType can fail and return a null QualType; you'll need to detect that and do something different here -- either return the error to the caller or fall back to the original type for error recovery.

9152–9154

No need to add Pointee's qualifiers to Pointee; it already has them.

9176

As above, this isn't the right name to pass, and we should not pass any name given that we don't have one.

9183

BuildReferenceType can fail and return a null QualType, and that will need to be handled here.

9243–9244

See comments in getCorrespondingUnsignedType: these don't perform the slightly odd "lowest rank type with this size" computation specified in the standard, in the case where the given type is an enum or character type.

clang/test/SemaCXX/type-traits.cpp

3269

I'm still seeing 39 pointer-to-member tests here in check_remove_cvref, 39 in check_decay, and 25 in check_remove_reference, all of which seem to be testing the same thing (that these traits don't look "inside" a pointer-to-member's pointee type in any way). Can those be cut down a bit?

[cjdb]

clang/lib/Parse/ParseExpr.cpp

1755–1756 ↗

(On Diff #440078)

Will this risk sending out the warning twice, and if so, can the diagnostic engine handle that?

[cjdb]

responds to Richard's feedback

I had accidentally uploaded this to D116280, apologies if there was any confusion.

[cjdb]

rebases to ToT

[rsmith]

A handful more comments, but I think we've basically converged here. I'm happy to take another look after you address these if you'd like (or you could ask someone else for a final pass), or for you to land this once you're happy.

Before landing, it'd be good to patch libc++ to use these intrinsics and run its testsuite to look for any unexpected behavior changes, if you've not already done so with this version of the patch.

clang/lib/AST/ASTContext.cpp

10331

I think we don't need this case any more.

clang/lib/Parse/ParseDeclCXX.cpp

1141–1142

This comment still needs to be addressed.

clang/lib/Parse/ParseExpr.cpp

1066–1067 ↗

(On Diff #450586)

Just curious: why do we only handle six of the traits here, rather than all of them?

clang/lib/Sema/SemaType.cpp

9122–9123

I've been pondering the proper behavior for make_signed on enum E : _BitInt(N) {}. I think the standard wording here is broken (see my email to the lib reflector, subject "make_signed / make_unsigned and padding / extended integer types"), but I'm not certain what the right rule is. Let's say that always producing a _BitInt type in that case is good enough for now. :)

9132

Have you considered moving the calls to getUnaryTransformType into this function? Right now they're scattered among the Builtin* helper functions, and it's hard to be sure that every code path calls it. I think it'd be a lot simpler to create the UnaryTransformType wrapper once, in a single place.

9239

Remove the static -- it's not correct to use a static local for this. There can be multiple Sema instances, and this will pick the types from whichever one was used the first time this function was called.

9241–9245

We don't have an __int128 on 32-bit targets. Maybe below you can form an ArrayRef and slice off the last element if __int128 is unsupported?

9252

Please only compute the size of BaseType once.

9255

Can this fail for an enum whose underlying type is _BitInt(N) for some unusual N?

[cjdb]

responds to @richardsmith's feedback

[cjdb]

Thanks for patiently reviewing! I'll do the libc++ stuff and a pilot run in some code. Hopefully can get it merged tomorrow :-)

clang/lib/Parse/ParseDeclCXX.cpp

1141–1142

Could've sworn I did this one, but it might've gotten mixed up in the D116280 switcheroo.

clang/lib/Parse/ParseExpr.cpp

1750 ↗

(On Diff #423716)

You haven't countered this concern, so I'm going to close for now and will happily revisit if this one just slipped by unnoticed.

1066–1067 ↗

(On Diff #450586)

Why indeed. Perhaps these were the original six I worked on and didn't come back to update this.

clang/lib/Sema/SemaType.cpp

9255

Nice catch. This wasn't supposed to happen, but I ended up changing the logic so that _BitInt is considered here instead.

[cjdb]

tl;dr fixes corner-case bug uncovered by libc++

I'd accidentally inverted the logic for when __int128 and unsigned __int128 would be available for underlying enum types. This led to the types being swapped (??) and there wasn't a test to catch it.

[aaron.ballman]

Pre-commit CI found build errors that should be addressed.

clang/include/clang/AST/TransformTypeTraits.def

1–2 ↗

(On Diff #452001)

Have to fix the formatting manually though.

clang/include/clang/Sema/DeclSpec.h

457–464

Errr, this isn't Python, so that [-1] terrifies me. It took me a good solid ten minutes to convince myself this was actually valid. Any interest in something along the lines of this form?

clang/lib/AST/TypePrinter.cpp

1169–1191

I believe you can.

clang/lib/Parse/ParseDecl.cpp

3385

clang/lib/Sema/SemaType.cpp

9160

9198–9201

9243–9245

An interesting test case for you to consider (both for enumeration underlying types as well as types in general): signed _BitInt requires at least two bits, so trying to do a make_signed on _BitInt(1) should be diagnosed.

[cjdb]

applies Aaron's feedback

[cjdb]

clang/include/clang/Sema/DeclSpec.h

457–464

I have many questions about the decisions I made in this snippet.

clang/lib/AST/TypePrinter.cpp

1169–1191

It looks like other things also have this as just empty, so maybe it's best to keep it?

[aaron.ballman]

LGTM, though I did have a nit about diagnostic wording that you can feel free to take or leave at your discretion. Thank you for this work, this was a very large patch with a whole lot of review comments, but I think what we ended up with is really great!

clang/include/clang/Sema/DeclSpec.h

457–464

It was definitely a great way to wake up this morning. "Wait, what? WHAT?!?" followed by a bunch of furious standards reading. :-D

clang/lib/AST/TypePrinter.cpp

1169–1191

That's fine by me!

clang/test/SemaCXX/type-traits.cpp

3444

This diagnostic is a bit unfortunate because it was given a non-bool integer, so I don't know that users will know how to fix the issue from the text. I leave it to your discretion where to split that diagnostic up with a %select so that _BitInt is special or not; I don't think users will hit this diagnostic all that often, but I do have a little bit of a worry about template metaprogramming accidentally getting into this state.

[cjdb]

adds a clearer diagnostic for unsigned _BitInt(1)

[cjdb]

moves TransformTypeTraits.def from clang/AST to clang/Basic

There are dowstream issues with having this definition file in the
former, because of the Bazel rules describing the relationship
between Basic and AST. Since Basic is the base and moving it there
is an NFC, I've taken the initiative to move it ahead of downstrem
usage. (Updating changelist for transperancy, but still merging
with main today.)

[thakis]

This breaks building on windows: http://45.33.8.238/win/64423/step_4.txt

Please take a look and revert for now if it takes a while to fix.

[mstorsjo]

This also broke building with GCC 9 on Ubuntu 20.04:

[5/225] ASTNodeAPI.json
FAILED: tools/clang/lib/Tooling/ASTNodeAPI.json
cd /home/martin/code/llvm-project/llvm/build/tools/clang/lib/Tooling && /home/martin/code/llvm-project/llvm/build/bin/clang-ast-dump --skip-processing=0 -I /home/martin/code/llvm-project/llvm/build/lib/clang/16.0.0/include -I /home/martin/code/llvm-project/llvm/tools/clang/include -I /home/martin/code/llvm-project/llvm/build/tools/clang/include -I /home/martin/code/llvm-project/llvm/build/include -I /home/martin/code/llvm-project/llvm/include -I /usr/include/c++/9 -I /usr/include/x86_64-linux-gnu/c++/9 -I /usr/include/c++/9/backward -I /usr/lib/gcc/x86_64-linux-gnu/9/include -I /usr/local/include -I /usr/include/x86_64-linux-gnu -I /usr/include --json-output-path /home/martin/code/llvm-project/llvm/build/tools/clang/lib/Tooling/ASTNodeAPI.json
clang-ast-dump: ../tools/clang/lib/Sema/DeclSpec.cpp:833: bool clang::DeclSpec::SetTypeSpecType(clang::DeclSpec::TST, clang::SourceLocation, const char*&, unsigned int&, const clang::PrintingPolicy&): Assertion `!isDeclRep(T) && !isTypeRep(T) && !isExprRep(T) && "rep required for these type-spec kinds!"' failed.
Aborted (core dumped)

[thakis]

Reverted this (and follow-ups) in aacf1a9742f714dd432117d82d19a007289c3dee for now.

[cjdb]

changes so this patch doesn't break things:

1. changes from begin/end to data/size
2. changes from ArrayRef to array since an ArrayRef to a prvalue is undefined (and causes segfaults when building with GCC)

[fdeazeve]

I believe this patch might have broken LLDB bots https://green.lab.llvm.org/green/view/LLDB/job/lldb-cmake/46269/

I've confirmed that d2d77e050b32 is good while e9ef45635b77 (this commit) breaks some tests.

To repro, a build of llvm+lldb+libcxx+libcxxapi and

# inside build dir
/bin/llvm-lit -v tools/lldb/test/API/lang/objc/modules-objc-property/TestModulesObjCProperty.py

Alternatively, running the check-lldb target should do it. But there is one other unrelated failure that might show up in that target

[fdeazeve]

Forgot to add the failure message:

/usr/include/c++/v1/experimental/propagate_const:138:11: error: no template named 'remove_reference_t'; did you mean 'remove_reference'?
  typedef remove_reference_t<decltype(*_VSTD::declval<_Tp&>())> element_type;

[fdeazeve]

It seems like non-lldb bots are also failing, if it makes it easier to reproduce:
https://green.lab.llvm.org/green/view/Clang/job/clang-stage1-RA/30837/consoleFull#-54352964249ba4694-19c4-4d7e-bec5-911270d8a58c

[cjdb]

In D116203#3739856, @fdeazeve wrote:

It seems like non-lldb bots are also failing, if it makes it easier to reproduce:
https://green.lab.llvm.org/green/view/Clang/job/clang-stage1-RA/30837/consoleFull#-54352964249ba4694-19c4-4d7e-bec5-911270d8a58c

Thanks for flagging this. Based on the fact it only seems to be remove_reference_t, I'm wondering if this is an issue with D131732 (which was merged immediately after D116203).

[fdeazeve]

In D116203#3740015, @cjdb wrote:

In D116203#3739856, @fdeazeve wrote:

It seems like non-lldb bots are also failing, if it makes it easier to reproduce:
https://green.lab.llvm.org/green/view/Clang/job/clang-stage1-RA/30837/consoleFull#-54352964249ba4694-19c4-4d7e-bec5-911270d8a58c

Thanks for flagging this. Based on the fact it only seems to be remove_reference_t, I'm wondering if this is an issue with D131732 (which was merged immediately after D116203).

I'm not sure, to expand on my previous message, I tested these two commits which appear one right after the other in the log:

• e9ef45635b77 (14 hou..) cjdb@g.. [clang] adds unary type transformations as compiler built-ins
• d2d77e050b32 (15 hou..) Ting.W.. [PowerPC][Coroutines] Add tail-call check with call information for coroutines

The tests pass on d2d77e050b32 and fail on e9ef45635b77

[aprantl]

@cjdb Would you mind reverting the patch until we figured out a solution to unblock the CI?

[cjdb]

In D116203#3740227, @aprantl wrote:

@cjdb Would you mind reverting the patch until we figured out a solution to unblock the CI?

Sure, go ahead. I'm not even able to get to a point where I can repro the issue, as I get the following:

Command Output (stdout):
--
lldb version 16.0.0git ([e-mail]:llvm/llvm-project.git revision 11ce014a121ed0bbdbb2af6ea20c75f85e89fbe9)
  clang revision 11ce014a121ed0bbdbb2af6ea20c75f85e89fbe9
  llvm revision 11ce014a121ed0bbdbb2af6ea20c75f85e89fbe9
Unable to load lldb extension module.  Possible reasons for this include:
  1) LLDB was built with LLDB_ENABLE_PYTHON=0
  2) PYTHONPATH and PYTHONHOME are not set correctly.  PYTHONHOME should refer to
     the version of Python that LLDB built and linked against, and PYTHONPATH
     should contain the Lib directory for the same python distro, as well as the
     location of LLDB's site-packages folder.
  3) A different version of Python than that which was built against is exported in
     the system's PATH environment variable, causing conflicts.
  4) The executable '/tmp/lldb-breaks/bin/lldb' could not be found.  Please check 
     that it exists and is executable.

--
Command Output (stderr):
--
Traceback (most recent call last):
  File "/home/cjdb/projects/llvm-bisect/lldb/test/API/dotest.py", line 7, in <module>
    lldbsuite.test.run_suite()
  File "/home/cjdb/projects/llvm-bisect/lldb/packages/Python/lldbsuite/test/dotest.py", line 892, in run_suite
    import lldb
ModuleNotFoundError: No module named 'lldb'

1 and 4 seem to be fine.

[cjdb]

I think there's a forward fix available, but since I can't repro locally, I'm going to need to push it to main and observe how the tools fare.

[fdeazeve]

In D116203#3740843, @cjdb wrote:

I think there's a forward fix available, but since I can't repro locally, I'm going to need to push it to main and observe how the tools fare.

I need to be AFK for a bit now, but I can test locally on my end if you upload the patch here

[dschuff]

This broke us in emscripten as well (building with trunk clang against a recent-but-not-trunk version of libcxx). I can test the fix if you want.

[cjdb]

e137fb6fb85 should fix this issue. Thanks for your patience!

clang/include/clang/AST/Type.h

public:
   bool isCanonical() const;
   bool isCanonicalAsParam() const;
 
   /// Return true if this QualType doesn't point to a type yet.
   bool isNull() const {
     return Value.getPointer().isNull();
   }
 
+  bool isReferenceable() const;
+
   /// Determine whether this particular QualType instance has the
   /// "const" qualifier set, without looking through typedefs that may have
   /// added "const" at a different level.
   bool isLocalConstQualified() const {
     return (getLocalFastQualifiers() & Qualifiers::Const);
   }
 
   /// Determine whether this type is const-qualified.
public:
   static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
                       Expr *E);
 };
 
 /// A unary type transform, which is a type constructed from another.
 class UnaryTransformType : public Type {
 public:
   enum UTTKind {
-    EnumUnderlyingType
+    EnumUnderlyingType,
+    AddCV,
+    AddConst,
+    AddLvalueReference,
+    AddPointer,
+    AddRvalueReference,
+    AddVolatile,
+    Decay,
+    MakeSigned,
+    MakeUnsigned,
+    RemoveConst,
+    RemoveCV,
+    RemoveCVRef,
+    RemovePointer,
+    RemoveReference,
+    RemoveVolatile,
   };
 
 private:
   /// The untransformed type.
   QualType BaseType;
 
   /// The transformed type if not dependent, otherwise the same as BaseType.
   QualType UnderlyingType;
 

 inline const Type *QualType::getTypePtr() const {
   return getCommonPtr()->BaseType;
 }
 
 inline const Type *QualType::getTypePtrOrNull() const {
   return (isNull() ? nullptr : getCommonPtr()->BaseType);
 }
 
+inline bool QualType::isReferenceable() const {
+  // C++ [defns.referenceable]
+  //   type that is either an object type, a function type that does not have
+  //   cv-qualifiers or a ref-qualifier, or a reference type
+  const Type &Self = **this;
+  if (Self.isObjectType() || Self.isReferenceType())
+    return true;
+  if (!Self.isFunctionType())
+    return false;
+
+  const auto *F = Self.getAs<FunctionProtoType>();
+  return F == nullptr ||
+         (F->getMethodQuals().empty() && F->getRefQualifier() == RQ_None);
+}
+
 inline SplitQualType QualType::split() const {
   if (!hasLocalNonFastQualifiers())
     return SplitQualType(getTypePtrUnsafe(),
                          Qualifiers::fromFastMask(getLocalFastQualifiers()));
 
   const ExtQuals *eq = getExtQualsUnsafe();
   Qualifiers qs = eq->getQualifiers();
   qs.addFastQualifiers(getLocalFastQualifiers());
   return SplitQualType(eq->getBaseType(), qs);

clang/include/clang/Basic/DiagnosticSemaKinds.td

def err_typecheck_expect_scalar_operand : Error<
   "operand of type %0 where arithmetic or pointer type is required">;
 def err_typecheck_cond_incompatible_operands : Error<
   "incompatible operand types%diff{ ($ and $)|}0,1">;
 def err_typecheck_expect_flt_or_vector : Error<
   "invalid operand of type %0 where floating, complex or "
   "a vector of such types is required">;
 def err_cast_selector_expr : Error<
   "cannot type cast @selector expression">;
+def err_make_signed_integral_only : Error<
+  "'%select{make_unsigned|make_signed}0' is only compatible with non-bool integers and enum types, but was given %1">;
 def ext_typecheck_cond_incompatible_pointers : ExtWarn<
   "pointer type mismatch%diff{ ($ and $)|}0,1">,
   InGroup<DiagGroup<"pointer-type-mismatch">>;
 def ext_typecheck_cond_pointer_integer_mismatch : ExtWarn<
   "pointer/integer type mismatch in conditional expression"
   "%diff{ ($ and $)|}0,1">,
   InGroup<DiagGroup<"conditional-type-mismatch">>;
 def err_typecheck_choose_expr_requires_constant : Error<

clang/include/clang/Basic/Specifiers.h

namespace clang {
 
   enum class TypeSpecifiersPipe { Unspecified, Pipe };
 
   /// Specifies the kind of type.
   enum TypeSpecifierType {
     TST_unspecified,
     TST_void,
     TST_char,
-    TST_wchar,        // C++ wchar_t
-    TST_char8,        // C++20 char8_t (proposed)
-    TST_char16,       // C++11 char16_t
-    TST_char32,       // C++11 char32_t
+    TST_wchar,  // C++ wchar_t
+    TST_char8,  // C++20 char8_t (proposed)
+    TST_char16, // C++11 char16_t
+    TST_char32, // C++11 char32_t
     TST_int,
     TST_int128,
-    TST_bitint,       // Bit-precise integer types.
-    TST_half,         // OpenCL half, ARM NEON __fp16
-    TST_Float16,      // C11 extension ISO/IEC TS 18661-3
-    TST_Accum,        // ISO/IEC JTC1 SC22 WG14 N1169 Extension
+    TST_bitint,  // Bit-precise integer types.
+    TST_half,    // OpenCL half, ARM NEON __fp16
+    TST_Float16, // C11 extension ISO/IEC TS 18661-3
+    TST_Accum,   // ISO/IEC JTC1 SC22 WG14 N1169 Extension
     TST_Fract,
     TST_BFloat16,
     TST_float,
     TST_double,
     TST_float128,
     TST_ibm128,
-    TST_bool,         // _Bool
-    TST_decimal32,    // _Decimal32
-    TST_decimal64,    // _Decimal64
-    TST_decimal128,   // _Decimal128
+    TST_bool,       // _Bool
+    TST_decimal32,  // _Decimal32
+    TST_decimal64,  // _Decimal64
+    TST_decimal128, // _Decimal128
     TST_enum,
     TST_union,
     TST_struct,
-    TST_class,        // C++ class type
-    TST_interface,    // C++ (Microsoft-specific) __interface type
-    TST_typename,     // Typedef, C++ class-name or enum name, etc.
+    TST_class,     // C++ class type
+    TST_interface, // C++ (Microsoft-specific) __interface type
+    TST_typename,  // Typedef, C++ class-name or enum name, etc.
     TST_typeofType,
     TST_typeofExpr,
-    TST_decltype,         // C++11 decltype
-    TST_underlyingType,   // __underlying_type for C++11
-    TST_auto,             // C++11 auto
-    TST_decltype_auto,    // C++1y decltype(auto)
-    TST_auto_type,        // __auto_type extension
-    TST_unknown_anytype,  // __unknown_anytype extension
-    TST_atomic,           // C11 _Atomic
+    TST_decltype,             // C++11 decltype
+    TST_underlyingType,       // __underlying_type for C++11
+    TST_add_const,            // __add_const trait
+    TST_add_cv,               // __add_cv trait
+    TST_add_lvalue_reference, // __add_add_lvalue_reference trait
+    TST_add_pointer,          // __add_pointer trait
+    TST_add_rvalue_reference, // __add_add_rvalue_reference trait
+    TST_add_volatile,         // __add_volatile trait
+    TST_decay,                // __decay trait
+    TST_make_signed,          // __make_signed trait
+    TST_make_unsigned,        // __make_unsigned trait
+    TST_remove_const,         // __remove_const trait
+    TST_remove_cv,            // __remove_cv trait
+    TST_remove_cvref,         // __remove_cvref trait
+    TST_remove_pointer,       // __remove_pointer trait
+    TST_remove_reference,     // __remove_reference trait
+    TST_remove_volatile,      // __remove_volatile trait
+    TST_auto,                 // C++11 auto
+    TST_decltype_auto,        // C++1y decltype(auto)
+    TST_auto_type,            // __auto_type extension
+    TST_unknown_anytype,      // __unknown_anytype extension
+    TST_atomic,               // C11 _Atomic
 #define GENERIC_IMAGE_TYPE(ImgType, Id) TST_##ImgType##_t, // OpenCL image types
 #include "clang/Basic/OpenCLImageTypes.def"
     TST_error // erroneous type
   };
 
   /// Structure that packs information about the type specifiers that
   /// were written in a particular type specifier sequence.
   struct WrittenBuiltinSpecs {
-    static_assert(TST_error < 1 << 6, "Type bitfield not wide enough for TST");
-    /*DeclSpec::TST*/ unsigned Type  : 6;
+    static_assert(TST_error < 1 << 7, "Type bitfield not wide enough for TST");
+    /*DeclSpec::TST*/ unsigned Type  : 7;
     /*DeclSpec::TSS*/ unsigned Sign  : 2;
     /*TypeSpecifierWidth*/ unsigned Width : 2;
     unsigned ModeAttr : 1;
   };
 
   /// A C++ access specifier (public, private, protected), plus the
   /// special value "none" which means different things in different contexts.
   enum AccessSpecifier {

clang/include/clang/Basic/TokenKinds.def

 TYPE_TRAIT_1(__is_trivial, IsTrivial, KEYCXX)
 TYPE_TRAIT_2(__is_trivially_assignable, IsTriviallyAssignable, KEYCXX)
 TYPE_TRAIT_N(__is_trivially_constructible, IsTriviallyConstructible, KEYCXX)
 TYPE_TRAIT_1(__is_trivially_copyable, IsTriviallyCopyable, KEYCXX)
 TYPE_TRAIT_1(__is_union, IsUnion, KEYCXX)
 TYPE_TRAIT_1(__has_unique_object_representations,
              HasUniqueObjectRepresentations, KEYCXX)
 KEYWORD(__underlying_type           , KEYCXX)
+KEYWORD(__add_const, KEYCXX)
+KEYWORD(__add_cv, KEYCXX)
+KEYWORD(__add_lvalue_reference, KEYCXX)
+KEYWORD(__add_pointer, KEYCXX)
+KEYWORD(__add_rvalue_reference, KEYCXX)
+KEYWORD(__add_volatile, KEYCXX)
+KEYWORD(__decay, KEYCXX)
+KEYWORD(__make_signed, KEYCXX)
+KEYWORD(__make_unsigned, KEYCXX)
+KEYWORD(__remove_const, KEYCXX)
+KEYWORD(__remove_cv, KEYCXX)
+KEYWORD(__remove_cvref, KEYCXX)
+KEYWORD(__remove_pointer, KEYCXX)
+KEYWORD(__remove_reference, KEYCXX)
+KEYWORD(__remove_volatile, KEYCXX)
 
 // Clang-only C++ Type Traits
 TYPE_TRAIT_2(__reference_binds_to_temporary, ReferenceBindsToTemporary, KEYCXX)
 
 // Embarcadero Expression Traits
 EXPRESSION_TRAIT(__is_lvalue_expr, IsLValueExpr, KEYCXX)
 EXPRESSION_TRAIT(__is_rvalue_expr, IsRValueExpr, KEYCXX)
 

clang/include/clang/Parse/Parser.h

void ParseFunctionDeclaratorIdentifierList(
          SmallVectorImpl<DeclaratorChunk::ParamInfo> &ParamInfo);
   void ParseParameterDeclarationClause(
          DeclaratorContext DeclaratorContext,
          ParsedAttributes &attrs,
          SmallVectorImpl<DeclaratorChunk::ParamInfo> &ParamInfo,
          SourceLocation &EllipsisLoc);
   void ParseBracketDeclarator(Declarator &D);
   void ParseMisplacedBracketDeclarator(Declarator &D);
+  void ParseTypeTransformTypeSpecifier(DeclSpec &DS);
+  DeclSpec::TST TypeTransformTokToDeclSpec();
 
   //===--------------------------------------------------------------------===//
   // C++ 7: Declarations [dcl.dcl]
 
   /// The kind of attribute specifier we have found.
   enum CXX11AttributeKind {
     /// This is not an attribute specifier.
     CAK_NotAttributeSpecifier,

clang/include/clang/Sema/DeclSpec.h

 #include "clang/AST/NestedNameSpecifier.h"
 #include "clang/Basic/ExceptionSpecificationType.h"
 #include "clang/Basic/Lambda.h"
 #include "clang/Basic/OperatorKinds.h"
 #include "clang/Basic/Specifiers.h"
 #include "clang/Lex/Token.h"
 #include "clang/Sema/Ownership.h"
 #include "clang/Sema/ParsedAttr.h"
+#include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/ErrorHandling.h"
 
 namespace clang {
   class ASTContext;
   class CXXRecordDecl;
   class TypeLoc;
public:
   static const TST TST_interface = clang::TST_interface;
   static const TST TST_class = clang::TST_class;
   static const TST TST_typename = clang::TST_typename;
   static const TST TST_typeofType = clang::TST_typeofType;
   static const TST TST_typeofExpr = clang::TST_typeofExpr;
   static const TST TST_decltype = clang::TST_decltype;
   static const TST TST_decltype_auto = clang::TST_decltype_auto;
   static const TST TST_underlyingType = clang::TST_underlyingType;
+  static const TST TST_add_const = clang::TST_add_const;
+  static const TST TST_add_cv = clang::TST_add_cv;
+  static const TST TST_add_lvalue_reference = clang::TST_add_lvalue_reference;
+  static const TST TST_add_pointer = clang::TST_add_pointer;
+  static const TST TST_add_rvalue_reference = clang::TST_add_rvalue_reference;
+  static const TST TST_add_volatile = clang::TST_add_volatile;
+  static const TST TST_decay = clang::TST_decay;
+  static const TST TST_make_signed = clang::TST_make_signed;
+  static const TST TST_make_unsigned = clang::TST_make_unsigned;
+  static const TST TST_remove_const = clang::TST_remove_const;
+  static const TST TST_remove_cv = clang::TST_remove_cv;
+  static const TST TST_remove_cvref = clang::TST_remove_cvref;
+  static const TST TST_remove_pointer = clang::TST_remove_pointer;
+  static const TST TST_remove_reference = clang::TST_remove_reference;
+  static const TST TST_remove_volatile = clang::TST_remove_volatile;
   static const TST TST_auto = clang::TST_auto;
   static const TST TST_auto_type = clang::TST_auto_type;
   static const TST TST_unknown_anytype = clang::TST_unknown_anytype;
   static const TST TST_atomic = clang::TST_atomic;
 #define GENERIC_IMAGE_TYPE(ImgType, Id) \
   static const TST TST_##ImgType##_t = clang::TST_##ImgType##_t;
 #include "clang/Basic/OpenCLImageTypes.def"
   static const TST TST_error = clang::TST_error;
private:
   /*SCS*/unsigned StorageClassSpec : 3;
   /*TSCS*/unsigned ThreadStorageClassSpec : 2;
   unsigned SCS_extern_in_linkage_spec : 1;
 
   // type-specifier
   /*TypeSpecifierWidth*/ unsigned TypeSpecWidth : 2;
   /*TSC*/unsigned TypeSpecComplex : 2;
   /*TSS*/unsigned TypeSpecSign : 2;
-  /*TST*/unsigned TypeSpecType : 6;
+  /*TST*/unsigned TypeSpecType : 7;
   unsigned TypeAltiVecVector : 1;
   unsigned TypeAltiVecPixel : 1;
   unsigned TypeAltiVecBool : 1;
   unsigned TypeSpecOwned : 1;
   unsigned TypeSpecPipe : 1;
   unsigned TypeSpecSat : 1;
   unsigned ConstrainedAuto : 1;
 
private:
   SourceLocation TQ_pipeLoc;
 
   WrittenBuiltinSpecs writtenBS;
   void SaveWrittenBuiltinSpecs();
 
   ObjCDeclSpec *ObjCQualifiers;
 
   static bool isTypeRep(TST T) {
-    return (T == TST_typename || T == TST_typeofType ||
-            T == TST_underlyingType || T == TST_atomic);
+    constexpr std::array<TST, 19> validTSTs = {
+        TST_add_const,
+        TST_add_cv,
+        TST_add_lvalue_reference,
+        TST_add_pointer,
+        TST_add_rvalue_reference,
+        TST_add_volatile,
+        TST_atomic,
+        TST_decay,
+        TST_make_signed,
+        TST_make_unsigned,
+        TST_remove_const,
+        TST_remove_cv,
+        TST_remove_cvref,
+        TST_remove_pointer,
+        TST_remove_reference,
+        TST_remove_volatile,
+        TST_typename,
+        TST_typeofType,
+        TST_underlyingType,
+    };
+    return llvm::any_of(validTSTs, [T](TST X) { return X == T; });
   }
   static bool isExprRep(TST T) {
     return (T == TST_typeofExpr || T == TST_decltype || T == TST_bitint);
   }
   static bool isTemplateIdRep(TST T) {
     return (T == TST_auto || T == TST_decltype_auto);
   }
 
   DeclSpec(const DeclSpec &) = delete;
   void operator=(const DeclSpec &) = delete;
 public:
   static bool isDeclRep(TST T) {
     return (T == TST_enum || T == TST_struct ||
             T == TST_interface || T == TST_union ||
             T == TST_class);
   }
 
   DeclSpec(AttributeFactory &attrFactory)
       : StorageClassSpec(SCS_unspecified),
         ThreadStorageClassSpec(TSCS_unspecified),
         SCS_extern_in_linkage_spec(false),
         TypeSpecWidth(static_cast<unsigned>(TypeSpecifierWidth::Unspecified)),
         TypeSpecComplex(TSC_unspecified),
         TypeSpecSign(static_cast<unsigned>(TypeSpecifierSign::Unspecified)),
         TypeSpecType(TST_unspecified), TypeAltiVecVector(false),
         TypeAltiVecPixel(false), TypeAltiVecBool(false), TypeSpecOwned(false),
         TypeSpecPipe(false), TypeSpecSat(false), ConstrainedAuto(false),
         TypeQualifiers(TQ_unspecified), FS_inline_specified(false),
         FS_forceinline_specified(false), FS_virtual_specified(false),
         FS_noreturn_specified(false), Friend_specified(false),
         ConstexprSpecifier(
             static_cast<unsigned>(ConstexprSpecKind::Unspecified)),

clang/lib/AST/ASTContext.cpp

dt = new (*this, TypeAlignment)
         DecltypeType(e, UnderlyingType, getCanonicalType(UnderlyingType));
   }
   Types.push_back(dt);
   return QualType(dt, 0);
 }
 
 /// getUnaryTransformationType - We don't unique these, since the memory
 /// savings are minimal and these are rare.
+// Update 2021-12-16: it might be worth revisiting this
 QualType ASTContext::getUnaryTransformType(QualType BaseType,
                                            QualType UnderlyingType,
                                            UnaryTransformType::UTTKind Kind)
     const {
   UnaryTransformType *ut = nullptr;
 
   if (BaseType->isDependentType()) {
     // Look in the folding set for an existing type.

 CanQualType ASTContext::getUIntMaxType() const {
   return getFromTargetType(Target->getUIntMaxType());
 }
 
 /// getSignedWCharType - Return the type of "signed wchar_t".
 /// Used when in C++, as a GCC extension.
 QualType ASTContext::getSignedWCharType() const {
   // FIXME: derive from "Target" ?
   return WCharTy;
 }
 
 /// getUnsignedWCharType - Return the type of "unsigned wchar_t".
 /// Used when in C++, as a GCC extension.
 QualType ASTContext::getUnsignedWCharType() const {
   // FIXME: derive from "Target" ?
   return UnsignedIntTy;
 }
if (T->isBooleanType())
     return 1;
   if (const auto *EIT = T->getAs<BitIntType>())
     return EIT->getNumBits();
   // For builtin types, just use the standard type sizing method
   return (unsigned)getTypeSize(T);
 }
 
 QualType ASTContext::getCorrespondingUnsignedType(QualType T) const {
   assert((T->hasSignedIntegerRepresentation() || T->isSignedFixedPointType()) &&
          "Unexpected type");
 
   // Turn <4 x signed int> -> <4 x unsigned int>
   if (const auto *VTy = T->getAs<VectorType>())
     return getVectorType(getCorrespondingUnsignedType(VTy->getElementType()),
                          VTy->getNumElements(), VTy->getVectorKind());
 
   // For _BitInt, return an unsigned _BitInt with same width.
   if (const auto *EITy = T->getAs<BitIntType>())
     return getBitIntType(/*IsUnsigned=*/true, EITy->getNumBits());
 
   // For enums, get the underlying integer type of the enum, and let the general
   // integer type signchanging code handle it.
   if (const auto *ETy = T->getAs<EnumType>())
     T = ETy->getDecl()->getIntegerType();
 
   switch (T->castAs<BuiltinType>()->getKind()) {
   case BuiltinType::Char_S:
   case BuiltinType::SChar:
     return UnsignedCharTy;
   case BuiltinType::Short:
     return UnsignedShortTy;
   case BuiltinType::Int:
     return UnsignedIntTy;
   case BuiltinType::Long:
     return UnsignedLongTy;
   case BuiltinType::LongLong:
     return UnsignedLongLongTy;
   case BuiltinType::Int128:
     return UnsignedInt128Ty;
   // wchar_t is special. It is either signed or not, but when it's signed,
   // there's no matching "unsigned wchar_t". Therefore we return the unsigned
   // version of it's underlying type instead.
   case BuiltinType::WChar_S:
     return getUnsignedWCharType();
 
   case BuiltinType::ShortAccum:
     return UnsignedShortAccumTy;
   case BuiltinType::Accum:
     return UnsignedAccumTy;
   case BuiltinType::LongAccum:
     return UnsignedLongAccumTy;
   case BuiltinType::SatShortAccum:
     return SatUnsignedShortAccumTy;
   case BuiltinType::SatAccum:
     return SatUnsignedAccumTy;
   case BuiltinType::SatLongAccum:
     return SatUnsignedLongAccumTy;
   case BuiltinType::ShortFract:
     return UnsignedShortFractTy;
   case BuiltinType::Fract:
     return UnsignedFractTy;
   case BuiltinType::LongFract:
     return UnsignedLongFractTy;
   case BuiltinType::SatShortFract:
     return SatUnsignedShortFractTy;
   case BuiltinType::SatFract:
     return SatUnsignedFractTy;
   case BuiltinType::SatLongFract:
     return SatUnsignedLongFractTy;
   default:
     llvm_unreachable("Unexpected signed integer or fixed point type");
   }
 }
 
 QualType ASTContext::getCorrespondingSignedType(QualType T) const {
   assert((T->hasUnsignedIntegerRepresentation() ||
           T->isUnsignedFixedPointType()) &&
          "Unexpected type");
 
   // Turn <4 x unsigned int> -> <4 x signed int>
   if (const auto *VTy = T->getAs<VectorType>())
     return getVectorType(getCorrespondingSignedType(VTy->getElementType()),
                          VTy->getNumElements(), VTy->getVectorKind());
 
   // For _BitInt, return a signed _BitInt with same width.

clang/lib/AST/ItaniumMangle.cpp

void CXXNameMangler::mangleType(const DecltypeType *T) {
   mangleExpression(E);
   Out << 'E';
 }
 
 void CXXNameMangler::mangleType(const UnaryTransformType *T) {
   // If this is dependent, we need to record that. If not, we simply
   // mangle it as the underlying type since they are equivalent.
   if (T->isDependentType()) {
     Out << 'U';
 
     switch (T->getUTTKind()) {
       case UnaryTransformType::EnumUnderlyingType:
         Out << "3eut";
         break;
+      case UnaryTransformType::AddConst:
+        Out << "2ac";
+        break;
+      case UnaryTransformType::AddCV:
+        Out << "3acv";
+        break;
+      case UnaryTransformType::AddLvalueReference:
+        Out << "5alref";
+        break;
+      case UnaryTransformType::AddPointer:
+        Out << "4aptr";
+        break;
+      case UnaryTransformType::AddRvalueReference:
+        Out << "5arref";
+        break;
+      case UnaryTransformType::AddVolatile:
+        Out << "2av";
+        break;
+      case UnaryTransformType::Decay:
+        Out << "1d";
+        break;
+      case UnaryTransformType::MakeSigned:
+        Out << "3msi";
+        break;
+      case UnaryTransformType::MakeUnsigned:
+        Out << "3mui";
+        break;
+      case UnaryTransformType::RemoveConst:
+        Out << "2rc";
+        break;
+      case UnaryTransformType::RemoveCV:
+        Out << "3rcv";
+        break;
+      case UnaryTransformType::RemoveCVRef:
+        Out << "6rcvref";
+        break;
+      case UnaryTransformType::RemovePointer:
+        Out << "4rptr";
+        break;
+      case UnaryTransformType::RemoveReference:
+        Out << "2rr";
+        break;
+      case UnaryTransformType::RemoveVolatile:
+        Out << "2rv";
+        break;
     }
   }
 
   mangleType(T->getBaseType());
 }
 
 void CXXNameMangler::mangleType(const AutoType *T) {
   assert(T->getDeducedType().isNull() &&
          "Deduced AutoType shouldn't be handled here!");
   assert(T->getKeyword() != AutoTypeKeyword::GNUAutoType &&
          "shouldn't need to mangle __auto_type!");
   // <builtin-type> ::= Da # auto

clang/lib/AST/JSONNodeDumper.cpp

void JSONNodeDumper::VisitUnresolvedUsingType(const UnresolvedUsingType *UUT) {
   JOS.attribute("decl", createBareDeclRef(UUT->getDecl()));
 }
 
 void JSONNodeDumper::VisitUnaryTransformType(const UnaryTransformType *UTT) {
   switch (UTT->getUTTKind()) {
   case UnaryTransformType::EnumUnderlyingType:
     JOS.attribute("transformKind", "underlying_type");
     break;
+  case UnaryTransformType::AddConst:
+    JOS.attribute("transformedKind", "add_const");
+    break;
+  case UnaryTransformType::AddCV:
+    JOS.attribute("transformedKind", "add_cv");
+    break;
+  case UnaryTransformType::AddLvalueReference:
+    JOS.attribute("transformedKind", "add_lvalue_reference");
+    break;
+  case UnaryTransformType::AddPointer:
+    JOS.attribute("transformedKind", "add_pointer");
+    break;
+  case UnaryTransformType::AddRvalueReference:
+    JOS.attribute("transformedKind", "add_rvalue_reference");
+    break;
+  case UnaryTransformType::AddVolatile:
+    JOS.attribute("transformedKind", "add_volatile");
+    break;
+  case UnaryTransformType::Decay:
+    JOS.attribute("transformedKind", "decay");
+    break;
+  case UnaryTransformType::MakeSigned:
+    JOS.attribute("transformedKind", "make_signed");
+    break;
+  case UnaryTransformType::MakeUnsigned:
+    JOS.attribute("transformedKind", "make_unsigned");
+    break;
+  case UnaryTransformType::RemoveConst:
+    JOS.attribute("transformedKind", "remove_const");
+    break;
+  case UnaryTransformType::RemoveCV:
+    JOS.attribute("transformedKind", "remove_cv");
+    break;
+  case UnaryTransformType::RemoveCVRef:
+    JOS.attribute("transformedKind", "remove_cvref");
+    break;
+  case UnaryTransformType::RemovePointer:
+    JOS.attribute("transformedKind", "remove_pointer");
+    break;
+  case UnaryTransformType::RemoveReference:
+    JOS.attribute("transformedKind", "remove_reference");
+    break;
+  case UnaryTransformType::RemoveVolatile:
+    JOS.attribute("transformedKind", "remove_volatile");
+    break;
   }
 }
 
 void JSONNodeDumper::VisitTagType(const TagType *TT) {
   JOS.attribute("decl", createBareDeclRef(TT->getDecl()));
 }
 
 void JSONNodeDumper::VisitTemplateTypeParmType(

clang/lib/AST/TextNodeDumper.cpp

void TextNodeDumper::VisitTypedefType(const TypedefType *T) {
   dumpDeclRef(T->getDecl());
 }
 
 void TextNodeDumper::VisitUnaryTransformType(const UnaryTransformType *T) {
   switch (T->getUTTKind()) {
   case UnaryTransformType::EnumUnderlyingType:
     OS << " underlying_type";
     break;
+  case UnaryTransformType::AddConst:
+    OS << " add_const";
+    break;
+  case UnaryTransformType::AddCV:
+    OS << " add_cv";
+    break;
+  case UnaryTransformType::AddLvalueReference:
+    OS << " add_lvalue_reference";
+    break;
+  case UnaryTransformType::AddPointer:
+    OS << " add_pointer";
+    break;
+  case UnaryTransformType::AddRvalueReference:
+    OS << " add_rvalue_reference";
+    break;
+  case UnaryTransformType::AddVolatile:
+    OS << " add_volatile";
+    break;
+  case UnaryTransformType::Decay:
+    OS << " decay";
+    break;
+  case UnaryTransformType::MakeSigned:
+    OS << " make_signed";
+    break;
+  case UnaryTransformType::MakeUnsigned:
+    OS << " make_unsigned";
+    break;
+  case UnaryTransformType::RemoveConst:
+    OS << " remove_const";
+    break;
+  case UnaryTransformType::RemoveCV:
+    OS << " remove_cv";
+    break;
+  case UnaryTransformType::RemoveCVRef:
+    OS << " remove_cvref";
+    break;
+  case UnaryTransformType::RemovePointer:
+    OS << " remove_pointer";
+    break;
+  case UnaryTransformType::RemoveReference:
+    OS << " remove_reference";
+    break;
+  case UnaryTransformType::RemoveVolatile:
+    OS << " remove_volatile";
+    break;
   }
 }
 
 void TextNodeDumper::VisitTagType(const TagType *T) {
   dumpDeclRef(T->getDecl());
 }
 
 void TextNodeDumper::VisitTemplateTypeParmType(const TemplateTypeParmType *T) {

clang/lib/AST/TypePrinter.cpp

 #include "clang/AST/DeclCXX.h"
 #include "clang/AST/DeclObjC.h"
 #include "clang/AST/DeclTemplate.h"
 #include "clang/AST/Expr.h"
 #include "clang/AST/NestedNameSpecifier.h"
 #include "clang/AST/PrettyPrinter.h"
 #include "clang/AST/TemplateBase.h"
 #include "clang/AST/TemplateName.h"
+#include "clang/AST/TextNodeDumper.h"
 #include "clang/AST/Type.h"
 #include "clang/Basic/AddressSpaces.h"
 #include "clang/Basic/ExceptionSpecificationType.h"
 #include "clang/Basic/IdentifierTable.h"
 #include "clang/Basic/LLVM.h"
 #include "clang/Basic/LangOptions.h"
 #include "clang/Basic/SourceLocation.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Basic/Specifiers.h"
 #include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/SaveAndRestore.h"
 #include "llvm/Support/raw_ostream.h"

 void TypePrinter::printDecltypeAfter(const DecltypeType *T, raw_ostream &OS) {}
 
 void TypePrinter::printUnaryTransformBefore(const UnaryTransformType *T,
                                             raw_ostream &OS) {
   IncludeStrongLifetimeRAII Strong(Policy);
 
   switch (T->getUTTKind()) {
     case UnaryTransformType::EnumUnderlyingType:
-      OS << "__underlying_type(";
+    case UnaryTransformType::AddConst:
+    case UnaryTransformType::AddCV:
+    case UnaryTransformType::AddLvalueReference:
+    case UnaryTransformType::AddPointer:
+    case UnaryTransformType::AddRvalueReference:
+    case UnaryTransformType::AddVolatile:
+    case UnaryTransformType::Decay:
+    case UnaryTransformType::MakeSigned:
+    case UnaryTransformType::MakeUnsigned:
+    case UnaryTransformType::RemoveConst:
+    case UnaryTransformType::RemoveCV:
+    case UnaryTransformType::RemoveCVRef:
+    case UnaryTransformType::RemovePointer:
+    case UnaryTransformType::RemoveReference:
+    case UnaryTransformType::RemoveVolatile: {
+      static llvm::DenseMap<int, const char *> Transformation = {
+          {{UnaryTransformType::EnumUnderlyingType, "__underlying_type"},
+           {UnaryTransformType::AddConst, "__add_const"},
+           {UnaryTransformType::AddCV, "__add_cv"},
+           {UnaryTransformType::AddLvalueReference, "__add_lvalue_reference"},
+           {UnaryTransformType::AddPointer, "__add_pointer"},
+           {UnaryTransformType::AddRvalueReference, "__add_rvalue_reference"},
+           {UnaryTransformType::AddVolatile, "__add_volatile"},
+           {UnaryTransformType::Decay, "__decay"},
+           {UnaryTransformType::MakeSigned, "__make_signed"},
+           {UnaryTransformType::MakeUnsigned, "__make_unsigned"},
+           {UnaryTransformType::RemoveConst, "__remove_const"},
+           {UnaryTransformType::RemoveCV, "__remove_cv"},
+           {UnaryTransformType::RemoveCVRef, "__remove_cvref"},
+           {UnaryTransformType::RemovePointer, "__remove_pointer"},
+           {UnaryTransformType::RemoveReference, "__remove_reference"},
+           {UnaryTransformType::RemoveVolatile, "__remove_volatile"}}};
+      OS << Transformation[T->getUTTKind()] << '(';
       print(T->getBaseType(), OS, StringRef());
       OS << ')';
       spaceBeforePlaceHolder(OS);
       return;
     }
+  }
 
   printBefore(T->getBaseType(), OS);
 }
 
 void TypePrinter::printUnaryTransformAfter(const UnaryTransformType *T,
                                            raw_ostream &OS) {
   IncludeStrongLifetimeRAII Strong(Policy);
 
   switch (T->getUTTKind()) {
     case UnaryTransformType::EnumUnderlyingType:
+    case UnaryTransformType::AddConst:
+    case UnaryTransformType::AddCV:
+    case UnaryTransformType::AddLvalueReference:
+    case UnaryTransformType::AddPointer:
+    case UnaryTransformType::AddRvalueReference:
+    case UnaryTransformType::AddVolatile:
+    case UnaryTransformType::Decay:
+    case UnaryTransformType::MakeSigned:
+    case UnaryTransformType::MakeUnsigned:
+    case UnaryTransformType::RemoveConst:
+    case UnaryTransformType::RemoveCV:
+    case UnaryTransformType::RemoveCVRef:
+    case UnaryTransformType::RemovePointer:
+    case UnaryTransformType::RemoveReference:
+    case UnaryTransformType::RemoveVolatile:
       return;
   }
 
   printAfter(T->getBaseType(), OS);
 }
 
 void TypePrinter::printAutoBefore(const AutoType *T, raw_ostream &OS) {
   // If the type has been deduced, do not print 'auto'.
   if (!T->getDeducedType().isNull()) {
     printBefore(T->getDeducedType(), OS);
   } else {
     if (T->isConstrained()) {

clang/lib/Format/FormatToken.cpp

bool FormatToken::isSimpleTypeSpecifier() const {
   case tok::kw_double:
   case tok::kw___bf16:
   case tok::kw__Float16:
   case tok::kw___float128:
   case tok::kw___ibm128:
   case tok::kw_wchar_t:
   case tok::kw_bool:
   case tok::kw___underlying_type:
+  case tok::kw___add_const:
+  case tok::kw___add_cv:
+  case tok::kw___add_lvalue_reference:
+  case tok::kw___add_pointer:
+  case tok::kw___add_rvalue_reference:
+  case tok::kw___add_volatile:
+  case tok::kw___decay:
+  case tok::kw___make_signed:
+  case tok::kw___make_unsigned:
+  case tok::kw___remove_const:
+  case tok::kw___remove_cv:
+  case tok::kw___remove_cvref:
+  case tok::kw___remove_pointer:
+  case tok::kw___remove_reference:
+  case tok::kw___remove_volatile:
   case tok::annot_typename:
   case tok::kw_char8_t:
   case tok::kw_char16_t:
   case tok::kw_char32_t:
   case tok::kw_typeof:
   case tok::kw_decltype:
   case tok::kw__Atomic:
     return true;

clang/lib/Lex/PPMacroExpansion.cpp

EvaluateFeatureLikeBuiltinMacro(OS, Tok, II, *this, false,
               II->getName().startswith("__is_") ||
               II->getName().startswith("__has_"))
             return true;
           return llvm::StringSwitch<bool>(II->getName())
               .Case("__array_rank", true)
               .Case("__array_extent", true)
               .Case("__reference_binds_to_temporary", true)
               .Case("__underlying_type", true)
+              .Case("__add_const", true)
+              .Case("__add_cv", true)
+              .Case("__add_lvalue_reference", true)
+              .Case("__add_pointer", true)
+              .Case("__add_rvalue_reference", true)
+              .Case("__add_volatile", true)
+              .Case("__decay", true)
+              .Case("__make_signed", true)
+              .Case("__make_unsigned", true)
+              .Case("__remove_const", true)
+              .Case("__remove_cv", true)
+              .Case("__remove_cvref", true)
+              .Case("__remove_pointer", true)
+              .Case("__remove_reference", true)
+              .Case("__remove_volatile", true)
               .Default(false);
         } else {
           return llvm::StringSwitch<bool>(II->getName())
               // Report builtin templates as being builtins.
               .Case("__make_integer_seq", getLangOpts().CPlusPlus)
               .Case("__type_pack_element", getLangOpts().CPlusPlus)
               // Likewise for some builtin preprocessor macros.
               // FIXME: This is inconsistent; we usually suggest detecting

clang/lib/Parse/ParseDecl.cpp

case tok::kw___is_signed:
           DS.getTypeQualifiers() == DeclSpec::TQ_const &&
           DS.getStorageClassSpec() == DeclSpec::SCS_static)
         TryKeywordIdentFallback(true);
 
       // We're done with the declaration-specifiers.
       goto DoneWithDeclSpec;
 
       // typedef-name
     case tok::kw___super:
     case tok::kw_decltype:
     case tok::identifier: {
       // This identifier can only be a typedef name if we haven't already seen
       // a type-specifier.  Without this check we misparse:
       //  typedef int X; struct Y { short X; };  as 'short int'.
       if (DS.hasTypeSpecifier())
         goto DoneWithDeclSpec;
 
       // If the token is an identifier named "__declspec" and Microsoft
       // extensions are not enabled, it is likely that there will be cascading
       // parse errors if this really is a __declspec attribute. Attempt to
#include "clang/Basic/OpenCLImageTypes.def"
     case tok::annot_pragma_ms_vtordisp:
       HandlePragmaMSVtorDisp();
       continue;
 
     case tok::annot_pragma_ms_pointers_to_members:
       HandlePragmaMSPointersToMembers();
       continue;
 
     case tok::kw___underlying_type:
       ParseUnderlyingTypeSpecifier(DS);
       continue;
 
+    case tok::kw___add_const:
+    case tok::kw___add_cv:
+    case tok::kw___add_lvalue_reference:
+    case tok::kw___add_pointer:
+    case tok::kw___add_rvalue_reference:
+    case tok::kw___add_volatile:
+    case tok::kw___decay:
+    case tok::kw___make_signed:
+    case tok::kw___make_unsigned:
+    case tok::kw___remove_const:
+    case tok::kw___remove_cv:
+    case tok::kw___remove_cvref:
+    case tok::kw___remove_pointer:
+    case tok::kw___remove_reference:
+    case tok::kw___remove_volatile:
+      ParseTypeTransformTypeSpecifier(DS);
+      continue;
+
     case tok::kw__Atomic:
       // C11 6.7.2.4/4:
       //   If the _Atomic keyword is immediately followed by a left parenthesis,
       //   it is interpreted as a type specifier (with a type name), not as a
       //   type qualifier.
       if (!getLangOpts().C11)
         Diag(Tok, diag::ext_c11_feature) << Tok.getName();
 
       if (NextToken().is(tok::l_paren)) {
#include "clang/Basic/OpenCLImageTypes.def"
     if (DiagID != diag::err_bool_redeclaration && ConsumedEnd.isInvalid())
       // After an error the next token can be an annotation token.
       ConsumeAnyToken();
 
     AttrsLastTime = false;
   }
 }
 
+DeclSpec::TST Parser::TypeTransformTokToDeclSpec() {
+  switch (Tok.getKind()) {
+  case tok::kw___add_const:
+    return DeclSpec::TST_add_const;
+  case tok::kw___add_cv:
+    return DeclSpec::TST_add_cv;
+  case tok::kw___add_lvalue_reference:
+    return DeclSpec::TST_add_lvalue_reference;
+  case tok::kw___add_pointer:
+    return DeclSpec::TST_add_pointer;
+  case tok::kw___add_rvalue_reference:
+    return DeclSpec::TST_add_rvalue_reference;
+  case tok::kw___add_volatile:
+    return DeclSpec::TST_add_volatile;
+  case tok::kw___decay:
+    return DeclSpec::TST_decay;
+  case tok::kw___make_signed:
+    return DeclSpec::TST_make_signed;
+  case tok::kw___make_unsigned:
+    return DeclSpec::TST_make_unsigned;
+  case tok::kw___remove_const:
+    return DeclSpec::TST_remove_const;
+  case tok::kw___remove_cv:
+    return DeclSpec::TST_remove_cv;
+  case tok::kw___remove_cvref:
+    return DeclSpec::TST_remove_cvref;
+  case tok::kw___remove_pointer:
+    return DeclSpec::TST_remove_pointer;
+  case tok::kw___remove_reference:
+    return DeclSpec::TST_remove_reference;
+  case tok::kw___remove_volatile:
+    return DeclSpec::TST_remove_volatile;
+  default:
+    llvm_unreachable(__FILE__
+                     "passed in an unhandled type transformation built-in");
+  }
+}
+
+void Parser::ParseTypeTransformTypeSpecifier(DeclSpec &DS) {
+  DeclSpec::TST TypeTransformTST = TypeTransformTokToDeclSpec();
+  SourceLocation StartLoc = ConsumeToken();
+  BalancedDelimiterTracker T(*this, tok::l_paren);
+  if (T.expectAndConsume(diag::err_expected_lparen_after,
+                         "type transformation builtin", tok::r_paren))
+    return;
+
+  TypeResult BaseTyResult = ParseTypeName();
+  if (BaseTyResult.isInvalid()) {
+    SkipUntil(tok::r_paren, StopAtSemi);
+    return;
+  }
+
+  T.consumeClose();
+  if (T.getCloseLocation().isInvalid())
+    return;
+
+  const char *PrevSpec;
+  unsigned DiagID;
+  if (DS.SetTypeSpecType(TypeTransformTST, StartLoc, PrevSpec, DiagID,
+                         BaseTyResult.get(),
+                         Actions.getASTContext().getPrintingPolicy())) {
+    Diag(StartLoc, DiagID) << PrevSpec;
+  }
+  DS.setTypeofParensRange(T.getRange());
+}
+
 /// ParseStructDeclaration - Parse a struct declaration without the terminating
 /// semicolon.
 ///
 /// Note that a struct declaration refers to a declaration in a struct,
 /// not to the declaration of a struct.
 ///
 ///       struct-declaration:
 /// [C2x]   attributes-specifier-seq[opt]

clang/lib/Parse/ParseDeclCXX.cpp

void Parser::ParseUnderlyingTypeSpecifier(DeclSpec &DS) {
   assert(Tok.is(tok::kw___underlying_type) &&
          "Not an underlying type specifier");
 
   SourceLocation StartLoc = ConsumeToken();
   BalancedDelimiterTracker T(*this, tok::l_paren);
   if (T.expectAndConsume(diag::err_expected_lparen_after,
                        "__underlying_type", tok::r_paren)) {
     return;
   }
 
   TypeResult Result = ParseTypeName();
   if (Result.isInvalid()) {
     SkipUntil(tok::r_paren, StopAtSemi);
     return;
   }
 
   // Match the ')'
   T.consumeClose();
void Parser::ParseClassSpecifier(tok::TokenKind TagTokKind,
 
   // Allow attributes to precede or succeed the inheritance specifiers.
   MaybeParseAttributes(PAKM_CXX11 | PAKM_Declspec | PAKM_GNU, attrs);
 
   // Source location used by FIXIT to insert misplaced
   // C++11 attributes
   SourceLocation AttrFixitLoc = Tok.getLocation();
 
-  if (TagType == DeclSpec::TST_struct &&
-      Tok.isNot(tok::identifier) &&
-      !Tok.isAnnotation() &&
-      Tok.getIdentifierInfo() &&
-      Tok.isOneOf(tok::kw___is_abstract,
-                  tok::kw___is_aggregate,
-                  tok::kw___is_arithmetic,
-                  tok::kw___is_array,
-                  tok::kw___is_assignable,
-                  tok::kw___is_base_of,
-                  tok::kw___is_class,
-                  tok::kw___is_complete_type,
-                  tok::kw___is_compound,
-                  tok::kw___is_const,
-                  tok::kw___is_constructible,
-                  tok::kw___is_convertible,
-                  tok::kw___is_convertible_to,
-                  tok::kw___is_destructible,
-                  tok::kw___is_empty,
-                  tok::kw___is_enum,
-                  tok::kw___is_floating_point,
-                  tok::kw___is_final,
-                  tok::kw___is_function,
-                  tok::kw___is_fundamental,
-                  tok::kw___is_integral,
-                  tok::kw___is_interface_class,
-                  tok::kw___is_literal,
-                  tok::kw___is_lvalue_expr,
-                  tok::kw___is_lvalue_reference,
-                  tok::kw___is_member_function_pointer,
-                  tok::kw___is_member_object_pointer,
-                  tok::kw___is_member_pointer,
-                  tok::kw___is_nothrow_assignable,
-                  tok::kw___is_nothrow_constructible,
-                  tok::kw___is_nothrow_destructible,
-                  tok::kw___is_object,
-                  tok::kw___is_pod,
-                  tok::kw___is_pointer,
-                  tok::kw___is_polymorphic,
-                  tok::kw___is_reference,
-                  tok::kw___is_rvalue_expr,
-                  tok::kw___is_rvalue_reference,
-                  tok::kw___is_same,
-                  tok::kw___is_scalar,
-                  tok::kw___is_sealed,
-                  tok::kw___is_signed,
-                  tok::kw___is_standard_layout,
-                  tok::kw___is_trivial,
-                  tok::kw___is_trivially_assignable,
-                  tok::kw___is_trivially_constructible,
-                  tok::kw___is_trivially_copyable,
-                  tok::kw___is_union,
-                  tok::kw___is_unsigned,
-                  tok::kw___is_void,
-                  tok::kw___is_volatile))
+  if (TagType == DeclSpec::TST_struct && Tok.isNot(tok::identifier) &&
+      !Tok.isAnnotation() && Tok.getIdentifierInfo() &&
+      Tok.isOneOf( // clang-format off
+          tok::kw___add_const,
+          tok::kw___add_cv,
+          tok::kw___add_lvalue_reference,
+          tok::kw___add_pointer,
+          tok::kw___add_rvalue_reference,
+          tok::kw___add_volatile,
+          tok::kw___decay,
+          tok::kw___is_abstract,
+          tok::kw___is_volatile,
+          tok::kw___make_signed,
+          tok::kw___make_unsigned,
+          tok::kw___remove_const,
+          tok::kw___remove_cv,
+          tok::kw___remove_cvref,
+          tok::kw___remove_pointer,
+          tok::kw___remove_reference,
+          tok::kw___remove_volatile)) // clang-format on
     // GNU libstdc++ 4.2 and libc++ use certain intrinsic names as the
     // name of struct templates, but some are keywords in GCC >= 4.3
     // and Clang. Therefore, when we see the token sequence "struct
     // X", make X into a normal identifier rather than a keyword, to
     // allow libstdc++ 4.2 and libc++ to work properly.
     TryKeywordIdentFallback(true);
 
   struct PreserveAtomicIdentifierInfoRAII {

clang/lib/Sema/DeclSpec.cpp

 #include "clang/Sema/DeclSpec.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/DeclCXX.h"
 #include "clang/AST/Expr.h"
 #include "clang/AST/LocInfoType.h"
 #include "clang/AST/TypeLoc.h"
 #include "clang/Basic/LangOptions.h"
 #include "clang/Basic/SourceManager.h"
+#include "clang/Basic/Specifiers.h"
 #include "clang/Basic/TargetInfo.h"
 #include "clang/Sema/ParsedTemplate.h"
 #include "clang/Sema/Sema.h"
 #include "clang/Sema/SemaDiagnostic.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallString.h"
 #include <cstring>
 using namespace clang;
#include "clang/Basic/OpenCLImageTypes.def"
 
     case TST_decltype:
     case TST_typeofExpr:
       if (Expr *E = DS.getRepAsExpr())
         return E->getType()->isFunctionType();
       return false;
 
     case TST_underlyingType:
+    case TST_add_const:
+    case TST_add_cv:
+    case TST_add_lvalue_reference:
+    case TST_add_pointer:
+    case TST_add_rvalue_reference:
+    case TST_add_volatile:
+    case TST_decay:
+    case TST_make_signed:
+    case TST_make_unsigned:
+    case TST_remove_const:
+    case TST_remove_cv:
+    case TST_remove_cvref:
+    case TST_remove_pointer:
+    case TST_remove_reference:
+    case TST_remove_volatile:
     case TST_typename:
     case TST_typeofType: {
       QualType QT = DS.getRepAsType().get();
       if (QT.isNull())
         return false;
 
       if (const LocInfoType *LIT = dyn_cast<LocInfoType>(QT))
         QT = LIT->getType();
const char *DeclSpec::getSpecifierName(DeclSpec::TST T,
   case DeclSpec::TST_interface:   return "__interface";
   case DeclSpec::TST_typename:    return "type-name";
   case DeclSpec::TST_typeofType:
   case DeclSpec::TST_typeofExpr:  return "typeof";
   case DeclSpec::TST_auto:        return "auto";
   case DeclSpec::TST_auto_type:   return "__auto_type";
   case DeclSpec::TST_decltype:    return "(decltype)";
   case DeclSpec::TST_decltype_auto: return "decltype(auto)";
   case DeclSpec::TST_underlyingType: return "__underlying_type";
+  case DeclSpec::TST_add_const:
+    return "__add_const";
+  case DeclSpec::TST_add_cv:
+    return "__add_cv";
+  case DeclSpec::TST_add_lvalue_reference:
+    return "__add_lvalue_reference";
+  case DeclSpec::TST_add_pointer:
+    return "__add_pointer";
+  case DeclSpec::TST_add_rvalue_reference:
+    return "__add_rvalue_reference";
+  case DeclSpec::TST_add_volatile:
+    return "__add_volatile";
+  case DeclSpec::TST_decay:
+    return "__decay";
+  case DeclSpec::TST_make_signed:
+    return "__make_signed";
+  case DeclSpec::TST_make_unsigned:
+    return "__make_unsigned";
+  case DeclSpec::TST_remove_const:
+    return "__remove_const";
+  case DeclSpec::TST_remove_cv:
+    return "__remove_cv";
+  case DeclSpec::TST_remove_cvref:
+    return "__remove_cvref";
+  case DeclSpec::TST_remove_pointer:
+    return "__remove_pointer";
+  case DeclSpec::TST_remove_reference:
+    return "__remove_reference";
+  case DeclSpec::TST_remove_volatile:
+    return "__remove_volatile";
   case DeclSpec::TST_unknown_anytype: return "__unknown_anytype";
   case DeclSpec::TST_atomic: return "_Atomic";
   case DeclSpec::TST_BFloat16: return "__bf16";
 #define GENERIC_IMAGE_TYPE(ImgType, Id) \
   case DeclSpec::TST_##ImgType##_t: \
     return #ImgType "_t";
 #include "clang/Basic/OpenCLImageTypes.def"
   case DeclSpec::TST_error:       return "(error)";

clang/lib/Sema/SemaDecl.cpp

bool Sema::isSimpleTypeSpecifier(tok::TokenKind Kind) const {
   case tok::kw_double:
   case tok::kw___bf16:
   case tok::kw__Float16:
   case tok::kw___float128:
   case tok::kw___ibm128:
   case tok::kw_wchar_t:
   case tok::kw_bool:
   case tok::kw___underlying_type:
+  case tok::kw___add_const:
+  case tok::kw___add_cv:
+  case tok::kw___add_volatile:
+  case tok::kw___decay:
+  case tok::kw___make_signed:
+  case tok::kw___make_unsigned:
+  case tok::kw___remove_const:
+  case tok::kw___remove_cv:
+  case tok::kw___remove_cvref:
+  case tok::kw___remove_reference:
+  case tok::kw___remove_volatile:
   case tok::kw___auto_type:
     return true;
 
   case tok::annot_typename:
   case tok::kw_char16_t:
   case tok::kw_char32_t:
   case tok::kw_typeof:
   case tok::annot_decltype:
static bool RebuildDeclaratorInCurrentInstantiation(Sema &S, Declarator &D,
   // type.  It's safest to just say "dependent", but we call out a
   // few cases here.
 
   DeclSpec &DS = D.getMutableDeclSpec();
   switch (DS.getTypeSpecType()) {
   case DeclSpec::TST_typename:
   case DeclSpec::TST_typeofType:
   case DeclSpec::TST_underlyingType:
+  case DeclSpec::TST_add_const:
+  case DeclSpec::TST_add_cv:
+  case DeclSpec::TST_add_volatile:
+  case DeclSpec::TST_decay:
+  case DeclSpec::TST_make_signed:
+  case DeclSpec::TST_make_unsigned:
+  case DeclSpec::TST_remove_const:
+  case DeclSpec::TST_remove_cv:
+  case DeclSpec::TST_remove_cvref:
+  case DeclSpec::TST_remove_reference:
+  case DeclSpec::TST_remove_volatile:
   case DeclSpec::TST_atomic: {
     // Grab the type from the parser.
     TypeSourceInfo *TSI = nullptr;
     QualType T = S.GetTypeFromParser(DS.getRepAsType(), &TSI);
     if (T.isNull() || !T->isInstantiationDependentType()) break;
 
     // Make sure there's a type source info.  This isn't really much
     // of a waste; most dependent types should have type source info

clang/lib/Sema/SemaTemplateVariadic.cpp

 }
 
 bool Sema::containsUnexpandedParameterPacks(Declarator &D) {
   const DeclSpec &DS = D.getDeclSpec();
   switch (DS.getTypeSpecType()) {
   case TST_typename:
   case TST_typeofType:
   case TST_underlyingType:
+  case TST_add_const:
+  case TST_add_cv:
+  case TST_add_lvalue_reference:
+  case TST_add_pointer:
+  case TST_add_rvalue_reference:
+  case TST_add_volatile:
+  case TST_decay:
+  case TST_make_signed:
+  case TST_make_unsigned:
+  case TST_remove_const:
+  case TST_remove_cv:
+  case TST_remove_cvref:
+  case TST_remove_pointer:
+  case TST_remove_reference:
+  case TST_remove_volatile:
   case TST_atomic: {
     QualType T = DS.getRepAsType().get();
     if (!T.isNull() && T->containsUnexpandedParameterPack())
       return true;
     break;
   }
 
   case TST_typeofExpr:

clang/lib/Sema/SemaType.cpp

 #include "clang/AST/ASTConsumer.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/ASTMutationListener.h"
 #include "clang/AST/ASTStructuralEquivalence.h"
 #include "clang/AST/CXXInheritance.h"
 #include "clang/AST/DeclObjC.h"
 #include "clang/AST/DeclTemplate.h"
 #include "clang/AST/Expr.h"
+#include "clang/AST/Type.h"
 #include "clang/AST/TypeLoc.h"
 #include "clang/AST/TypeLocVisitor.h"
 #include "clang/Basic/PartialDiagnostic.h"
+#include "clang/Basic/Specifiers.h"
 #include "clang/Basic/TargetInfo.h"
 #include "clang/Lex/Preprocessor.h"
 #include "clang/Sema/DeclSpec.h"
 #include "clang/Sema/DelayedDiagnostic.h"
 #include "clang/Sema/Lookup.h"
 #include "clang/Sema/ParsedTemplate.h"
 #include "clang/Sema/ScopeInfo.h"
 #include "clang/Sema/SemaInternal.h"

 static OpenCLAccessAttr::Spelling
 getImageAccess(const ParsedAttributesView &Attrs) {
   for (const ParsedAttr &AL : Attrs)
     if (AL.getKind() == ParsedAttr::AT_OpenCLAccess)
       return static_cast<OpenCLAccessAttr::Spelling>(AL.getSemanticSpelling());
   return OpenCLAccessAttr::Keyword_read_only;
 }
 
+static UnaryTransformType::UTTKind
+TSTToUnaryTransformType(DeclSpec::TST SwitchTST) {
+  switch (SwitchTST) {
+  case TST_add_const:
+    return UnaryTransformType::AddConst;
+  case TST_add_cv:
+    return UnaryTransformType::AddCV;
+  case TST_add_lvalue_reference:
+    return UnaryTransformType::AddLvalueReference;
+  case TST_add_pointer:
+    return UnaryTransformType::AddPointer;
+  case TST_add_rvalue_reference:
+    return UnaryTransformType::AddRvalueReference;
+  case TST_add_volatile:
+    return UnaryTransformType::AddVolatile;
+  case TST_decay:
+    return UnaryTransformType::Decay;
+  case TST_make_signed:
+    return UnaryTransformType::MakeSigned;
+  case TST_make_unsigned:
+    return UnaryTransformType::MakeUnsigned;
+  case TST_remove_const:
+    return UnaryTransformType::RemoveConst;
+  case TST_remove_cv:
+    return UnaryTransformType::RemoveCV;
+  case TST_remove_cvref:
+    return UnaryTransformType::RemoveCVRef;
+  case TST_remove_pointer:
+    return UnaryTransformType::RemovePointer;
+  case TST_remove_reference:
+    return UnaryTransformType::RemoveReference;
+  case TST_remove_volatile:
+    return UnaryTransformType::RemoveVolatile;
+  case TST_underlyingType:
+    return UnaryTransformType::EnumUnderlyingType;
+  default:
+    llvm_unreachable("attempted to parse a non-unary transform builtin");
+  }
+}
+
 /// Convert the specified declspec to the appropriate type
 /// object.
 /// \param state Specifies the declarator containing the declaration specifier
 /// to be converted, along with other associated processing state.
 /// \returns The type described by the declaration specifiers.  This function
 /// never returns null.
 static QualType ConvertDeclSpecToType(TypeProcessingState &state) {
   // FIXME: Should move the logic from DeclSpec::Finish to here for validity
case DeclSpec::TST_decltype: {
     Result = S.BuildDecltypeType(E);
     if (Result.isNull()) {
       Result = Context.IntTy;
       declarator.setInvalidType(true);
     }
     break;
   }
   case DeclSpec::TST_underlyingType:
+  case DeclSpec::TST_add_const:
+  case DeclSpec::TST_add_cv:
+  case DeclSpec::TST_add_lvalue_reference:
+  case DeclSpec::TST_add_pointer:
+  case DeclSpec::TST_add_rvalue_reference:
+  case DeclSpec::TST_add_volatile:
+  case DeclSpec::TST_decay:
+  case DeclSpec::TST_make_signed:
+  case DeclSpec::TST_make_unsigned:
+  case DeclSpec::TST_remove_const:
+  case DeclSpec::TST_remove_cv:
+  case DeclSpec::TST_remove_cvref:
+  case DeclSpec::TST_remove_pointer:
+  case DeclSpec::TST_remove_reference:
+  case DeclSpec::TST_remove_volatile:
     Result = S.GetTypeFromParser(DS.getRepAsType());
-    assert(!Result.isNull() && "Didn't get a type for __underlying_type?");
-    Result = S.BuildUnaryTransformType(Result,
-                                       UnaryTransformType::EnumUnderlyingType,
-                                       DS.getTypeSpecTypeLoc());
+    assert(!Result.isNull() && "Didn't get a type for the transformation?");
+    Result = S.BuildUnaryTransformType(
+        Result, TSTToUnaryTransformType(DS.getTypeSpecType()),
     if (Result.isNull()) {
+      if (DS.getTypeSpecType() == DeclSpec::TST_underlyingType)
         Result = Context.IntTy;
       declarator.setInvalidType(true);
     }
     break;
 
   case DeclSpec::TST_auto:
   case DeclSpec::TST_decltype_auto: {
     auto AutoKW = DS.getTypeSpecType() == DeclSpec::TST_decltype_auto
                       ? AutoTypeKeyword::DecltypeAuto
void VisitTypeOfTypeLoc(TypeOfTypeLoc TL) {
       TL.setTypeofLoc(DS.getTypeSpecTypeLoc());
       TL.setParensRange(DS.getTypeofParensRange());
       assert(DS.getRepAsType());
       TypeSourceInfo *TInfo = nullptr;
       Sema::GetTypeFromParser(DS.getRepAsType(), &TInfo);
       TL.setUnderlyingTInfo(TInfo);
     }
     void VisitUnaryTransformTypeLoc(UnaryTransformTypeLoc TL) {
-      // FIXME: This holds only because we only have one unary transform.
-      assert(DS.getTypeSpecType() == DeclSpec::TST_underlyingType);
+      // Make sure it is a unary transform type
+      assert(DS.getTypeSpecType() >= DeclSpec::TST_underlyingType &&
+             DS.getTypeSpecType() <= DeclSpec::TST_remove_volatile);
       TL.setKWLoc(DS.getTypeSpecTypeLoc());
       TL.setParensRange(DS.getTypeofParensRange());
       assert(DS.getRepAsType());
       TypeSourceInfo *TInfo = nullptr;
       Sema::GetTypeFromParser(DS.getRepAsType(), &TInfo);
       TL.setUnderlyingTInfo(TInfo);
     }
     void VisitBuiltinTypeLoc(BuiltinTypeLoc TL) {
if (AsUnevaluated && CodeSynthesisContexts.empty() &&
     Diag(E->getExprLoc(), diag::warn_side_effects_unevaluated_context);
   }
   return Context.getDecltypeType(E, getDecltypeForExpr(E));
 }
 
 QualType Sema::BuildUnaryTransformType(QualType BaseType,
                                        UnaryTransformType::UTTKind UKind,
                                        SourceLocation Loc) {
+  if (BaseType->isDependentType())
+    return Context.getUnaryTransformType(BaseType, BaseType, UKind);
   switch (UKind) {
   case UnaryTransformType::EnumUnderlyingType:
     if (!BaseType->isDependentType() && !BaseType->isEnumeralType()) {
       Diag(Loc, diag::err_only_enums_have_underlying_types);
       return QualType();
     } else {
       QualType Underlying = BaseType;
       if (!BaseType->isDependentType()) {
         // The enum could be incomplete if we're parsing its definition or
         // recovering from an error.
         NamedDecl *FwdDecl = nullptr;
         if (BaseType->isIncompleteType(&FwdDecl)) {
           Diag(Loc, diag::err_underlying_type_of_incomplete_enum) << BaseType;
           Diag(FwdDecl->getLocation(), diag::note_forward_declaration) << FwdDecl;
           return QualType();
         }
 
         EnumDecl *ED = BaseType->castAs<EnumType>()->getDecl();
         assert(ED && "EnumType has no EnumDecl");
 
         DiagnoseUseOfDecl(ED, Loc);
 
         Underlying = ED->getIntegerType();
         assert(!Underlying.isNull());
       }
       return Context.getUnaryTransformType(BaseType, Underlying,
                                         UnaryTransformType::EnumUnderlyingType);
     }
+  case UnaryTransformType::AddPointer: {
+    DeclarationName EntityName(BaseType.getBaseTypeIdentifier());
+    QualType PointerToT =
+        QualType(BaseType).isReferenceable() || BaseType->isVoidType()
+            ? BuildPointerType(BaseType.getNonReferenceType(), Loc, EntityName)
+            : BaseType;
+    return Context.getUnaryTransformType(BaseType, PointerToT, UKind);
+  }
+  case UnaryTransformType::RemovePointer: {
+    if (!BaseType->isPointerType())
+      return Context.getUnaryTransformType(BaseType, BaseType, UKind);
+    return Context.getUnaryTransformType(BaseType, BaseType->getPointeeType(),
+                                         UKind);
+  }
+  case UnaryTransformType::Decay: {
+    QualType Underlying = BaseType.getNonReferenceType();
+    if (Underlying->isArrayType() || Underlying->isFunctionType())
+      return Context.getUnaryTransformType(
+          BaseType, Context.getDecayedType(Underlying), UKind);
+
+    Qualifiers Quals = Underlying.getQualifiers();
+    Quals.removeCVRQualifiers();
+    return Context.getUnaryTransformType(
+        BaseType,
+        QualType(Underlying.getSplitUnqualifiedType().Ty,
+                 Quals.getAsOpaqueValue()),
+        UKind);
+  }
+  case UnaryTransformType::AddLvalueReference:
+  case UnaryTransformType::AddRvalueReference: {
+    DeclarationName EntityName(BaseType.getBaseTypeIdentifier());
+    QualType PointerToT =
+        QualType(BaseType).isReferenceable()
+            ? BuildReferenceType(
+                  BaseType, UKind == UnaryTransformType::AddLvalueReference,
+                  Loc, EntityName)
+            : BaseType;
+    return Context.getUnaryTransformType(BaseType, PointerToT, UKind);
+  }
+  case UnaryTransformType::RemoveCVRef:
+  case UnaryTransformType::RemoveReference: {
+    QualType Underlying = BaseType.getNonReferenceType();
+    Qualifiers Quals = Underlying.getQualifiers();
+    if (UKind == UnaryTransformType::RemoveCVRef) {
+      Quals.removeConst();
+      Quals.removeVolatile();
+    }
+    return Context.getUnaryTransformType(
+        BaseType,
+        QualType(Underlying.getSplitUnqualifiedType().Ty,
+                 Quals.getAsOpaqueValue()),
+        UKind);
+  }
+  case UnaryTransformType::AddConst:
+  case UnaryTransformType::AddCV:
+  case UnaryTransformType::AddVolatile:
+  case UnaryTransformType::RemoveConst:
+  case UnaryTransformType::RemoveCV:
+  case UnaryTransformType::RemoveVolatile: {
+    SplitQualType Split = BaseType.getSplitUnqualifiedType();
+    Qualifiers Quals = BaseType.getQualifiers();
+    if (BaseType->isReferenceType() || BaseType->isFunctionType())
+      return Context.getUnaryTransformType(BaseType, BaseType, UKind);
+
+    if (UKind == UnaryTransformType::AddConst ||
+        UKind == UnaryTransformType::AddCV)
+      Quals.addConst();
+    if (UKind == UnaryTransformType::AddVolatile ||
+        UKind == UnaryTransformType::AddCV)
+      Quals.addVolatile();
+
+    if (UKind == UnaryTransformType::RemoveConst ||
+        UKind == UnaryTransformType::RemoveCV)
+      Quals.removeConst();
+    if (UKind == UnaryTransformType::RemoveVolatile ||
+        UKind == UnaryTransformType::RemoveCV)
+      Quals.removeVolatile();
+
+    QualType Underlying(Split.Ty, Quals.getAsOpaqueValue());
+    return Context.getUnaryTransformType(BaseType, Underlying, UKind);
+  }
+  case UnaryTransformType::MakeSigned:
+  case UnaryTransformType::MakeUnsigned: {
+    if (BaseType->isDependentType())
+      return Context.getUnaryTransformType(BaseType, BaseType, UKind);
+    bool IsMakeSigned = UKind == UnaryTransformType::MakeSigned;
+    if ((!BaseType->isIntegerType() && !BaseType->isEnumeralType()) ||
+        BaseType->isBooleanType()) {
+      Diag(Loc, diag::err_make_signed_integral_only)
+          << IsMakeSigned << BaseType;
+      return QualType();
+    }
+    bool IsSigned = BaseType->isSignedIntegerType();
+    bool IsNonCharIntegral =
+        BaseType->isCharType() || BaseType->isEnumeralType();
+
+    // Clang doesn't seem to have a way to distinguish `char` from `signed char`
+    // and `unsigned char`
+    if (IsMakeSigned == IsSigned && !IsNonCharIntegral)
+      return Context.getUnaryTransformType(BaseType, BaseType, UKind);
+
+    QualType Underlying = Context.getIntTypeForBitwidth(
+        Context.getIntWidth(BaseType), IsMakeSigned);
+    Qualifiers Quals = Underlying.getQualifiers();
+    if (IsMakeSigned == IsSigned && BaseType->isCharType()) {
+      Quals.setCVRQualifiers(BaseType.getCVRQualifiers());
+      Underlying = QualType(Underlying.getSplitUnqualifiedType().Ty,
+                            Quals.getAsOpaqueValue());
+    }
+    return Context.getUnaryTransformType(BaseType, Underlying, UKind);
+  }
   }
   llvm_unreachable("unknown unary transform type");
 }
 
 QualType Sema::BuildAtomicType(QualType T, SourceLocation Loc) {
   if (!T->isDependentType()) {
     // FIXME: It isn't entirely clear whether incomplete atomic types
     // are allowed or not; for simplicity, ban them for the moment.
     if (RequireCompleteType(Loc, T, diag::err_atomic_specifier_bad_type, 0))
       return QualType();
 
     int DisallowedKind = -1;
     if (T->isArrayType())
       DisallowedKind = 1;
     else if (T->isFunctionType())
       DisallowedKind = 2;
     else if (T->isReferenceType())
       DisallowedKind = 3;
     else if (T->isAtomicType())
       DisallowedKind = 4;
     else if (T.hasQualifiers())
       DisallowedKind = 5;
     else if (T->isSizelessType())
       DisallowedKind = 6;

clang/test/SemaCXX/type-traits.cpp

 // RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only -verify -std=gnu++11 -fms-extensions -Wno-microsoft %s
 // RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only -verify -std=gnu++14 -fms-extensions -Wno-microsoft %s
 // RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only -verify -std=gnu++1z -fms-extensions -Wno-microsoft %s
 
 #define T(b) (b) ? 1 : -1
 #define F(b) (b) ? -1 : 1
 
 struct NonPOD { NonPOD(int); };
 typedef NonPOD NonPODAr[10];
 typedef NonPOD NonPODArNB[];
 typedef NonPOD NonPODArMB[10][2];
 
 // PODs
 enum Enum { EV };
 enum SignedEnum : signed int { };
 enum UnsignedEnum : unsigned int { };
+enum class EnumClass { EV };
+enum class SignedEnumClass : signed int { };
+enum class UnsignedEnumClass : unsigned int { };
 struct POD { Enum e; int i; float f; NonPOD* p; };
 struct Empty {};
 struct IncompleteStruct;
 typedef Empty EmptyAr[10];
 typedef Empty EmptyArNB[];
 typedef Empty EmptyArMB[1][2];
 typedef int Int;
 typedef Int IntAr[10];

 #undef T16
 #undef T64
 #undef T256
 #undef T1024
 #undef T4096
 #undef T16384
 #undef T32768
 } // namespace type_trait_expr_numargs_overflow
+
+template<class T> using add_const_t = __add_const(T);
+
+struct S {};
+void check_add_const() {
+  { int a[T(__is_same(add_const_t<void>, const void))]; }
+  { int a[T(__is_same(add_const_t<int>, const int))]; }
+  { int a[T(__is_same(add_const_t<const int>, const int))]; }
+  { int a[T(__is_same(add_const_t<volatile int>, const volatile int))]; }
+  { int a[T(__is_same(add_const_t<const volatile int>, const volatile int))]; }
+  { int a[T(__is_same(add_const_t<int*>, int* const))]; }
+  { int a[T(__is_same(add_const_t<int&>, int&))]; }
+  { int a[T(__is_same(add_const_t<int&&>, int&&))]; }
+  { int a[T(__is_same(add_const_t<int()>, int()))]; }
+  { int a[T(__is_same(add_const_t<int(*)()>, int(* const)()))]; }
+  { int a[T(__is_same(add_const_t<int(&)()>, int(&)()))]; }
+
+  { int a[T(__is_same(add_const_t<S>, const S))]; }
+  { int a[T(__is_same(add_const_t<const S>, const S))]; }
+  { int a[T(__is_same(add_const_t<volatile S>, const volatile S))]; }
+  { int a[T(__is_same(add_const_t<const volatile S>, const volatile S))]; }
+  { int a[T(__is_same(add_const_t<int S::*>, int S::* const))]; }
+  { int a[T(__is_same(add_const_t<int (S::*)()>, int (S::* const)()))]; }
+  { int a[T(__is_same(add_const_t<int (S::*)() &>, int (S::* const)() &))]; }
+  { int a[T(__is_same(add_const_t<int (S::*)() &&>, int (S::* const)() &&))]; }
+  { int a[T(__is_same(add_const_t<int (S::*)() const>, int (S::* const)() const))]; }
+  { int a[T(__is_same(add_const_t<int (S::*)() const&>, int (S::* const)() const&))]; }
+  { int a[T(__is_same(add_const_t<int (S::*)() const&&>, int (S::* const)() const&&))]; }
+  { int a[T(__is_same(add_const_t<int (S::*)() volatile>, int (S::* const)() volatile))]; }
+  { int a[T(__is_same(add_const_t<int (S::*)() volatile&>, int (S::* const)() volatile&))]; }
+  { int a[T(__is_same(add_const_t<int (S::*)() volatile&&>, int (S::* const)() volatile&&))]; }
+  { int a[T(__is_same(add_const_t<int (S::*)() const volatile>, int (S::* const)() const volatile))]; }
+  { int a[T(__is_same(add_const_t<int (S::*)() const volatile&>, int (S::* const)() const volatile&))]; }
+  { int a[T(__is_same(add_const_t<int (S::*)() const volatile&&>, int (S::* const)() const volatile&&))]; }
+}
+
+template<class T> using remove_const_t = __remove_const(T);
+
+void check_remove_const() {
+  { int a[T(__is_same(remove_const_t<void>, void))]; }
+  { int a[T(__is_same(remove_const_t<const void>, void))]; }
+  { int a[T(__is_same(remove_const_t<int>, int))]; }
+  { int a[T(__is_same(remove_const_t<const int>, int))]; }
+  { int a[T(__is_same(remove_const_t<volatile int>, volatile int))]; }
+  { int a[T(__is_same(remove_const_t<const volatile int>, volatile int))]; }
+  { int a[T(__is_same(remove_const_t<int*>, int*))]; }
+  { int a[T(__is_same(remove_const_t<int* const>, int*))]; }
+  { int a[T(__is_same(remove_const_t<int const* const>, int const*))]; }
+  { int a[T(__is_same(remove_const_t<int&>, int&))]; }
+  { int a[T(__is_same(remove_const_t<int const&>, int const&))]; }
+  { int a[T(__is_same(remove_const_t<int&&>, int&&))]; }
+  { int a[T(__is_same(remove_const_t<int const&&>, int const&&))]; }
+  { int a[T(__is_same(remove_const_t<int()>, int()))]; }
+  { int a[T(__is_same(remove_const_t<int(* const)()>, int(*)()))]; }
+  { int a[T(__is_same(remove_const_t<int(&)()>, int(&)()))]; }
+
+  { int a[T(__is_same(remove_const_t<S>, S))]; }
+  { int a[T(__is_same(remove_const_t<const S>,  S))]; }
+  { int a[T(__is_same(remove_const_t<volatile S>, volatile S))]; }
+  { int a[T(__is_same(remove_const_t<const volatile S>, volatile S))]; }
+  { int a[T(__is_same(remove_const_t<int S::* const>, int S::*))]; }
+  { int a[T(__is_same(remove_const_t<int (S::* const)()>, int (S::*)()))]; }
+  { int a[T(__is_same(remove_const_t<int (S::* const)() &>, int (S::*)() &))]; }
+  { int a[T(__is_same(remove_const_t<int (S::* const)() &&>, int (S::*)() &&))]; }
+  { int a[T(__is_same(remove_const_t<int (S::* const)() const>, int (S::*)() const))]; }
+  { int a[T(__is_same(remove_const_t<int (S::* const)() const&>, int (S::*)() const&))]; }
+  { int a[T(__is_same(remove_const_t<int (S::* const)() const&&>, int (S::*)() const&&))]; }
+  { int a[T(__is_same(remove_const_t<int (S::* const)() volatile>, int (S::*)() volatile))]; }
+  { int a[T(__is_same(remove_const_t<int (S::* const)() volatile&>, int (S::*)() volatile&))]; }
+  { int a[T(__is_same(remove_const_t<int (S::* const)() volatile&&>, int (S::*)() volatile&&))]; }
+  { int a[T(__is_same(remove_const_t<int (S::* const)() const volatile>, int (S::*)() const volatile))]; }
+  { int a[T(__is_same(remove_const_t<int (S::* const)() const volatile&>, int (S::*)() const volatile&))]; }
+  { int a[T(__is_same(remove_const_t<int (S::* const)() const volatile&&>, int (S::*)() const volatile&&))]; }
+}
+
+template<class T> using add_volatile_t = __add_volatile(T);
+
+void check_add_volatile() {
+  { int a[T(__is_same(add_volatile_t<void>, volatile void))]; }
+  { int a[T(__is_same(add_volatile_t<int>, volatile int))]; }
+  { int a[T(__is_same(add_volatile_t<const int>, const volatile int))]; }
+  { int a[T(__is_same(add_volatile_t<volatile int>, volatile int))]; }
+  { int a[T(__is_same(add_volatile_t<const volatile int>, const volatile int))]; }
+  { int a[T(__is_same(add_volatile_t<int*>, int* volatile))]; }
+  { int a[T(__is_same(add_volatile_t<int&>, int&))]; }
+  { int a[T(__is_same(add_volatile_t<int&&>, int&&))]; }
+  { int a[T(__is_same(add_volatile_t<int()>, int()))]; }
+  { int a[T(__is_same(add_volatile_t<int(*)()>, int(* volatile)()))]; }
+  { int a[T(__is_same(add_volatile_t<int(&)()>, int(&)()))]; }
+
+  { int a[T(__is_same(add_volatile_t<S>, volatile S))]; }
+  { int a[T(__is_same(add_volatile_t<const S>, const volatile S))]; }
+  { int a[T(__is_same(add_volatile_t<volatile S>, volatile S))]; }
+  { int a[T(__is_same(add_volatile_t<const volatile S>, const volatile S))]; }
+  { int a[T(__is_same(add_volatile_t<int S::*>, int S::* volatile))]; }
+  { int a[T(__is_same(add_volatile_t<int (S::*)()>, int (S::* volatile)()))]; }
+  { int a[T(__is_same(add_volatile_t<int (S::*)() &>, int (S::* volatile)() &))]; }
+  { int a[T(__is_same(add_volatile_t<int (S::*)() &&>, int (S::* volatile)() &&))]; }
+  { int a[T(__is_same(add_volatile_t<int (S::*)() const>, int (S::* volatile)() const))]; }
+  { int a[T(__is_same(add_volatile_t<int (S::*)() const&>, int (S::* volatile)() const&))]; }
+  { int a[T(__is_same(add_volatile_t<int (S::*)() const&&>, int (S::* volatile)() const&&))]; }
+  { int a[T(__is_same(add_volatile_t<int (S::*)() volatile>, int (S::* volatile)() volatile))]; }
+  { int a[T(__is_same(add_volatile_t<int (S::*)() volatile&>, int (S::* volatile)() volatile&))]; }
+  { int a[T(__is_same(add_volatile_t<int (S::*)() volatile&&>, int (S::* volatile)() volatile&&))]; }
+  { int a[T(__is_same(add_volatile_t<int (S::*)() const volatile>, int (S::* volatile)() const volatile))]; }
+  { int a[T(__is_same(add_volatile_t<int (S::*)() const volatile&>, int (S::* volatile)() const volatile&))]; }
+  { int a[T(__is_same(add_volatile_t<int (S::*)() const volatile&&>, int (S::* volatile)() const volatile&&))]; }
+}
+
+template<class T> using remove_volatile_t = __remove_volatile(T);
+
+void check_remove_volatile() {
+  { int a[T(__is_same(remove_volatile_t<void>, void))]; }
+  { int a[T(__is_same(remove_volatile_t<volatile void>, void))]; }
+  { int a[T(__is_same(remove_volatile_t<int>, int))]; }
+  { int a[T(__is_same(remove_volatile_t<const int>, const int))]; }
+  { int a[T(__is_same(remove_volatile_t<volatile int>, int))]; }
+  { int a[T(__is_same(remove_volatile_t<const volatile int>, const int))]; }
+  { int a[T(__is_same(remove_volatile_t<int*>, int*))]; }
+  { int a[T(__is_same(remove_volatile_t<int* volatile>, int*))]; }
+  { int a[T(__is_same(remove_volatile_t<int volatile* volatile>, int volatile*))]; }
+  { int a[T(__is_same(remove_volatile_t<int&>, int&))]; }
+  { int a[T(__is_same(remove_volatile_t<int volatile&>, int volatile&))]; }
+  { int a[T(__is_same(remove_volatile_t<int&&>, int&&))]; }
+  { int a[T(__is_same(remove_volatile_t<int volatile&&>, int volatile&&))]; }
+  { int a[T(__is_same(remove_volatile_t<int()>, int()))]; }
+  { int a[T(__is_same(remove_volatile_t<int(* volatile)()>, int(*)()))]; }
+  { int a[T(__is_same(remove_volatile_t<int(&)()>, int(&)()))]; }
+
+  { int a[T(__is_same(remove_volatile_t<S>, S))]; }
+  { int a[T(__is_same(remove_volatile_t<const S>, const  S))]; }
+  { int a[T(__is_same(remove_volatile_t<volatile S>, S))]; }
+  { int a[T(__is_same(remove_volatile_t<const volatile S>, const S))]; }
+  { int a[T(__is_same(remove_volatile_t<int S::* volatile>, int S::*))]; }
+  { int a[T(__is_same(remove_volatile_t<int (S::* volatile)()>, int (S::*)()))]; }
+  { int a[T(__is_same(remove_volatile_t<int (S::* volatile)() &>, int (S::*)() &))]; }
+  { int a[T(__is_same(remove_volatile_t<int (S::* volatile)() &&>, int (S::*)() &&))]; }
+  { int a[T(__is_same(remove_volatile_t<int (S::* volatile)() const>, int (S::*)() const))]; }
+  { int a[T(__is_same(remove_volatile_t<int (S::* volatile)() const&>, int (S::*)() const&))]; }
+  { int a[T(__is_same(remove_volatile_t<int (S::* volatile)() const&&>, int (S::*)() const&&))]; }
+  { int a[T(__is_same(remove_volatile_t<int (S::* volatile)() volatile>, int (S::*)() volatile))]; }
+  { int a[T(__is_same(remove_volatile_t<int (S::* volatile)() volatile&>, int (S::*)() volatile&))]; }
+  { int a[T(__is_same(remove_volatile_t<int (S::* volatile)() volatile&&>, int (S::*)() volatile&&))]; }
+  { int a[T(__is_same(remove_volatile_t<int (S::* volatile)() const volatile>, int (S::*)() const volatile))]; }
+  { int a[T(__is_same(remove_volatile_t<int (S::* volatile)() const volatile&>, int (S::*)() const volatile&))]; }
+  { int a[T(__is_same(remove_volatile_t<int (S::* volatile)() const volatile&&>, int (S::*)() const volatile&&))]; }
+}
+
+template<class T> using add_cv_t = __add_cv(T);
+
+void check_add_cv() {
+  { int a[T(__is_same(add_cv_t<void>, const volatile void))]; }
+  { int a[T(__is_same(add_cv_t<int>, const volatile int))]; }
+  { int a[T(__is_same(add_cv_t<const int>, const volatile int))]; }
+  { int a[T(__is_same(add_cv_t<volatile int>, const volatile int))]; }
+  { int a[T(__is_same(add_cv_t<const volatile int>, const volatile int))]; }
+  { int a[T(__is_same(add_cv_t<int*>, int* const volatile))]; }
+  { int a[T(__is_same(add_cv_t<int&>, int&))]; }
+  { int a[T(__is_same(add_cv_t<int&&>, int&&))]; }
+  { int a[T(__is_same(add_cv_t<int()>, int()))]; }
+  { int a[T(__is_same(add_cv_t<int(*)()>, int(* const volatile)()))]; }
+  { int a[T(__is_same(add_cv_t<int(&)()>, int(&)()))]; }
+
+  { int a[T(__is_same(add_cv_t<S>, const volatile S))]; }
+  { int a[T(__is_same(add_cv_t<const S>, const volatile S))]; }
+  { int a[T(__is_same(add_cv_t<volatile S>, const volatile S))]; }
+  { int a[T(__is_same(add_cv_t<const volatile S>, const volatile S))]; }
+  { int a[T(__is_same(add_cv_t<int S::*>, int S::* const volatile))]; }
+  { int a[T(__is_same(add_cv_t<int (S::*)()>, int (S::* const volatile)()))]; }
+  { int a[T(__is_same(add_cv_t<int (S::*)() &>, int (S::* const volatile)() &))]; }
+  { int a[T(__is_same(add_cv_t<int (S::*)() &&>, int (S::* const volatile)() &&))]; }
+  { int a[T(__is_same(add_cv_t<int (S::*)() const>, int (S::* const volatile)() const))]; }
+  { int a[T(__is_same(add_cv_t<int (S::*)() const&>, int (S::* const volatile)() const&))]; }
+  { int a[T(__is_same(add_cv_t<int (S::*)() const&&>, int (S::* const volatile)() const&&))]; }
+  { int a[T(__is_same(add_cv_t<int (S::*)() volatile>, int (S::* const volatile)() volatile))]; }
+  { int a[T(__is_same(add_cv_t<int (S::*)() volatile&>, int (S::* const volatile)() volatile&))]; }
+  { int a[T(__is_same(add_cv_t<int (S::*)() volatile&&>, int (S::* const volatile)() volatile&&))]; }
+  { int a[T(__is_same(add_cv_t<int (S::*)() const volatile>, int (S::* const volatile)() const volatile))]; }
+  { int a[T(__is_same(add_cv_t<int (S::*)() const volatile&>, int (S::* const volatile)() const volatile&))]; }
+  { int a[T(__is_same(add_cv_t<int (S::*)() const volatile&&>, int (S::* const volatile)() const volatile&&))]; }
+}
+
+template<class T> using remove_cv_t = __remove_cv(T);
+
+void check_remove_cv() {
+  { int a[T(__is_same(remove_cv_t<void>, void))]; }
+  { int a[T(__is_same(remove_cv_t<const volatile void>, void))]; }
+  { int a[T(__is_same(remove_cv_t<int>, int))]; }
+  { int a[T(__is_same(remove_cv_t<const int>, int))]; }
+  { int a[T(__is_same(remove_cv_t<volatile int>, int))]; }
+  { int a[T(__is_same(remove_cv_t<const volatile int>, int))]; }
+  { int a[T(__is_same(remove_cv_t<int*>, int*))]; }
+  { int a[T(__is_same(remove_cv_t<int* const volatile>, int*))]; }
+  { int a[T(__is_same(remove_cv_t<int const* const volatile>, int const*))]; }
+  { int a[T(__is_same(remove_cv_t<int&>, int&))]; }
+  { int a[T(__is_same(remove_cv_t<int const volatile&>, int const volatile&))]; }
+  { int a[T(__is_same(remove_cv_t<int&&>, int&&))]; }
+  { int a[T(__is_same(remove_cv_t<int const volatile&&>, int const volatile&&))]; }
+  { int a[T(__is_same(remove_cv_t<int()>, int()))]; }
+  { int a[T(__is_same(remove_cv_t<int(* const volatile)()>, int(*)()))]; }
+  { int a[T(__is_same(remove_cv_t<int(&)()>, int(&)()))]; }
+
+  { int a[T(__is_same(remove_cv_t<S>, S))]; }
+  { int a[T(__is_same(remove_cv_t<const S>, S))]; }
+  { int a[T(__is_same(remove_cv_t<volatile S>, S))]; }
+  { int a[T(__is_same(remove_cv_t<const volatile S>, S))]; }
+  { int a[T(__is_same(remove_cv_t<int S::* const volatile>, int S::*))]; }
+  { int a[T(__is_same(remove_cv_t<int (S::* const volatile)()>, int (S::*)()))]; }
+  { int a[T(__is_same(remove_cv_t<int (S::* const volatile)() &>, int (S::*)() &))]; }
+  { int a[T(__is_same(remove_cv_t<int (S::* const volatile)() &&>, int (S::*)() &&))]; }
+  { int a[T(__is_same(remove_cv_t<int (S::* const volatile)() const>, int (S::*)() const))]; }
+  { int a[T(__is_same(remove_cv_t<int (S::* const volatile)() const&>, int (S::*)() const&))]; }
+  { int a[T(__is_same(remove_cv_t<int (S::* const volatile)() const&&>, int (S::*)() const&&))]; }
+  { int a[T(__is_same(remove_cv_t<int (S::* const volatile)() volatile>, int (S::*)() volatile))]; }
+  { int a[T(__is_same(remove_cv_t<int (S::* const volatile)() volatile&>, int (S::*)() volatile&))]; }
+  { int a[T(__is_same(remove_cv_t<int (S::* const volatile)() volatile&&>, int (S::*)() volatile&&))]; }
+  { int a[T(__is_same(remove_cv_t<int (S::* const volatile)() const volatile>, int (S::*)() const volatile))]; }
+  { int a[T(__is_same(remove_cv_t<int (S::* const volatile)() const volatile&>, int (S::*)() const volatile&))]; }
+  { int a[T(__is_same(remove_cv_t<int (S::* const volatile)() const volatile&&>, int (S::*)() const volatile&&))]; }
+}
+
+template<class T> using add_pointer_t = __add_pointer(T);
+
+void add_pointer() {
+  { int a[T(__is_same(add_pointer_t<void>, void*))]; }
+  { int a[T(__is_same(add_pointer_t<const void>, const void*))]; }
+  { int a[T(__is_same(add_pointer_t<volatile void>, volatile void*))]; }
+  { int a[T(__is_same(add_pointer_t<const volatile void>, const volatile void*))]; }
+  { int a[T(__is_same(add_pointer_t<int>, int*))]; }
+  { int a[T(__is_same(add_pointer_t<const int>, const int*))]; }
+  { int a[T(__is_same(add_pointer_t<volatile int>, volatile int*))]; }
+  { int a[T(__is_same(add_pointer_t<const volatile int>, const volatile int*))]; }
+  { int a[T(__is_same(add_pointer_t<int*>, int**))]; }
+  { int a[T(__is_same(add_pointer_t<int&>, int*))]; }
+  { int a[T(__is_same(add_pointer_t<int&&>, int*))]; }
+  { int a[T(__is_same(add_pointer_t<int()>, int(*)()))]; }
+  { int a[T(__is_same(add_pointer_t<int(*)()>, int(**)()))]; }
+  { int a[T(__is_same(add_pointer_t<int(&)()>, int(*)()))]; }
+
+  { int a[T(__is_same(add_pointer_t<S>, S*))]; }
+  { int a[T(__is_same(add_pointer_t<const S>, const S*))]; }
+  { int a[T(__is_same(add_pointer_t<volatile S>, volatile S*))]; }
+  { int a[T(__is_same(add_pointer_t<const volatile S>, const volatile S*))]; }
+  { int a[T(__is_same(add_pointer_t<int S::*>, int S::**))]; }
+  { int a[T(__is_same(add_pointer_t<int (S::*)()>, int (S::**)()))]; }
+  { int a[T(__is_same(add_pointer_t<int (S::*)() &>, int (S::**)() &))]; }
+  { int a[T(__is_same(add_pointer_t<int (S::*)() &&>, int (S::**)() &&))]; }
+  { int a[T(__is_same(add_pointer_t<int (S::*)() const>, int (S::**)() const))]; }
+  { int a[T(__is_same(add_pointer_t<int (S::*)() const&>, int (S::**)() const&))]; }
+  { int a[T(__is_same(add_pointer_t<int (S::*)() const&&>, int (S::**)() const&&))]; }
+  { int a[T(__is_same(add_pointer_t<int (S::*)() volatile>, int (S::**)() volatile))]; }
+  { int a[T(__is_same(add_pointer_t<int (S::*)() volatile&>, int (S::**)() volatile&))]; }
+  { int a[T(__is_same(add_pointer_t<int (S::*)() volatile&&>, int (S::**)() volatile&&))]; }
+  { int a[T(__is_same(add_pointer_t<int (S::*)() const volatile>, int (S::**)() const volatile))]; }
+  { int a[T(__is_same(add_pointer_t<int (S::*)() const volatile&>, int (S::**)() const volatile&))]; }
+  { int a[T(__is_same(add_pointer_t<int (S::*)() const volatile&&>, int (S::**)() const volatile&&))]; }
+}
+
+template<class T> using remove_pointer_t = __remove_pointer(T);
+
+void remove_pointer() {
+  { int a[T(__is_same(remove_pointer_t<void>, void))]; }
+  { int a[T(__is_same(remove_pointer_t<const void>, const void))]; }
+  { int a[T(__is_same(remove_pointer_t<volatile void>, volatile void))]; }
+  { int a[T(__is_same(remove_pointer_t<const volatile void>, const volatile void))]; }
+  { int a[T(__is_same(remove_pointer_t<int>, int))]; }
+  { int a[T(__is_same(remove_pointer_t<const int>, const int))]; }
+  { int a[T(__is_same(remove_pointer_t<volatile int>, volatile int))]; }
+  { int a[T(__is_same(remove_pointer_t<const volatile int>, const volatile int))]; }
+  { int a[T(__is_same(remove_pointer_t<int*>, int))]; }
+  { int a[T(__is_same(remove_pointer_t<int&>, int&))]; }
+  { int a[T(__is_same(remove_pointer_t<int&&>, int&&))]; }
+  { int a[T(__is_same(remove_pointer_t<int()>, int()))]; }
+  { int a[T(__is_same(remove_pointer_t<int(*)()>, int()))]; }
+  { int a[T(__is_same(remove_pointer_t<int(&)()>, int(&)()))]; }
+
+  { int a[T(__is_same(remove_pointer_t<S>, S))]; }
+  { int a[T(__is_same(remove_pointer_t<const S>, const S))]; }
+  { int a[T(__is_same(remove_pointer_t<volatile S>, volatile S))]; }
+  { int a[T(__is_same(remove_pointer_t<const volatile S>, const volatile S))]; }
+  { int a[T(__is_same(remove_pointer_t<int S::*>, int S::*))]; }
+  { int a[T(__is_same(remove_pointer_t<int (S::*)()>, int (S::*)()))]; }
+  { int a[T(__is_same(remove_pointer_t<int (S::*)() &>, int (S::*)() &))]; }
+  { int a[T(__is_same(remove_pointer_t<int (S::*)() &&>, int (S::*)() &&))]; }
+  { int a[T(__is_same(remove_pointer_t<int (S::*)() const>, int (S::*)() const))]; }
+  { int a[T(__is_same(remove_pointer_t<int (S::*)() const&>, int (S::*)() const&))]; }
+  { int a[T(__is_same(remove_pointer_t<int (S::*)() const&&>, int (S::*)() const&&))]; }
+  { int a[T(__is_same(remove_pointer_t<int (S::*)() volatile>, int (S::*)() volatile))]; }
+  { int a[T(__is_same(remove_pointer_t<int (S::*)() volatile&>, int (S::*)() volatile&))]; }
+  { int a[T(__is_same(remove_pointer_t<int (S::*)() volatile&&>, int (S::*)() volatile&&))]; }
+  { int a[T(__is_same(remove_pointer_t<int (S::*)() const volatile>, int (S::*)() const volatile))]; }
+  { int a[T(__is_same(remove_pointer_t<int (S::*)() const volatile&>, int (S::*)() const volatile&))]; }
+  { int a[T(__is_same(remove_pointer_t<int (S::*)() const volatile&&>, int (S::*)() const volatile&&))]; }
+}
+
+template<class T> using add_lvalue_reference_t = __add_lvalue_reference(T);
+
+void add_lvalue_reference() {
+  { int a[T(__is_same(add_lvalue_reference_t<void>, void))]; }
+  { int a[T(__is_same(add_lvalue_reference_t<const void>, const void))]; }
+  { int a[T(__is_same(add_lvalue_reference_t<volatile void>, volatile void))]; }
+  { int a[T(__is_same(add_lvalue_reference_t<const volatile void>, const volatile void))]; }
+  { int a[T(__is_same(add_lvalue_reference_t<int>, int&))]; }
+  { int a[T(__is_same(add_lvalue_reference_t<const int>, const int&))]; }
+  { int a[T(__is_same(add_lvalue_reference_t<volatile int>, volatile int&))]; }
+  { int a[T(__is_same(add_lvalue_reference_t<const volatile int>, const volatile int&))]; }
+  { int a[T(__is_same(add_lvalue_reference_t<int*>, int*&))]; }
+  { int a[T(__is_same(add_lvalue_reference_t<int&>, int&))]; }
+  { int a[T(__is_same(add_lvalue_reference_t<int&&>, int&))]; } // reference collapsing
+  { int a[T(__is_same(add_lvalue_reference_t<int()>, int(&)()))]; }
+  { int a[T(__is_same(add_lvalue_reference_t<int(*)()>, int(*&)()))]; }
+  { int a[T(__is_same(add_lvalue_reference_t<int(&)()>, int(&)()))]; }
+
+  { int a[T(__is_same(add_lvalue_reference_t<S>, S&))]; }
+  { int a[T(__is_same(add_lvalue_reference_t<const S>, const S&))]; }
+  { int a[T(__is_same(add_lvalue_reference_t<volatile S>, volatile S&))]; }
+  { int a[T(__is_same(add_lvalue_reference_t<const volatile S>, const volatile S&))]; }
+  { int a[T(__is_same(add_lvalue_reference_t<int S::*>, int S::*&))]; }
+  { int a[T(__is_same(add_lvalue_reference_t<int (S::*)()>, int (S::*&)()))]; }
+  { int a[T(__is_same(add_lvalue_reference_t<int (S::*)() &>, int (S::*&)() &))]; }
+  { int a[T(__is_same(add_lvalue_reference_t<int (S::*)() &&>, int (S::*&)() &&))]; }
+  { int a[T(__is_same(add_lvalue_reference_t<int (S::*)() const>, int (S::*&)() const))]; }
+  { int a[T(__is_same(add_lvalue_reference_t<int (S::*)() const&>, int (S::*&)() const&))]; }
+  { int a[T(__is_same(add_lvalue_reference_t<int (S::*)() const&&>, int (S::*&)() const&&))]; }
+  { int a[T(__is_same(add_lvalue_reference_t<int (S::*)() volatile>, int (S::*&)() volatile))]; }
+  { int a[T(__is_same(add_lvalue_reference_t<int (S::*)() volatile&>, int (S::*&)() volatile&))]; }
+  { int a[T(__is_same(add_lvalue_reference_t<int (S::*)() volatile&&>, int (S::*&)() volatile&&))]; }
+  { int a[T(__is_same(add_lvalue_reference_t<int (S::*)() const volatile>, int (S::*&)() const volatile))]; }
+  { int a[T(__is_same(add_lvalue_reference_t<int (S::*)() const volatile&>, int (S::*&)() const volatile&))]; }
+  { int a[T(__is_same(add_lvalue_reference_t<int (S::*)() const volatile&&>, int (S::*&)() const volatile&&))]; }
+}
+
+template<class T> using add_rvalue_reference_t = __add_rvalue_reference(T);
+
+void add_rvalue_reference() {
+  { int a[T(__is_same(add_rvalue_reference_t<void>, void))]; }
+  { int a[T(__is_same(add_rvalue_reference_t<const void>, const void))]; }
+  { int a[T(__is_same(add_rvalue_reference_t<volatile void>, volatile void))]; }
+  { int a[T(__is_same(add_rvalue_reference_t<const volatile void>, const volatile void))]; }
+  { int a[T(__is_same(add_rvalue_reference_t<int>, int&&))]; }
+  { int a[T(__is_same(add_rvalue_reference_t<const int>, const int&&))]; }
+  { int a[T(__is_same(add_rvalue_reference_t<volatile int>, volatile int&&))]; }
+  { int a[T(__is_same(add_rvalue_reference_t<const volatile int>, const volatile int&&))]; }
+  { int a[T(__is_same(add_rvalue_reference_t<int*>, int*&&))]; }
+  { int a[T(__is_same(add_rvalue_reference_t<int&>, int&))]; } // reference collapsing
+  { int a[T(__is_same(add_rvalue_reference_t<int&&>, int&&))]; }
+  { int a[T(__is_same(add_rvalue_reference_t<int()>, int(&&)()))]; }
+  { int a[T(__is_same(add_rvalue_reference_t<int(*)()>, int(*&&)()))]; }
+  { int a[T(__is_same(add_rvalue_reference_t<int(&)()>, int(&)()))]; } // reference collapsing
+
+  { int a[T(__is_same(add_rvalue_reference_t<S>, S&&))]; }
+  { int a[T(__is_same(add_rvalue_reference_t<const S>, const S&&))]; }
+  { int a[T(__is_same(add_rvalue_reference_t<volatile S>, volatile S&&))]; }
+  { int a[T(__is_same(add_rvalue_reference_t<const volatile S>, const volatile S&&))]; }
+  { int a[T(__is_same(add_rvalue_reference_t<int S::*>, int S::*&&))]; }
+  { int a[T(__is_same(add_rvalue_reference_t<int (S::*)()>, int (S::*&&)()))]; }
+  { int a[T(__is_same(add_rvalue_reference_t<int (S::*)() &>, int (S::*&&)() &))]; }
+  { int a[T(__is_same(add_rvalue_reference_t<int (S::*)() &&>, int (S::*&&)() &&))]; }
+  { int a[T(__is_same(add_rvalue_reference_t<int (S::*)() const>, int (S::*&&)() const))]; }
+  { int a[T(__is_same(add_rvalue_reference_t<int (S::*)() const&>, int (S::*&&)() const&))]; }
+  { int a[T(__is_same(add_rvalue_reference_t<int (S::*)() const&&>, int (S::*&&)() const&&))]; }
+  { int a[T(__is_same(add_rvalue_reference_t<int (S::*)() volatile>, int (S::*&&)() volatile))]; }
+  { int a[T(__is_same(add_rvalue_reference_t<int (S::*)() volatile&>, int (S::*&&)() volatile&))]; }
+  { int a[T(__is_same(add_rvalue_reference_t<int (S::*)() volatile&&>, int (S::*&&)() volatile&&))]; }
+  { int a[T(__is_same(add_rvalue_reference_t<int (S::*)() const volatile>, int (S::*&&)() const volatile))]; }
+  { int a[T(__is_same(add_rvalue_reference_t<int (S::*)() const volatile&>, int (S::*&&)() const volatile&))]; }
+  { int a[T(__is_same(add_rvalue_reference_t<int (S::*)() const volatile&&>, int (S::*&&)() const volatile&&))]; }
+}
+
+template<class T> using remove_reference_t = __remove_reference(T);
+
+void check_remove_reference() {
+  { int a[T(__is_same(remove_reference_t<void>, void))]; }
+  { int a[T(__is_same(remove_reference_t<const volatile void>, const volatile void))]; }
+  { int a[T(__is_same(remove_reference_t<int>, int))]; }
+  { int a[T(__is_same(remove_reference_t<const int>, const int))]; }
+  { int a[T(__is_same(remove_reference_t<volatile int>, volatile int))]; }
+  { int a[T(__is_same(remove_reference_t<const volatile int>, const volatile int))]; }
+  { int a[T(__is_same(remove_reference_t<int*>, int*))]; }
+  { int a[T(__is_same(remove_reference_t<int* const volatile>, int* const volatile))]; }
+  { int a[T(__is_same(remove_reference_t<int const* const volatile>, int const* const volatile))]; }
+  { int a[T(__is_same(remove_reference_t<int&>, int))]; }
+  { int a[T(__is_same(remove_reference_t<int const volatile&>, int const volatile))]; }
+  { int a[T(__is_same(remove_reference_t<int&&>, int))]; }
+  { int a[T(__is_same(remove_reference_t<int const volatile&&>, int const volatile))]; }
+  { int a[T(__is_same(remove_reference_t<int()>, int()))]; }
+  { int a[T(__is_same(remove_reference_t<int(* const volatile)()>, int(* const volatile)()))]; }
+  { int a[T(__is_same(remove_reference_t<int(&)()>, int()))]; }
+
+  { int a[T(__is_same(remove_reference_t<S>, S))]; }
+  { int a[T(__is_same(remove_reference_t<S&>, S))]; }
+  { int a[T(__is_same(remove_reference_t<S&&>, S))]; }
+  { int a[T(__is_same(remove_reference_t<const S>, const S))]; }
+  { int a[T(__is_same(remove_reference_t<const S&>, const S))]; }
+  { int a[T(__is_same(remove_reference_t<const S&&>, const S))]; }
+  { int a[T(__is_same(remove_reference_t<volatile S>, volatile S))]; }
+  { int a[T(__is_same(remove_reference_t<volatile S&>, volatile S))]; }
+  { int a[T(__is_same(remove_reference_t<volatile S&&>, volatile S))]; }
+  { int a[T(__is_same(remove_reference_t<const volatile S>, const volatile S))]; }
+  { int a[T(__is_same(remove_reference_t<const volatile S&>, const volatile S))]; }
+  { int a[T(__is_same(remove_reference_t<const volatile S&&>, const volatile S))]; }
+  { int a[T(__is_same(remove_reference_t<int S::* const volatile&>, int S::* const volatile))]; }
+  { int a[T(__is_same(remove_reference_t<int (S::* const volatile&)()>, int (S::* const volatile)()))]; }
+  { int a[T(__is_same(remove_reference_t<int (S::* const volatile&)() &>, int (S::* const volatile)() &))]; }
+  { int a[T(__is_same(remove_reference_t<int (S::* const volatile&)() &&>, int (S::* const volatile)() &&))]; }
+  { int a[T(__is_same(remove_reference_t<int (S::* const volatile&)() const>, int (S::* const volatile)() const))]; }
+  { int a[T(__is_same(remove_reference_t<int (S::* const volatile&)() const&>, int (S::* const volatile)() const&))]; }
+  { int a[T(__is_same(remove_reference_t<int (S::* const volatile&)() const&&>, int (S::* const volatile)() const&&))]; }
+  { int a[T(__is_same(remove_reference_t<int (S::* const volatile&)() volatile>, int (S::* const volatile)() volatile))]; }
+  { int a[T(__is_same(remove_reference_t<int (S::* const volatile&)() volatile&>, int (S::* const volatile)() volatile&))]; }
+  { int a[T(__is_same(remove_reference_t<int (S::* const volatile&)() volatile&&>, int (S::* const volatile)() volatile&&))]; }
+  { int a[T(__is_same(remove_reference_t<int (S::* const volatile&)() const volatile>, int (S::* const volatile)() const volatile))]; }
+  { int a[T(__is_same(remove_reference_t<int (S::* const volatile&)() const volatile&>, int (S::* const volatile)() const volatile&))]; }
+  { int a[T(__is_same(remove_reference_t<int (S::* const volatile&)() const volatile&&>, int (S::* const volatile)() const volatile&&))]; }
+  { int a[T(__is_same(remove_reference_t<int (S::* const volatile&)()>, int (S::* const volatile)()))]; }
+  { int a[T(__is_same(remove_reference_t<int (S::* const volatile&&)() &>, int (S::* const volatile)() &))]; }
+  { int a[T(__is_same(remove_reference_t<int (S::* const volatile&&)() &&>, int (S::* const volatile)() &&))]; }
+  { int a[T(__is_same(remove_reference_t<int (S::* const volatile&&)() const>, int (S::* const volatile)() const))]; }
+  { int a[T(__is_same(remove_reference_t<int (S::* const volatile&&)() const&>, int (S::* const volatile)() const&))]; }
+  { int a[T(__is_same(remove_reference_t<int (S::* const volatile&&)() const&&>, int (S::* const volatile)() const&&))]; }
+  { int a[T(__is_same(remove_reference_t<int (S::* const volatile&&)() volatile>, int (S::* const volatile)() volatile))]; }
+  { int a[T(__is_same(remove_reference_t<int (S::* const volatile&&)() volatile&>, int (S::* const volatile)() volatile&))]; }
+  { int a[T(__is_same(remove_reference_t<int (S::* const volatile&&)() volatile&&>, int (S::* const volatile)() volatile&&))]; }
+  { int a[T(__is_same(remove_reference_t<int (S::* const volatile&&)() const volatile>, int (S::* const volatile)() const volatile))]; }
+  { int a[T(__is_same(remove_reference_t<int (S::* const volatile&&)() const volatile&>, int (S::* const volatile)() const volatile&))]; }
+  { int a[T(__is_same(remove_reference_t<int (S::* const volatile&&)() const volatile&&>, int (S::* const volatile)() const volatile&&))]; }
+}
+
+template<class T> using remove_cvref_t = __remove_cvref(T);
+
+void check_remove_cvref() {
+  { int a[T(__is_same(remove_cvref_t<void>, void))]; }
+  { int a[T(__is_same(remove_cvref_t<const volatile void>, void))]; }
+  { int a[T(__is_same(remove_cvref_t<int>, int))]; }
+  { int a[T(__is_same(remove_cvref_t<const int>, int))]; }
+  { int a[T(__is_same(remove_cvref_t<volatile int>, int))]; }
+  { int a[T(__is_same(remove_cvref_t<const volatile int>, int))]; }
+  { int a[T(__is_same(remove_cvref_t<int*>, int*))]; }
+  { int a[T(__is_same(remove_cvref_t<int* const volatile>, int*))]; }
+  { int a[T(__is_same(remove_cvref_t<int const* const volatile>, int const*))]; }
+  { int a[T(__is_same(remove_cvref_t<int&>, int))]; }
+  { int a[T(__is_same(remove_cvref_t<int const volatile&>, int))]; }
+  { int a[T(__is_same(remove_cvref_t<int&&>, int))]; }
+  { int a[T(__is_same(remove_cvref_t<int const volatile&&>, int))]; }
+  { int a[T(__is_same(remove_cvref_t<int()>, int()))]; }
+  { int a[T(__is_same(remove_cvref_t<int(* const volatile)()>, int(*)()))]; }
+  { int a[T(__is_same(remove_cvref_t<int(&)()>, int()))]; }
+
+  { int a[T(__is_same(remove_cvref_t<S>, S))]; }
+  { int a[T(__is_same(remove_cvref_t<S&>, S))]; }
+  { int a[T(__is_same(remove_cvref_t<S&&>, S))]; }
+  { int a[T(__is_same(remove_cvref_t<const S>, S))]; }
+  { int a[T(__is_same(remove_cvref_t<const S&>, S))]; }
+  { int a[T(__is_same(remove_cvref_t<const S&&>, S))]; }
+  { int a[T(__is_same(remove_cvref_t<volatile S>, S))]; }
+  { int a[T(__is_same(remove_cvref_t<volatile S&>, S))]; }
+  { int a[T(__is_same(remove_cvref_t<volatile S&&>, S))]; }
+  { int a[T(__is_same(remove_cvref_t<const volatile S>, S))]; }
+  { int a[T(__is_same(remove_cvref_t<const volatile S&>, S))]; }
+  { int a[T(__is_same(remove_cvref_t<const volatile S&&>, S))]; }
+  { int a[T(__is_same(remove_cvref_t<int S::* const volatile>, int S::*))]; }
+  { int a[T(__is_same(remove_cvref_t<int (S::* const volatile)()>, int (S::*)()))]; }
+  { int a[T(__is_same(remove_cvref_t<int (S::* const volatile)() &>, int (S::*)() &))]; }
+  { int a[T(__is_same(remove_cvref_t<int (S::* const volatile)() &&>, int (S::*)() &&))]; }
+  { int a[T(__is_same(remove_cvref_t<int (S::* const volatile)() const>, int (S::*)() const))]; }
+  { int a[T(__is_same(remove_cvref_t<int (S::* const volatile)() const&>, int (S::*)() const&))]; }
+  { int a[T(__is_same(remove_cvref_t<int (S::* const volatile)() const&&>, int (S::*)() const&&))]; }
+  { int a[T(__is_same(remove_cvref_t<int (S::* const volatile)() volatile>, int (S::*)() volatile))]; }
+  { int a[T(__is_same(remove_cvref_t<int (S::* const volatile)() volatile&>, int (S::*)() volatile&))]; }
+  { int a[T(__is_same(remove_cvref_t<int (S::* const volatile)() volatile&&>, int (S::*)() volatile&&))]; }
+  { int a[T(__is_same(remove_cvref_t<int (S::* const volatile)() const volatile>, int (S::*)() const volatile))]; }
+  { int a[T(__is_same(remove_cvref_t<int (S::* const volatile)() const volatile&>, int (S::*)() const volatile&))]; }
+  { int a[T(__is_same(remove_cvref_t<int (S::* const volatile)() const volatile&&>, int (S::*)() const volatile&&))]; }
+  { int a[T(__is_same(remove_cvref_t<int S::* const volatile&>, int S::*))]; }
+  { int a[T(__is_same(remove_cvref_t<int (S::* const volatile&)()>, int (S::*)()))]; }
+  { int a[T(__is_same(remove_cvref_t<int (S::* const volatile&)() &>, int (S::*)() &))]; }
+  { int a[T(__is_same(remove_cvref_t<int (S::* const volatile&)() &&>, int (S::*)() &&))]; }
+  { int a[T(__is_same(remove_cvref_t<int (S::* const volatile&)() const>, int (S::*)() const))]; }
+  { int a[T(__is_same(remove_cvref_t<int (S::* const volatile&)() const&>, int (S::*)() const&))]; }
+  { int a[T(__is_same(remove_cvref_t<int (S::* const volatile&)() const&&>, int (S::*)() const&&))]; }
+  { int a[T(__is_same(remove_cvref_t<int (S::* const volatile&)() volatile>, int (S::*)() volatile))]; }
+  { int a[T(__is_same(remove_cvref_t<int (S::* const volatile&)() volatile&>, int (S::*)() volatile&))]; }
+  { int a[T(__is_same(remove_cvref_t<int (S::* const volatile&)() volatile&&>, int (S::*)() volatile&&))]; }
+  { int a[T(__is_same(remove_cvref_t<int (S::* const volatile&)() const volatile>, int (S::*)() const volatile))]; }
+  { int a[T(__is_same(remove_cvref_t<int (S::* const volatile&)() const volatile&>, int (S::*)() const volatile&))]; }
+  { int a[T(__is_same(remove_cvref_t<int (S::* const volatile&)() const volatile&&>, int (S::*)() const volatile&&))]; }
+  { int a[T(__is_same(remove_cvref_t<int S::* const volatile&&>, int S::*))]; }
+  { int a[T(__is_same(remove_cvref_t<int (S::* const volatile&&)()>, int (S::*)()))]; }
+  { int a[T(__is_same(remove_cvref_t<int (S::* const volatile&&)() &>, int (S::*)() &))]; }
+  { int a[T(__is_same(remove_cvref_t<int (S::* const volatile&&)() &&>, int (S::*)() &&))]; }
+  { int a[T(__is_same(remove_cvref_t<int (S::* const volatile&&)() const>, int (S::*)() const))]; }
+  { int a[T(__is_same(remove_cvref_t<int (S::* const volatile&&)() const&>, int (S::*)() const&))]; }
+  { int a[T(__is_same(remove_cvref_t<int (S::* const volatile&&)() const&&>, int (S::*)() const&&))]; }
+  { int a[T(__is_same(remove_cvref_t<int (S::* const volatile&&)() volatile>, int (S::*)() volatile))]; }
+  { int a[T(__is_same(remove_cvref_t<int (S::* const volatile&&)() volatile&>, int (S::*)() volatile&))]; }
+  { int a[T(__is_same(remove_cvref_t<int (S::* const volatile&&)() volatile&&>, int (S::*)() volatile&&))]; }
+  { int a[T(__is_same(remove_cvref_t<int (S::* const volatile&&)() const volatile>, int (S::*)() const volatile))]; }
+  { int a[T(__is_same(remove_cvref_t<int (S::* const volatile&&)() const volatile&>, int (S::*)() const volatile&))]; }
+  { int a[T(__is_same(remove_cvref_t<int (S::* const volatile&&)() const volatile&&>, int (S::*)() const volatile&&))]; }
+}
+
+template<class T> using decay_t = __decay(T);
+
+void check_decay() {
+  { int a[T(__is_same(decay_t<void>, void))]; }
+  { int a[T(__is_same(decay_t<const volatile void>, void))]; }
+  { int a[T(__is_same(decay_t<int>, int))]; }
+  { int a[T(__is_same(decay_t<const int>, int))]; }
+  { int a[T(__is_same(decay_t<volatile int>, int))]; }
+  { int a[T(__is_same(decay_t<const volatile int>, int))]; }
+  { int a[T(__is_same(decay_t<int*>, int*))]; }
+  { int a[T(__is_same(decay_t<int* const volatile>, int*))]; }
+  { int a[T(__is_same(decay_t<int const* const volatile>, int const*))]; }
+  { int a[T(__is_same(decay_t<int&>, int))]; }
+  { int a[T(__is_same(decay_t<int const volatile&>, int))]; }
+  { int a[T(__is_same(decay_t<int&&>, int))]; }
+  { int a[T(__is_same(decay_t<int const volatile&&>, int))]; }
+  { int a[T(__is_same(decay_t<int()>, int(*)()))]; }
+  { int a[T(__is_same(decay_t<int(*)()>, int(*)()))]; }
+  { int a[T(__is_same(decay_t<int(* const)()>, int(*)()))]; }
+  { int a[T(__is_same(decay_t<int(* volatile)()>, int(*)()))]; }
+  { int a[T(__is_same(decay_t<int(* const volatile)()>, int(*)()))]; }
+  { int a[T(__is_same(decay_t<int(&)()>, int(*)()))]; }
+  { int a[T(__is_same(decay_t<IntAr>, int*))]; }
+  { int a[T(__is_same(decay_t<IntArNB>, int*))]; }
+
+  { int a[T(__is_same(decay_t<S>, S))]; }
+  { int a[T(__is_same(decay_t<S&>, S))]; }
+  { int a[T(__is_same(decay_t<S&&>, S))]; }
+  { int a[T(__is_same(decay_t<const S>, S))]; }
+  { int a[T(__is_same(decay_t<const S&>, S))]; }
+  { int a[T(__is_same(decay_t<const S&&>, S))]; }
+  { int a[T(__is_same(decay_t<volatile S>, S))]; }
+  { int a[T(__is_same(decay_t<volatile S&>, S))]; }
+  { int a[T(__is_same(decay_t<volatile S&&>, S))]; }
+  { int a[T(__is_same(decay_t<const volatile S>, S))]; }
+  { int a[T(__is_same(decay_t<const volatile S&>, S))]; }
+  { int a[T(__is_same(decay_t<const volatile S&&>, S))]; }
+  { int a[T(__is_same(decay_t<int S::* const volatile>, int S::*))]; }
+  { int a[T(__is_same(decay_t<int (S::* const volatile)()>, int (S::*)()))]; }
+  { int a[T(__is_same(decay_t<int (S::* const volatile)() &>, int (S::*)() &))]; }
+  { int a[T(__is_same(decay_t<int (S::* const volatile)() &&>, int (S::*)() &&))]; }
+  { int a[T(__is_same(decay_t<int (S::* const volatile)() const>, int (S::*)() const))]; }
+  { int a[T(__is_same(decay_t<int (S::* const volatile)() const&>, int (S::*)() const&))]; }
+  { int a[T(__is_same(decay_t<int (S::* const volatile)() const&&>, int (S::*)() const&&))]; }
+  { int a[T(__is_same(decay_t<int (S::* const volatile)() volatile>, int (S::*)() volatile))]; }
+  { int a[T(__is_same(decay_t<int (S::* const volatile)() volatile&>, int (S::*)() volatile&))]; }
+  { int a[T(__is_same(decay_t<int (S::* const volatile)() volatile&&>, int (S::*)() volatile&&))]; }
+  { int a[T(__is_same(decay_t<int (S::* const volatile)() const volatile>, int (S::*)() const volatile))]; }
+  { int a[T(__is_same(decay_t<int (S::* const volatile)() const volatile&>, int (S::*)() const volatile&))]; }
+  { int a[T(__is_same(decay_t<int (S::* const volatile)() const volatile&&>, int (S::*)() const volatile&&))]; }
+  { int a[T(__is_same(decay_t<int S::* const volatile&>, int S::*))]; }
+  { int a[T(__is_same(decay_t<int (S::* const volatile&)()>, int (S::*)()))]; }
+  { int a[T(__is_same(decay_t<int (S::* const volatile&)() &>, int (S::*)() &))]; }
+  { int a[T(__is_same(decay_t<int (S::* const volatile&)() &&>, int (S::*)() &&))]; }
+  { int a[T(__is_same(decay_t<int (S::* const volatile&)() const>, int (S::*)() const))]; }
+  { int a[T(__is_same(decay_t<int (S::* const volatile&)() const&>, int (S::*)() const&))]; }
+  { int a[T(__is_same(decay_t<int (S::* const volatile&)() const&&>, int (S::*)() const&&))]; }
+  { int a[T(__is_same(decay_t<int (S::* const volatile&)() volatile>, int (S::*)() volatile))]; }
+  { int a[T(__is_same(decay_t<int (S::* const volatile&)() volatile&>, int (S::*)() volatile&))]; }
+  { int a[T(__is_same(decay_t<int (S::* const volatile&)() volatile&&>, int (S::*)() volatile&&))]; }
+  { int a[T(__is_same(decay_t<int (S::* const volatile&)() const volatile>, int (S::*)() const volatile))]; }
+  { int a[T(__is_same(decay_t<int (S::* const volatile&)() const volatile&>, int (S::*)() const volatile&))]; }
+  { int a[T(__is_same(decay_t<int (S::* const volatile&)() const volatile&&>, int (S::*)() const volatile&&))]; }
+  { int a[T(__is_same(decay_t<int S::* const volatile&&>, int S::*))]; }
+  { int a[T(__is_same(decay_t<int (S::* const volatile&&)()>, int (S::*)()))]; }
+  { int a[T(__is_same(decay_t<int (S::* const volatile&&)() &>, int (S::*)() &))]; }
+  { int a[T(__is_same(decay_t<int (S::* const volatile&&)() &&>, int (S::*)() &&))]; }
+  { int a[T(__is_same(decay_t<int (S::* const volatile&&)() const>, int (S::*)() const))]; }
+  { int a[T(__is_same(decay_t<int (S::* const volatile&&)() const&>, int (S::*)() const&))]; }
+  { int a[T(__is_same(decay_t<int (S::* const volatile&&)() const&&>, int (S::*)() const&&))]; }
+  { int a[T(__is_same(decay_t<int (S::* const volatile&&)() volatile>, int (S::*)() volatile))]; }
+  { int a[T(__is_same(decay_t<int (S::* const volatile&&)() volatile&>, int (S::*)() volatile&))]; }
+  { int a[T(__is_same(decay_t<int (S::* const volatile&&)() volatile&&>, int (S::*)() volatile&&))]; }
+  { int a[T(__is_same(decay_t<int (S::* const volatile&&)() const volatile>, int (S::*)() const volatile))]; }
+  { int a[T(__is_same(decay_t<int (S::* const volatile&&)() const volatile&>, int (S::*)() const volatile&))]; }
+  { int a[T(__is_same(decay_t<int (S::* const volatile&&)() const volatile&&>, int (S::*)() const volatile&&))]; }
+}
+
+template<class T> struct CheckAbominableFunction {};
+template<class M>
+struct CheckAbominableFunction<M S::*> {
+  static void checks()
+  {
+    { int a[T(__is_same(add_const_t<M>, const M))]; }
+    { int a[T(__is_same(add_volatile_t<M>, volatile M))]; }
+    { int a[T(__is_same(add_cv_t<M>, const volatile M))]; }
+    { int a[T(__is_same(add_lvalue_reference_t<M>, M))]; }
+    { int a[T(__is_same(add_pointer_t<M>, M))]; }
+    { int a[T(__is_same(add_rvalue_reference_t<M>, M))]; }
+    { int a[T(__is_same(remove_const_t<M>, M))]; }
+    { int a[T(__is_same(remove_volatile_t<M>, M))]; }
+    { int a[T(__is_same(remove_cv_t<M>, M))]; }
+    { int a[T(__is_same(remove_cvref_t<M>, M))]; }
+    { int a[T(__is_same(remove_pointer_t<M>, M))]; }
+    { int a[T(__is_same(remove_reference_t<M>, M))]; }
+  }
+};
+
+void check_abominable_function()
+{
+  { CheckAbominableFunction<int (S::*)() &> x; }
+  { CheckAbominableFunction<int (S::*)() &&> x; }
+  { CheckAbominableFunction<int (S::*)() const> x; }
+  { CheckAbominableFunction<int (S::*)() const&> x; }
+  { CheckAbominableFunction<int (S::*)() const&&> x; }
+  { CheckAbominableFunction<int (S::*)() volatile> x; }
+  { CheckAbominableFunction<int (S::*)() volatile&> x; }
+  { CheckAbominableFunction<int (S::*)() volatile&&> x; }
+  { CheckAbominableFunction<int (S::*)() const volatile> x; }
+  { CheckAbominableFunction<int (S::*)() const volatile&> x; }
+  { CheckAbominableFunction<int (S::*)() const volatile&&> x; }
+}
+
+template<class T> using make_signed_t = __make_signed(T);
+
+void make_signed()
+{
+  { int a[T(__is_same(make_signed_t<char>, signed char))]; }
+  { int a[T(__is_same(make_signed_t<const char>, const signed char))]; }
+  { int a[T(__is_same(make_signed_t<volatile char>, volatile signed char))]; }
+  { int a[T(__is_same(make_signed_t<const volatile char>, const volatile signed char))]; }
+  { int a[T(__is_same(make_signed_t<signed char>, signed char))]; }
+  { int a[T(__is_same(make_signed_t<const signed char>, const signed char))]; }
+  { int a[T(__is_same(make_signed_t<volatile signed char>, volatile signed char))]; }
+  { int a[T(__is_same(make_signed_t<const volatile signed char>, const volatile signed char))]; }
+  { int a[T(__is_same(make_signed_t<unsigned char>, signed char))]; }
+  { int a[T(__is_same(make_signed_t<const unsigned char>, signed char))]; }
+  { int a[T(__is_same(make_signed_t<volatile unsigned char>, signed char))]; }
+  { int a[T(__is_same(make_signed_t<const volatile unsigned char>, signed char))]; }
+  { int a[T(__is_same(make_signed_t<short>, short))]; }
+  { int a[T(__is_same(make_signed_t<const short>, const short))]; }
+  { int a[T(__is_same(make_signed_t<volatile short>, volatile short))]; }
+  { int a[T(__is_same(make_signed_t<const volatile short>, const volatile short))]; }
+  { int a[T(__is_same(make_signed_t<unsigned short>, short))]; }
+  { int a[T(__is_same(make_signed_t<const unsigned short>, short))]; }
+  { int a[T(__is_same(make_signed_t<volatile unsigned short>, short))]; }
+  { int a[T(__is_same(make_signed_t<const volatile unsigned short>, short))]; }
+  { int a[T(__is_same(make_signed_t<int>, int))]; }
+  { int a[T(__is_same(make_signed_t<const int>, const int))]; }
+  { int a[T(__is_same(make_signed_t<volatile int>, volatile int))]; }
+  { int a[T(__is_same(make_signed_t<const volatile int>, const volatile int))]; }
+  { int a[T(__is_same(make_signed_t<unsigned int>, int))]; }
+  { int a[T(__is_same(make_signed_t<const unsigned int>, int))]; }
+  { int a[T(__is_same(make_signed_t<volatile unsigned int>, int))]; }
+  { int a[T(__is_same(make_signed_t<const volatile unsigned int>, int))]; }
+  { int a[T(__is_same(make_signed_t<long>, long))]; }
+  { int a[T(__is_same(make_signed_t<const long>, const long))]; }
+  { int a[T(__is_same(make_signed_t<volatile long>, volatile long))]; }
+  { int a[T(__is_same(make_signed_t<const volatile long>, const volatile long))]; }
+  { int a[T(__is_same(make_signed_t<unsigned long>, long))]; }
+  { int a[T(__is_same(make_signed_t<const unsigned long>, long))]; }
+  { int a[T(__is_same(make_signed_t<volatile unsigned long>, long))]; }
+  { int a[T(__is_same(make_signed_t<const volatile unsigned long>, long))]; }
+  { int a[T(__is_same(make_signed_t<long long>, long long))]; } // remains unchanged
+  { int a[T(__is_same(make_signed_t<const long long>, const long long))]; } // remains unchanged
+  { int a[T(__is_same(make_signed_t<volatile long long>, volatile long long))]; } // remains unchanged
+  { int a[T(__is_same(make_signed_t<const volatile long long>, const volatile long long))]; } // remains unchanged
+  { int a[T(__is_same(make_signed_t<unsigned long long>, long))]; }
+  { int a[T(__is_same(make_signed_t<const unsigned long long>, long))]; }
+  { int a[T(__is_same(make_signed_t<volatile unsigned long long>, long))]; }
+  { int a[T(__is_same(make_signed_t<const volatile unsigned long long>, long))]; }
+  { int a[T(__is_same(make_signed_t<__int128>, __int128))]; }
+  { int a[T(__is_same(make_signed_t<const __int128>, const __int128))]; }
+  { int a[T(__is_same(make_signed_t<volatile __int128>, volatile __int128))]; }
+  { int a[T(__is_same(make_signed_t<const volatile __int128>, const volatile __int128))]; }
+  { int a[T(__is_same(make_signed_t<__uint128_t>, __int128))]; }
+  { int a[T(__is_same(make_signed_t<const __uint128_t>, __int128))]; }
+  { int a[T(__is_same(make_signed_t<volatile __uint128_t>, __int128))]; }
+  { int a[T(__is_same(make_signed_t<const volatile __uint128_t>, __int128))]; }
+
+  { int a[T(__is_same(make_signed_t<Enum>, int))]; }
+  { int a[T(__is_same(make_signed_t<SignedEnum>, int))]; }
+  { int a[T(__is_same(make_signed_t<const SignedEnum>, int))]; }
+  { int a[T(__is_same(make_signed_t<volatile SignedEnum>, int))]; }
+  { int a[T(__is_same(make_signed_t<const volatile SignedEnum>, int))]; }
+  { int a[T(__is_same(make_signed_t<UnsignedEnum>, int))]; }
+  { int a[T(__is_same(make_signed_t<const UnsignedEnum>, int))]; }
+  { int a[T(__is_same(make_signed_t<volatile UnsignedEnum>, int))]; }
+  { int a[T(__is_same(make_signed_t<const volatile UnsignedEnum>, int))]; }
+
+  { int a[T(__is_same(make_signed_t<EnumClass>, int))]; }
+  { int a[T(__is_same(make_signed_t<SignedEnumClass>, int))]; }
+  { int a[T(__is_same(make_signed_t<const SignedEnumClass>, int))]; }
+  { int a[T(__is_same(make_signed_t<volatile SignedEnumClass>, int))]; }
+  { int a[T(__is_same(make_signed_t<const volatile SignedEnumClass>, int))]; }
+  { int a[T(__is_same(make_signed_t<UnsignedEnumClass>, int))]; }
+  { int a[T(__is_same(make_signed_t<const UnsignedEnumClass>, int))]; }
+  { int a[T(__is_same(make_signed_t<volatile UnsignedEnumClass>, int))]; }
+  { int a[T(__is_same(make_signed_t<const volatile UnsignedEnumClass>, int))]; }
+
+  { using ExpectedError = make_signed_t<bool>; }
+  // expected-error@*:*{{'make_signed' is only compatible with non-bool integers and enum types, but was given 'bool'}}
+  // expected-note@-2{{in instantiation of template type alias 'make_signed_t' requested here}}
+  { using ExpectedError = make_signed_t<int[]>; }
+  // expected-error@*:*{{'make_signed' is only compatible with non-bool integers and enum types, but was given 'int[]'}}
+  // expected-note@-2{{in instantiation of template type alias 'make_signed_t' requested here}}
+  { using ExpectedError = make_signed_t<int[5]>; }
+  // expected-error@*:*{{'make_signed' is only compatible with non-bool integers and enum types, but was given 'int[5]'}}
+  // expected-note@-2{{in instantiation of template type alias 'make_signed_t' requested here}}
+  { using ExpectedError = make_signed_t<void>; }
+  // expected-error@*:*{{'make_signed' is only compatible with non-bool integers and enum types, but was given 'void'}}
+  // expected-note@-2{{in instantiation of template type alias 'make_signed_t' requested here}}
+  { using ExpectedError = make_signed_t<int*>; }
+  // expected-error@*:*{{'make_signed' is only compatible with non-bool integers and enum types, but was given 'int *'}}
+  // expected-note@-2{{in instantiation of template type alias 'make_signed_t' requested here}}
+  { using ExpectedError = make_signed_t<int &>; }
+  // expected-error@*:*{{'make_signed' is only compatible with non-bool integers and enum types, but was given 'int &'}}
+  // expected-note@-2{{in instantiation of template type alias 'make_signed_t' requested here}}
+  { using ExpectedError = make_signed_t<int &&>; }
+  // expected-error@*:*{{'make_signed' is only compatible with non-bool integers and enum types, but was given 'int &&'}}
+  // expected-note@-2{{in instantiation of template type alias 'make_signed_t' requested here}}
+  { using ExpectedError = make_signed_t<float>; }
+  // expected-error@*:*{{'make_signed' is only compatible with non-bool integers and enum types, but was given 'float'}}
+  // expected-note@-2{{in instantiation of template type alias 'make_signed_t' requested here}}
+  { using ExpectedError = make_signed_t<double>; }
+  // expected-error@*:*{{'make_signed' is only compatible with non-bool integers and enum types, but was given 'double'}}
+  // expected-note@-2{{in instantiation of template type alias 'make_signed_t' requested here}}
+  { using ExpectedError = make_signed_t<long double>; }
+  // expected-error@*:*{{'make_signed' is only compatible with non-bool integers and enum types, but was given 'long double'}}
+  // expected-note@-2{{in instantiation of template type alias 'make_signed_t' requested here}}
+  { using ExpectedError = make_signed_t<S>; }
+  // expected-error@*:*{{'make_signed' is only compatible with non-bool integers and enum types, but was given 'S'}}
+  // expected-note@-2{{in instantiation of template type alias 'make_signed_t' requested here}}
+  { using ExpectedError = make_signed_t<S*>; }
+  // expected-error@*:*{{'make_signed' is only compatible with non-bool integers and enum types, but was given 'S *'}}
+  // expected-note@-2{{in instantiation of template type alias 'make_signed_t' requested here}}
+  { using ExpectedError = make_signed_t<int S::*>; }
+  // expected-error@*:*{{'make_signed' is only compatible with non-bool integers and enum types, but was given 'int S::*'}}
+  // expected-note@-2{{in instantiation of template type alias 'make_signed_t' requested here}}
+  { using ExpectedError = make_signed_t<int (S::*)()>; }
+  // expected-error@*:*{{'make_signed' is only compatible with non-bool integers and enum types, but was given 'int (S::*)()'}}
+  // expected-note@-2{{in instantiation of template type alias 'make_signed_t' requested here}}
+  { using ExpectedError = make_signed_t<int (S::*)() &>; }
+  // expected-error@*:*{{'make_signed' is only compatible with non-bool integers and enum types, but was given 'int (S::*)() &'}}
+  // expected-note@-2{{in instantiation of template type alias 'make_signed_t' requested here}}
+  { using ExpectedError = make_signed_t<int (S::*)() &&>; }
+  // expected-error@*:*{{'make_signed' is only compatible with non-bool integers and enum types, but was given 'int (S::*)() &&'}}
+  // expected-note@-2{{in instantiation of template type alias 'make_signed_t' requested here}}
+  { using ExpectedError = make_signed_t<int (S::*)() const>; }
+  // expected-error@*:*{{'make_signed' is only compatible with non-bool integers and enum types, but was given 'int (S::*)() const'}}
+  // expected-note@-2{{in instantiation of template type alias 'make_signed_t' requested here}}
+  { using ExpectedError = make_signed_t<int (S::*)() const &>; }
+  // expected-error@*:*{{'make_signed' is only compatible with non-bool integers and enum types, but was given 'int (S::*)() const &'}}
+  // expected-note@-2{{in instantiation of template type alias 'make_signed_t' requested here}}
+  { using ExpectedError = make_signed_t<int (S::*)() const &&>; }
+  // expected-error@*:*{{'make_signed' is only compatible with non-bool integers and enum types, but was given 'int (S::*)() const &&'}}
+  // expected-note@-2{{in instantiation of template type alias 'make_signed_t' requested here}}
+  { using ExpectedError = make_signed_t<int (S::*)() volatile>; }
+  // expected-error@*:*{{'make_signed' is only compatible with non-bool integers and enum types, but was given 'int (S::*)() volatile'}}
+  // expected-note@-2{{in instantiation of template type alias 'make_signed_t' requested here}}
+  { using ExpectedError = make_signed_t<int (S::*)() volatile &>; }
+  // expected-error@*:*{{'make_signed' is only compatible with non-bool integers and enum types, but was given 'int (S::*)() volatile &'}}
+  // expected-note@-2{{in instantiation of template type alias 'make_signed_t' requested here}}
+  { using ExpectedError = make_signed_t<int (S::*)() volatile &&>; }
+  // expected-error@*:*{{'make_signed' is only compatible with non-bool integers and enum types, but was given 'int (S::*)() volatile &&'}}
+  // expected-note@-2{{in instantiation of template type alias 'make_signed_t' requested here}}
+  { using ExpectedError = make_signed_t<int (S::*)() const volatile>; }
+  // expected-error@*:*{{'make_signed' is only compatible with non-bool integers and enum types, but was given 'int (S::*)() const volatile'}}
+  // expected-note@-2{{in instantiation of template type alias 'make_signed_t' requested here}}
+  { using ExpectedError = make_signed_t<int (S::*)() const volatile &>; }
+  // expected-error@*:*{{'make_signed' is only compatible with non-bool integers and enum types, but was given 'int (S::*)() const volatile &'}}
+  // expected-note@-2{{in instantiation of template type alias 'make_signed_t' requested here}}
+  { using ExpectedError = make_signed_t<int (S::*)() const volatile &&>; }
+  // expected-error@*:*{{'make_signed' is only compatible with non-bool integers and enum types, but was given 'int (S::*)() const volatile &&'}}
+  // expected-note@-2{{in instantiation of template type alias 'make_signed_t' requested here}}
+}
+
+template <class T> using make_unsigned_t = __make_unsigned(T);
+
+void make_unsigned()
+{
+  { int a[T(__is_same(make_unsigned_t<char>, unsigned char))]; }
+  { int a[T(__is_same(make_unsigned_t<const char>, unsigned char))]; }
+  { int a[T(__is_same(make_unsigned_t<volatile char>, unsigned char))]; }
+  { int a[T(__is_same(make_unsigned_t<const volatile char>, unsigned char))]; }
+  { int a[T(__is_same(make_unsigned_t<signed char>, unsigned char))]; }
+  { int a[T(__is_same(make_unsigned_t<const signed char>, unsigned char))]; }
+  { int a[T(__is_same(make_unsigned_t<volatile signed char>, unsigned char))]; }
+  { int a[T(__is_same(make_unsigned_t<const volatile signed char>, unsigned char))]; }
+  { int a[T(__is_same(make_unsigned_t<unsigned char>, unsigned char))]; }
+  { int a[T(__is_same(make_unsigned_t<const unsigned char>, const unsigned char))]; }
+  { int a[T(__is_same(make_unsigned_t<volatile unsigned char>, volatile unsigned char))]; }
+  { int a[T(__is_same(make_unsigned_t<const volatile unsigned char>, const volatile unsigned char))]; }
+  { int a[T(__is_same(make_unsigned_t<short>, unsigned short))]; }
+  { int a[T(__is_same(make_unsigned_t<const short>, unsigned  short))]; }
+  { int a[T(__is_same(make_unsigned_t<volatile short>, unsigned short))]; }
+  { int a[T(__is_same(make_unsigned_t<const volatile short>, unsigned short))]; }
+  { int a[T(__is_same(make_unsigned_t<unsigned short>, unsigned short))]; }
+  { int a[T(__is_same(make_unsigned_t<const unsigned short>, const unsigned short))]; }
+  { int a[T(__is_same(make_unsigned_t<volatile unsigned short>, volatile unsigned short))]; }
+  { int a[T(__is_same(make_unsigned_t<const volatile unsigned short>, const volatile unsigned short))]; }
+  { int a[T(__is_same(make_unsigned_t<int>, unsigned int))]; }
+  { int a[T(__is_same(make_unsigned_t<const int>, unsigned int))]; }
+  { int a[T(__is_same(make_unsigned_t<volatile int>, unsigned int))]; }
+  { int a[T(__is_same(make_unsigned_t<const volatile int>, unsigned int))]; }
+  { int a[T(__is_same(make_unsigned_t<unsigned int>, unsigned int))]; }
+  { int a[T(__is_same(make_unsigned_t<const unsigned int>, const unsigned int))]; }
+  { int a[T(__is_same(make_unsigned_t<volatile unsigned int>, volatile unsigned int))]; }
+  { int a[T(__is_same(make_unsigned_t<const volatile unsigned int>, const volatile unsigned int))]; }
+  { int a[T(__is_same(make_unsigned_t<long>, unsigned long))]; }
+  { int a[T(__is_same(make_unsigned_t<const long>, unsigned long))]; }
+  { int a[T(__is_same(make_unsigned_t<volatile long>, unsigned long))]; }
+  { int a[T(__is_same(make_unsigned_t<const volatile long>, unsigned long))]; }
+  { int a[T(__is_same(make_unsigned_t<unsigned long>, unsigned long))]; }
+  { int a[T(__is_same(make_unsigned_t<const unsigned long>, const unsigned long))]; }
+  { int a[T(__is_same(make_unsigned_t<volatile unsigned long>, volatile unsigned long))]; }
+  { int a[T(__is_same(make_unsigned_t<const volatile unsigned long>, const volatile unsigned long))]; }
+  { int a[T(__is_same(make_unsigned_t<long long>, unsigned long))]; }
+  { int a[T(__is_same(make_unsigned_t<const long long>, unsigned long))]; }
+  { int a[T(__is_same(make_unsigned_t<volatile long long>, unsigned long))]; }
+  { int a[T(__is_same(make_unsigned_t<const volatile long long>, unsigned long))]; }
+  { int a[T(__is_same(make_unsigned_t<unsigned long long>, unsigned long long))]; } // remains unchanged
+  { int a[T(__is_same(make_unsigned_t<const unsigned long long>, const unsigned long long))]; } // remains unchanged
+  { int a[T(__is_same(make_unsigned_t<volatile unsigned long long>, volatile unsigned long long))]; } // remains unchanged
+  { int a[T(__is_same(make_unsigned_t<const volatile unsigned long long>, const volatile unsigned long long))]; } // remains unchanged
+  { int a[T(__is_same(make_unsigned_t<__int128>, __uint128_t))]; }
+  { int a[T(__is_same(make_unsigned_t<const __int128>, __uint128_t))]; }
+  { int a[T(__is_same(make_unsigned_t<volatile __int128>, __uint128_t))]; }
+  { int a[T(__is_same(make_unsigned_t<const volatile __int128>, __uint128_t))]; }
+  { int a[T(__is_same(make_unsigned_t<__uint128_t>, __uint128_t))]; }
+  { int a[T(__is_same(make_unsigned_t<const __uint128_t>, const __uint128_t))]; }
+  { int a[T(__is_same(make_unsigned_t<volatile __uint128_t>, volatile __uint128_t))]; }
+  { int a[T(__is_same(make_unsigned_t<const volatile __uint128_t>, const volatile __uint128_t))]; }
+
+  { int a[T(__is_same(make_unsigned_t<Enum>, unsigned int))]; }
+  { int a[T(__is_same(make_unsigned_t<SignedEnum>, unsigned int))]; }
+  { int a[T(__is_same(make_unsigned_t<const SignedEnum>, unsigned int))]; }
+  { int a[T(__is_same(make_unsigned_t<volatile SignedEnum>, unsigned int))]; }
+  { int a[T(__is_same(make_unsigned_t<const volatile SignedEnum>, unsigned int))]; }
+  { int a[T(__is_same(make_unsigned_t<UnsignedEnum>, unsigned int))]; }
+  { int a[T(__is_same(make_unsigned_t<const UnsignedEnum>, unsigned int))]; }
+  { int a[T(__is_same(make_unsigned_t<volatile UnsignedEnum>, unsigned int))]; }
+  { int a[T(__is_same(make_unsigned_t<const volatile UnsignedEnum>, unsigned int))]; }
+
+  { int a[T(__is_same(make_unsigned_t<EnumClass>, unsigned int))]; }
+  { int a[T(__is_same(make_unsigned_t<SignedEnumClass>, unsigned int))]; }
+  { int a[T(__is_same(make_unsigned_t<const SignedEnumClass>, unsigned int))]; }
+  { int a[T(__is_same(make_unsigned_t<volatile SignedEnumClass>, unsigned int))]; }
+  { int a[T(__is_same(make_unsigned_t<const volatile SignedEnumClass>, unsigned int))]; }
+  { int a[T(__is_same(make_unsigned_t<UnsignedEnumClass>, unsigned int))]; }
+  { int a[T(__is_same(make_unsigned_t<const UnsignedEnumClass>, unsigned int))]; }
+  { int a[T(__is_same(make_unsigned_t<volatile UnsignedEnumClass>, unsigned int))]; }
+  { int a[T(__is_same(make_unsigned_t<const volatile UnsignedEnumClass>, unsigned int))]; }
+
+  { using ExpectedError = make_signed_t<bool>; }
+  // expected-error@*:*{{'make_signed' is only compatible with non-bool integers and enum types, but was given 'bool'}}
+  // expected-note@-2{{in instantiation of template type alias 'make_signed_t' requested here}}
+  { using ExpectedError = make_unsigned_t<int[]>; }
+  // expected-error@*:*{{'make_unsigned' is only compatible with non-bool integers and enum types, but was given 'int[]'}}
+  // expected-note@-2{{in instantiation of template type alias 'make_unsigned_t' requested here}}
+  { using ExpectedError = make_unsigned_t<int[5]>; }
+  // expected-error@*:*{{'make_unsigned' is only compatible with non-bool integers and enum types, but was given 'int[5]'}}
+  // expected-note@-2{{in instantiation of template type alias 'make_unsigned_t' requested here}}
+  { using ExpectedError = make_unsigned_t<void>; }
+  // expected-error@*:*{{'make_unsigned' is only compatible with non-bool integers and enum types, but was given 'void'}}
+  // expected-note@-2{{in instantiation of template type alias 'make_unsigned_t' requested here}}
+  { using ExpectedError = make_unsigned_t<int*>; }
+  // expected-error@*:*{{'make_unsigned' is only compatible with non-bool integers and enum types, but was given 'int *'}}
+  // expected-note@-2{{in instantiation of template type alias 'make_unsigned_t' requested here}}
+  { using ExpectedError = make_unsigned_t<int &>; }
+  // expected-error@*:*{{'make_unsigned' is only compatible with non-bool integers and enum types, but was given 'int &'}}
+  // expected-note@-2{{in instantiation of template type alias 'make_unsigned_t' requested here}}
+  { using ExpectedError = make_unsigned_t<int &&>; }
+  // expected-error@*:*{{'make_unsigned' is only compatible with non-bool integers and enum types, but was given 'int &&'}}
+  // expected-note@-2{{in instantiation of template type alias 'make_unsigned_t' requested here}}
+  { using ExpectedError = make_unsigned_t<float>; }
+  // expected-error@*:*{{'make_unsigned' is only compatible with non-bool integers and enum types, but was given 'float'}}
+  // expected-note@-2{{in instantiation of template type alias 'make_unsigned_t' requested here}}
+  { using ExpectedError = make_unsigned_t<double>; }
+  // expected-error@*:*{{'make_unsigned' is only compatible with non-bool integers and enum types, but was given 'double'}}
+  // expected-note@-2{{in instantiation of template type alias 'make_unsigned_t' requested here}}
+  { using ExpectedError = make_unsigned_t<long double>; }
+  // expected-error@*:*{{'make_unsigned' is only compatible with non-bool integers and enum types, but was given 'long double'}}
+  // expected-note@-2{{in instantiation of template type alias 'make_unsigned_t' requested here}}
+  { using ExpectedError = make_unsigned_t<S>; }
+  // expected-error@*:*{{'make_unsigned' is only compatible with non-bool integers and enum types, but was given 'S'}}
+  // expected-note@-2{{in instantiation of template type alias 'make_unsigned_t' requested here}}
+  { using ExpectedError = make_unsigned_t<S*>; }
+  // expected-error@*:*{{'make_unsigned' is only compatible with non-bool integers and enum types, but was given 'S *'}}
+  // expected-note@-2{{in instantiation of template type alias 'make_unsigned_t' requested here}}
+  { using ExpectedError = make_unsigned_t<int S::*>; }
+  // expected-error@*:*{{'make_unsigned' is only compatible with non-bool integers and enum types, but was given 'int S::*'}}
+  // expected-note@-2{{in instantiation of template type alias 'make_unsigned_t' requested here}}
+  { using ExpectedError = make_unsigned_t<int (S::*)()>; }
+  // expected-error@*:*{{'make_unsigned' is only compatible with non-bool integers and enum types, but was given 'int (S::*)()'}}
+  // expected-note@-2{{in instantiation of template type alias 'make_unsigned_t' requested here}}
+  { using ExpectedError = make_unsigned_t<int (S::*)() &>; }
+  // expected-error@*:*{{'make_unsigned' is only compatible with non-bool integers and enum types, but was given 'int (S::*)() &'}}
+  // expected-note@-2{{in instantiation of template type alias 'make_unsigned_t' requested here}}
+  { using ExpectedError = make_unsigned_t<int (S::*)() &&>; }
+  // expected-error@*:*{{'make_unsigned' is only compatible with non-bool integers and enum types, but was given 'int (S::*)() &&'}}
+  // expected-note@-2{{in instantiation of template type alias 'make_unsigned_t' requested here}}
+  { using ExpectedError = make_unsigned_t<int (S::*)() const>; }
+  // expected-error@*:*{{'make_unsigned' is only compatible with non-bool integers and enum types, but was given 'int (S::*)() const'}}
+  // expected-note@-2{{in instantiation of template type alias 'make_unsigned_t' requested here}}
+  { using ExpectedError = make_unsigned_t<int (S::*)() const &>; }
+  // expected-error@*:*{{'make_unsigned' is only compatible with non-bool integers and enum types, but was given 'int (S::*)() const &'}}
+  // expected-note@-2{{in instantiation of template type alias 'make_unsigned_t' requested here}}
+  { using ExpectedError = make_unsigned_t<int (S::*)() const &&>; }
+  // expected-error@*:*{{'make_unsigned' is only compatible with non-bool integers and enum types, but was given 'int (S::*)() const &&'}}
+  // expected-note@-2{{in instantiation of template type alias 'make_unsigned_t' requested here}}
+  { using ExpectedError = make_unsigned_t<int (S::*)() volatile>; }
+  // expected-error@*:*{{'make_unsigned' is only compatible with non-bool integers and enum types, but was given 'int (S::*)() volatile'}}
+  // expected-note@-2{{in instantiation of template type alias 'make_unsigned_t' requested here}}
+  { using ExpectedError = make_unsigned_t<int (S::*)() volatile &>; }
+  // expected-error@*:*{{'make_unsigned' is only compatible with non-bool integers and enum types, but was given 'int (S::*)() volatile &'}}
+  // expected-note@-2{{in instantiation of template type alias 'make_unsigned_t' requested here}}
+  { using ExpectedError = make_unsigned_t<int (S::*)() volatile &&>; }
+  // expected-error@*:*{{'make_unsigned' is only compatible with non-bool integers and enum types, but was given 'int (S::*)() volatile &&'}}
+  // expected-note@-2{{in instantiation of template type alias 'make_unsigned_t' requested here}}
+  { using ExpectedError = make_unsigned_t<int (S::*)() const volatile>; }
+  // expected-error@*:*{{'make_unsigned' is only compatible with non-bool integers and enum types, but was given 'int (S::*)() const volatile'}}
+  // expected-note@-2{{in instantiation of template type alias 'make_unsigned_t' requested here}}
+  { using ExpectedError = make_unsigned_t<int (S::*)() const volatile &>; }
+  // expected-error@*:*{{'make_unsigned' is only compatible with non-bool integers and enum types, but was given 'int (S::*)() const volatile &'}}
+  // expected-note@-2{{in instantiation of template type alias 'make_unsigned_t' requested here}}
+  { using ExpectedError = make_unsigned_t<int (S::*)() const volatile &&>; }
+  // expected-error@*:*{{'make_unsigned' is only compatible with non-bool integers and enum types, but was given 'int (S::*)() const volatile &&'}}
+  // expected-note@-2{{in instantiation of template type alias 'make_unsigned_t' requested here}}
+}