[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

4214

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

9228

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

9234–9235

This makes me very happy.

9236–9239

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?

9261

Done, and added a test.

9275

I think this is a no-op?

clang/test/CodeGenCXX/mangle.cpp

54

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

1109–1110

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

clang/test/SemaCXX/remove_pointer.mm

8

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

13–47

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

1749

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

9228

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

5878

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

10784–10786

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?

10803–10831

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

10849–10853

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.

10858–10859

Similar comments for this function as previous one.

clang/lib/AST/TypePrinter.cpp

1156–1157

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

clang/lib/Parse/ParseExpr.cpp

1749

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

6086

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?

9228

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.

9231–9233

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

9234–9235

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.

9256–9260

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.

9257

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?

9260

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.

9271–9279

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.

9274

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.

9303–9312

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

9321–9332

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

9337–9341

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

9234–9235

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

5878

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

10784–10786

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

clang/lib/AST/TypePrinter.cpp

1156–1157

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

clang/lib/Parse/ParseExpr.cpp

1749

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

9274

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

5878

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.

10797–10800

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.

10810

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

1153–1154

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

clang/lib/Parse/ParseExpr.cpp

1752–1753

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

clang/lib/Sema/SemaType.cpp

9367

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.

9372–9373

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.

9383–9385

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

9407

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

9414

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

9474–9475

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

1752–1753

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

10814

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

clang/lib/Parse/ParseDeclCXX.cpp

1153–1154

This comment still needs to be addressed.

clang/lib/Parse/ParseExpr.cpp

1066–1067

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

clang/lib/Sema/SemaType.cpp

9232–9233

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. :)

9363

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.

9364

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.

9366–9370

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?

9377

Please only compute the size of BaseType once.

9380

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

1153–1154

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

clang/lib/Parse/ParseExpr.cpp

1066–1067

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

1749

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.

clang/lib/Sema/SemaType.cpp

9380

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

424–431

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

1156–1157

I believe you can.

clang/lib/Parse/ParseDecl.cpp

3476

clang/lib/Sema/SemaType.cpp

9267

9305–9308

9350–9352

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

424–431

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

clang/lib/AST/TypePrinter.cpp

1156–1157

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

424–431

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

1156–1157

That's fine by me!

clang/test/SemaCXX/type-traits.cpp

3505

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();
   }
 
+  // Determines if a type can form `T&`.
+  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
+#define TRANSFORM_TYPE_TRAIT_DEF(Enum, _) Enum,
+#include "clang/Basic/TransformTypeTraits.def"
   };
 
 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 (const auto *F = Self.getAs<FunctionProtoType>())
+    return F->getMethodQuals().empty() && F->getRefQualifier() == RQ_None;
+
+  return false;
+}
+
 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-%select{bool|_BitInt(1)}1 integers and enum types, but was given "
+  "%2%select{| whose underlying type is %4}3">;
 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
+#define TRANSFORM_TYPE_TRAIT_DEF(_, Trait) TST_##Trait,
+#include "clang/Basic/TransformTypeTraits.def"
+    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_standard_layout, IsStandardLayout, KEYCXX)
 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)
+
+#define TRANSFORM_TYPE_TRAIT_DEF(_, Trait) KEYWORD(__##Trait, KEYCXX)
+#include "clang/Basic/TransformTypeTraits.def"
 
 // Clang-only C++ Type Traits
 TYPE_TRAIT_1(__is_trivially_relocatable, IsTriviallyRelocatable, KEYCXX)
 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/Basic/TransformTypeTraits.def

+//==--- TransformTypeTraits.def - type trait transformations --------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines transform type traits' names.
+//
+//===----------------------------------------------------------------------===//
+
+TRANSFORM_TYPE_TRAIT_DEF(AddLvalueReference, add_lvalue_reference)
+TRANSFORM_TYPE_TRAIT_DEF(AddPointer, add_pointer)
+TRANSFORM_TYPE_TRAIT_DEF(AddRvalueReference, add_rvalue_reference)
+TRANSFORM_TYPE_TRAIT_DEF(Decay, decay)
+TRANSFORM_TYPE_TRAIT_DEF(MakeSigned, make_signed)
+TRANSFORM_TYPE_TRAIT_DEF(MakeUnsigned, make_unsigned)
+TRANSFORM_TYPE_TRAIT_DEF(RemoveAllExtents, remove_all_extents)
+TRANSFORM_TYPE_TRAIT_DEF(RemoveConst, remove_const)
+TRANSFORM_TYPE_TRAIT_DEF(RemoveCV, remove_cv)
+TRANSFORM_TYPE_TRAIT_DEF(RemoveCVRef, remove_cvref)
+TRANSFORM_TYPE_TRAIT_DEF(RemoveExtent, remove_extent)
+TRANSFORM_TYPE_TRAIT_DEF(RemovePointer, remove_pointer)
+TRANSFORM_TYPE_TRAIT_DEF(RemoveReference, remove_reference)
+TRANSFORM_TYPE_TRAIT_DEF(RemoveRestrict, remove_restrict)
+TRANSFORM_TYPE_TRAIT_DEF(RemoveVolatile, remove_volatile)
+TRANSFORM_TYPE_TRAIT_DEF(EnumUnderlyingType, underlying_type)
+#undef TRANSFORM_TYPE_TRAIT_DEF

clang/include/clang/Parse/Parser.h

void ParseAttributeWithTypeArg(IdentifierInfo &AttrName,
                                  SourceLocation ScopeLoc,
                                  ParsedAttr::Syntax Syntax);
 
   void ParseTypeofSpecifier(DeclSpec &DS);
   SourceLocation ParseDecltypeSpecifier(DeclSpec &DS);
   void AnnotateExistingDecltypeSpecifier(const DeclSpec &DS,
                                          SourceLocation StartLoc,
                                          SourceLocation EndLoc);
-  void ParseUnderlyingTypeSpecifier(DeclSpec &DS);
   void ParseAtomicSpecifier(DeclSpec &DS);
 
   ExprResult ParseAlignArgument(SourceLocation Start,
                                 SourceLocation &EllipsisLoc);
   void ParseAlignmentSpecifier(ParsedAttributes &Attrs,
                                SourceLocation *endLoc = nullptr);
   ExprResult ParseExtIntegerArgument();
 
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);
+  bool MaybeParseTypeTransformTypeSpecifier(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_struct = clang::TST_struct;
   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;
+#define TRANSFORM_TYPE_TRAIT_DEF(_, Trait)                                     \
+  static const TST TST_##Trait = clang::TST_##Trait;
+#include "clang/Basic/TransformTypeTraits.def"
   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);
+    return T == TST_atomic || T == TST_typename || T == TST_typeofType ||
+           isTransformTypeTrait(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);
   }
+  static bool isTransformTypeTrait(TST T) {
+    constexpr std::array<TST, 16> Traits = {
+#define TRANSFORM_TYPE_TRAIT_DEF(_, Trait) TST_##Trait,
+#include "clang/Basic/TransformTypeTraits.def"
+    };
+
+    return T >= Traits.front() && T <= Traits.back();
+  }
 
   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)),
#include "clang/Basic/TransformTypeTraits.def"
 
   SourceLocation getTypeSpecTypeNameLoc() const {
     assert(isDeclRep((TST)TypeSpecType) || isTypeRep((TST)TypeSpecType) ||
            isExprRep((TST)TypeSpecType));
     return TSTNameLoc;
   }
 
   SourceRange getTypeofParensRange() const { return TypeofParensRange; }
-  void setTypeofParensRange(SourceRange range) { TypeofParensRange = range; }
+  void setTypeArgumentRange(SourceRange range) { TypeofParensRange = range; }
 
   bool hasAutoTypeSpec() const {
     return (TypeSpecType == TST_auto || TypeSpecType == TST_auto_type ||
             TypeSpecType == TST_decltype_auto);
   }
 
   bool hasTagDefinition() const;
 

clang/include/clang/Sema/Sema.h

public:
 
   // Returns the underlying type of a decltype with the given expression.
   QualType getDecltypeForExpr(Expr *E);
 
   QualType BuildTypeofExprType(Expr *E);
   /// If AsUnevaluated is false, E is treated as though it were an evaluated
   /// context, such as when building a type for decltype(auto).
   QualType BuildDecltypeType(Expr *E, bool AsUnevaluated = true);
-  QualType BuildUnaryTransformType(QualType BaseType,
-                                   UnaryTransformType::UTTKind UKind,
+
+  using UTTKind = UnaryTransformType::UTTKind;
+  QualType BuildUnaryTransformType(QualType BaseType, UTTKind UKind,
+                                   SourceLocation Loc);
+  QualType BuiltinEnumUnderlyingType(QualType BaseType, SourceLocation Loc);
+  QualType BuiltinAddPointer(QualType BaseType, SourceLocation Loc);
+  QualType BuiltinRemovePointer(QualType BaseType, SourceLocation Loc);
+  QualType BuiltinDecay(QualType BaseType, SourceLocation Loc);
+  QualType BuiltinAddReference(QualType BaseType, UTTKind UKind,
+                               SourceLocation Loc);
+  QualType BuiltinRemoveExtent(QualType BaseType, UTTKind UKind,
+                               SourceLocation Loc);
+  QualType BuiltinRemoveReference(QualType BaseType, UTTKind UKind,
+                                  SourceLocation Loc);
+  QualType BuiltinChangeCVRQualifiers(QualType BaseType, UTTKind UKind,
+                                      SourceLocation Loc);
+  QualType BuiltinChangeSignedness(QualType BaseType, UTTKind UKind,
                                    SourceLocation Loc);
 
   //===--------------------------------------------------------------------===//
   // Symbol table / Decl tracking callbacks: SemaDecl.cpp.
   //
 
   struct SkipBodyInfo {
     SkipBodyInfo()

clang/include/clang/module.modulemap

module Clang_Basic {
   textual header "Basic/OpenCLImageTypes.def"
   textual header "Basic/OpenCLExtensionTypes.def"
   textual header "Basic/OpenMPKinds.def"
   textual header "Basic/OperatorKinds.def"
   textual header "Basic/PPCTypes.def"
   textual header "Basic/RISCVVTypes.def"
   textual header "Basic/Sanitizers.def"
   textual header "Basic/TargetCXXABI.def"
+  textual header "Basic/TransformTypeTraits.def"
 
   module * { export * }
 }
 module Clang_Basic_TokenKinds {
   requires cplusplus
 
   header "Basic/TokenKinds.h"
   textual header "Basic/TokenKinds.def"

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.
 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.
     llvm::FoldingSetNodeID ID;

 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()) &&
+  assert((T->hasIntegerRepresentation() || T->isEnumeralType() ||
+          T->isFixedPointType()) &&
          "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(/*Unsigned=*/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_U:
+    // Plain `char` is mapped to `unsigned char` even if it's already unsigned
   case BuiltinType::Char_S:
   case BuiltinType::SChar:
+  case BuiltinType::Char8:
     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.
+  // version of its 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");
+    assert((T->hasUnsignedIntegerRepresentation() ||
+            T->isUnsignedFixedPointType()) &&
+           "Unexpected signed integer or fixed point type");
+    return T;
   }
 }
 
 QualType ASTContext::getCorrespondingSignedType(QualType T) const {
-  assert((T->hasUnsignedIntegerRepresentation() ||
-          T->isUnsignedFixedPointType()) &&
+  assert((T->hasIntegerRepresentation() || T->isEnumeralType() ||
+          T->isFixedPointType()) &&
          "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.
   if (const auto *EITy = T->getAs<BitIntType>())
     return getBitIntType(/*Unsigned=*/false, 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:
+    // Plain `char` is mapped to `signed char` even if it's already signed
   case BuiltinType::Char_U:
   case BuiltinType::UChar:
+  case BuiltinType::Char8:
     return SignedCharTy;
   case BuiltinType::UShort:
     return ShortTy;
   case BuiltinType::UInt:
     return IntTy;
   case BuiltinType::ULong:
     return LongTy;
   case BuiltinType::ULongLong:
     return LongLongTy;
   case BuiltinType::UInt128:
     return Int128Ty;
   // wchar_t is special. It is either unsigned or not, but when it's unsigned,
   // there's no matching "signed wchar_t". Therefore we return the signed
-  // version of it's underlying type instead.
+  // version of its underlying type instead.
   case BuiltinType::WChar_U:
     return getSignedWCharType();
 
   case BuiltinType::UShortAccum:
     return ShortAccumTy;
   case BuiltinType::UAccum:
     return AccumTy;
   case BuiltinType::ULongAccum:
case BuiltinType::ULongFract:
     return LongFractTy;
   case BuiltinType::SatUShortFract:
     return SatShortFractTy;
   case BuiltinType::SatUFract:
     return SatFractTy;
   case BuiltinType::SatULongFract:
     return SatLongFractTy;
   default:
-    llvm_unreachable("Unexpected unsigned integer or fixed point type");
+    assert(
+        (T->hasSignedIntegerRepresentation() || T->isSignedFixedPointType()) &&
+        "Unexpected signed integer or fixed point type");
+    return T;
   }
 }
 
 ASTMutationListener::~ASTMutationListener() = default;
 
 void ASTMutationListener::DeducedReturnType(const FunctionDecl *FD,
                                             QualType ReturnType) {}
 

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';
+    Out << "u";
 
+    StringRef BuiltinName;
     switch (T->getUTTKind()) {
-      case UnaryTransformType::EnumUnderlyingType:
-        Out << "3eut";
-        break;
+#define TRANSFORM_TYPE_TRAIT_DEF(Enum, Trait)                                  \
+  case UnaryTransformType::Enum:                                               \
+    BuiltinName = "__" #Trait;                                                 \
+#include "clang/Basic/TransformTypeTraits.def"
     }
+    Out << BuiltinName.size() << BuiltinName;
   }
 
+  Out << "I";
   mangleType(T->getBaseType());
+  Out << "E";
 }
 
 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

 #include "clang/AST/JSONNodeDumper.h"
+#include "clang/AST/Type.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Basic/Specifiers.h"
 #include "clang/Lex/Lexer.h"
 #include "llvm/ADT/StringSwitch.h"
 
 using namespace clang;
 
 void JSONNodeDumper::addPreviousDeclaration(const Decl *D) {

 }
 
 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");
+#define TRANSFORM_TYPE_TRAIT_DEF(Enum, Trait)                                  \
+  case UnaryTransformType::Enum:                                               \
+    JOS.attribute("transformKind", #Trait);                                    \
     break;
+#include "clang/Basic/TransformTypeTraits.def"
   }
 }
 
 void JSONNodeDumper::VisitTagType(const TagType *TT) {
   JOS.attribute("decl", createBareDeclRef(TT->getDecl()));
 }
 
 void JSONNodeDumper::VisitTemplateTypeParmType(
     const TemplateTypeParmType *TTPT) {

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";
+#define TRANSFORM_TYPE_TRAIT_DEF(Enum, Trait)                                  \
+  case UnaryTransformType::Enum:                                               \
+    OS << " " #Trait;                                                          \
     break;
+#include "clang/Basic/TransformTypeTraits.def"
   }
 }
 
 void TextNodeDumper::VisitTagType(const TagType *T) {
   dumpDeclRef(T->getDecl());
 }
 
 void TextNodeDumper::VisitTemplateTypeParmType(const TemplateTypeParmType *T) {
   OS << " depth " << T->getDepth() << " index " << T->getIndex();

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(";
-      print(T->getBaseType(), OS, StringRef());
-      OS << ')';
-      spaceBeforePlaceHolder(OS);
-      return;
-  }
-
-  printBefore(T->getBaseType(), OS);
+  static llvm::DenseMap<int, const char *> Transformation = {{
+#define TRANSFORM_TYPE_TRAIT_DEF(Enum, Trait)                                  \
+  {UnaryTransformType::Enum, "__" #Trait},
+#include "clang/Basic/TransformTypeTraits.def"
+  }};
+  OS << Transformation[T->getUTTKind()] << '(';
 }
 
 void TypePrinter::printUnaryTransformAfter(const UnaryTransformType *T,
-                                           raw_ostream &OS) {
-  IncludeStrongLifetimeRAII Strong(Policy);
-
-  switch (T->getUTTKind()) {
-    case UnaryTransformType::EnumUnderlyingType:
-      return;
-  }
-
-  printAfter(T->getBaseType(), OS);
-}
+                                           raw_ostream &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()) {
       // FIXME: Track a TypeConstraint as type sugar, so that we can print the

clang/lib/Format/FormatToken.h

bool isFunctionLikeKeyword() const {
     case tok::kw_sizeof:
     case tok::kw_alignof:
     case tok::kw_alignas:
     case tok::kw_decltype:
     case tok::kw_noexcept:
     case tok::kw_static_assert:
     case tok::kw__Atomic:
     case tok::kw___attribute:
-    case tok::kw___underlying_type:
+#define TRANSFORM_TYPE_TRAIT_DEF(_, Trait) case tok::kw___##Trait:
+#include "clang/Basic/TransformTypeTraits.def"
     case tok::kw_requires:
       return true;
     default:
       return false;
     }
   }
 
   /// Returns \c true if this is a string literal that's like a label,

clang/lib/Format/FormatToken.cpp

bool FormatToken::isSimpleTypeSpecifier() const {
   case tok::kw_float:
   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:
+#define TRANSFORM_TYPE_TRAIT_DEF(_, Trait) case tok::kw___##Trait:
+#include "clang/Basic/TransformTypeTraits.def"
   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/Format/TokenAnnotator.cpp

bool parseParens(bool LookForDecls = false) {
     }
 
     // Infer the role of the l_paren based on the previous token if we haven't
     // detected one one yet.
     if (PrevNonComment && OpeningParen.is(TT_Unknown)) {
       if (PrevNonComment->is(tok::kw___attribute)) {
         OpeningParen.setType(TT_AttributeParen);
       } else if (PrevNonComment->isOneOf(TT_TypenameMacro, tok::kw_decltype,
-                                         tok::kw_typeof, tok::kw__Atomic,
-                                         tok::kw___underlying_type)) {
+                                         tok::kw_typeof,
+#define TRANSFORM_TYPE_TRAIT_DEF(_, Trait) tok::kw___##Trait,
+#include "clang/Basic/TransformTypeTraits.def"
+                                         tok::kw__Atomic)) {
         OpeningParen.setType(TT_TypeDeclarationParen);
         // decltype() and typeof() usually contain expressions.
         if (PrevNonComment->isOneOf(tok::kw_decltype, tok::kw_typeof))
           Contexts.back().IsExpression = true;
       }
     }
 
     if (StartsObjCMethodExpr) {

clang/lib/Lex/PPMacroExpansion.cpp

EvaluateFeatureLikeBuiltinMacro(OS, Tok, II, *this, false,
           if (II->getName().startswith("__builtin_") ||
               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)
+#define TRANSFORM_TYPE_TRAIT_DEF(_, Trait) .Case("__" #Trait, true)
+#include "clang/Basic/TransformTypeTraits.def"
               .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: {
+    case tok::identifier:
+    ParseIdentifier: {
       // 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
case tok::annot_template_id: {
                 << FixItHint::CreateReplacement(SourceRange(AutoLoc,
                                                             Tok.getLocation()),
                                                 "auto");
             } else {
               Tracker.consumeClose();
             }
           }
           ConsumedEnd = Tok.getLocation();
-          DS.setTypeofParensRange(Tracker.getRange());
+          DS.setTypeArgumentRange(Tracker.getRange());
           // Even if something went wrong above, continue as if we've seen
           // `decltype(auto)`.
           isInvalid = DS.SetTypeSpecType(TST_decltype_auto, Loc, PrevSpec,
                                          DiagID, TemplateId, Policy);
         } else {
           isInvalid = DS.SetTypeSpecType(TST_auto, AutoLoc, PrevSpec, DiagID,
                                          TemplateId, Policy);
         }
#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);
+#define TRANSFORM_TYPE_TRAIT_DEF(_, Trait) case tok::kw___##Trait:
+#include "clang/Basic/TransformTypeTraits.def"
+      // HACK: libstdc++ already uses '__remove_cv' as an alias template so we
+      // work around this by expecting all transform type traits to be suffixed
+      // with '('. They're an identifier otherwise.
+      if (!MaybeParseTypeTransformTypeSpecifier(DS))
+        goto ParseIdentifier;
       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)) {

 /// [C2x]   attributes-specifier-seq[opt]
 ///           specifier-qualifier-list struct-declarator-list
 /// [GNU]   __extension__ struct-declaration
 /// [GNU]   specifier-qualifier-list
 ///       struct-declarator-list:
 ///         struct-declarator
 ///         struct-declarator-list ',' struct-declarator
 /// [GNU]   struct-declarator-list ',' attributes[opt] struct-declarator
 ///       struct-declarator:
 ///         declarator
 /// [GNU]   declarator attributes[opt]
 ///         declarator[opt] ':' constant-expression
 /// [GNU]   declarator[opt] ':' constant-expression attributes[opt]
 ///
 void Parser::ParseStructDeclaration(
     ParsingDeclSpec &DS,
     llvm::function_ref<void(ParsingFieldDeclarator &)> FieldsCallback) {
 
   if (Tok.is(tok::kw___extension__)) {
     // __extension__ silences extension warnings in the subexpression.
     ExtensionRAIIObject O(Diags);  // Use RAII to do this.
     ConsumeToken();
     return ParseStructDeclaration(DS, FieldsCallback);
   }
 
   // Parse leading attributes.
   ParsedAttributes Attrs(AttrFactory);
   MaybeParseCXX11Attributes(Attrs);
 
   // Parse the common specifier-qualifiers-list piece.
   ParseSpecifierQualifierList(DS);
 
   // If there are no declarators, this is a free-standing declaration
   // specifier. Let the actions module cope with it.
   if (Tok.is(tok::semi)) {
     // C2x 6.7.2.1p9 : "The optional attribute specifier sequence in a
     // member declaration appertains to each of the members declared by the
     // member declarator list; it shall not appear if the optional member
     // declarator list is omitted."
     ProhibitAttributes(Attrs);
     RecordDecl *AnonRecord = nullptr;
     Decl *TheDecl = Actions.ParsedFreeStandingDeclSpec(
         getCurScope(), AS_none, DS, ParsedAttributesView::none(), AnonRecord);
     assert(!AnonRecord && "Did not expect anonymous struct or union here");
     DS.complete(TheDecl);
     return;
   }
 
   // Read struct-declarators until we find the semicolon.
EnterExpressionEvaluationContext Unevaluated(
       Sema::ReuseLambdaContextDecl);
 
   bool isCastExpr;
   ParsedType CastTy;
   SourceRange CastRange;
   ExprResult Operand = Actions.CorrectDelayedTyposInExpr(
       ParseExprAfterUnaryExprOrTypeTrait(OpTok, isCastExpr, CastTy, CastRange));
   if (hasParens)
-    DS.setTypeofParensRange(CastRange);
+    DS.setTypeArgumentRange(CastRange);
 
   if (CastRange.getEnd().isInvalid())
     // FIXME: Not accurate, the range gets one token more than it should.
     DS.SetRangeEnd(Tok.getLocation());
   else
     DS.SetRangeEnd(CastRange.getEnd());
 
   if (isCastExpr) {
void Parser::ParseAtomicSpecifier(DeclSpec &DS) {
   }
 
   // Match the ')'
   T.consumeClose();
 
   if (T.getCloseLocation().isInvalid())
     return;
 
-  DS.setTypeofParensRange(T.getRange());
+  DS.setTypeArgumentRange(T.getRange());
   DS.SetRangeEnd(T.getCloseLocation());
 
   const char *PrevSpec = nullptr;
   unsigned DiagID;
   if (DS.SetTypeSpecType(DeclSpec::TST_atomic, StartLoc, PrevSpec,
                          DiagID, Result.get(),
                          Actions.getASTContext().getPrintingPolicy()))
     Diag(StartLoc, DiagID) << PrevSpec;

clang/lib/Parse/ParseDeclCXX.cpp

 #include "clang/AST/ASTContext.h"
 #include "clang/AST/DeclTemplate.h"
 #include "clang/AST/PrettyDeclStackTrace.h"
 #include "clang/Basic/AttributeCommonInfo.h"
 #include "clang/Basic/Attributes.h"
 #include "clang/Basic/CharInfo.h"
 #include "clang/Basic/OperatorKinds.h"
 #include "clang/Basic/TargetInfo.h"
+#include "clang/Basic/TokenKinds.h"
 #include "clang/Parse/ParseDiagnostic.h"
 #include "clang/Parse/Parser.h"
 #include "clang/Parse/RAIIObjectsForParser.h"
 #include "clang/Sema/DeclSpec.h"
 #include "clang/Sema/ParsedTemplate.h"
 #include "clang/Sema/Scope.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/Support/TimeProfiler.h"
SourceLocation Parser::ParseDecltypeSpecifier(DeclSpec &DS) {
   SourceLocation StartLoc = Tok.getLocation();
   SourceLocation EndLoc;
 
   if (Tok.is(tok::annot_decltype)) {
     Result = getExprAnnotation(Tok);
     EndLoc = Tok.getAnnotationEndLoc();
     // Unfortunately, we don't know the LParen source location as the annotated
     // token doesn't have it.
-    DS.setTypeofParensRange(SourceRange(SourceLocation(), EndLoc));
+    DS.setTypeArgumentRange(SourceRange(SourceLocation(), EndLoc));
     ConsumeAnnotationToken();
     if (Result.isInvalid()) {
       DS.SetTypeSpecError();
       return EndLoc;
     }
   } else {
     if (Tok.getIdentifierInfo()->isStr("decltype"))
       Diag(Tok, diag::warn_cxx98_compat_decltype);
if (Tok.is(tok::kw_auto) && NextToken().is(tok::r_paren)) {
         return EndLoc;
       }
 
       Result = Actions.ActOnDecltypeExpression(Result.get());
     }
 
     // Match the ')'
     T.consumeClose();
-    DS.setTypeofParensRange(T.getRange());
+    DS.setTypeArgumentRange(T.getRange());
     if (T.getCloseLocation().isInvalid()) {
       DS.SetTypeSpecError();
       // FIXME: this should return the location of the last token
       //        that was consumed (by "consumeClose()")
       return T.getCloseLocation();
     }
 
     if (Result.isInvalid()) {
setExprAnnotation(Tok,
                     DS.getTypeSpecType() == TST_decltype ? DS.getRepAsExpr()
                     : DS.getTypeSpecType() == TST_decltype_auto ? ExprResult()
                                                                 : ExprError());
   Tok.setAnnotationEndLoc(EndLoc);
   Tok.setLocation(StartLoc);
   PP.AnnotateCachedTokens(Tok);
 }
 
-void Parser::ParseUnderlyingTypeSpecifier(DeclSpec &DS) {
-  assert(Tok.is(tok::kw___underlying_type) &&
-         "Not an underlying type specifier");
+DeclSpec::TST Parser::TypeTransformTokToDeclSpec() {
+  switch (Tok.getKind()) {
+#define TRANSFORM_TYPE_TRAIT_DEF(_, Trait)                                     \
+  case tok::kw___##Trait:                                                      \
+    return DeclSpec::TST_##Trait;
+#include "clang/Basic/TransformTypeTraits.def"
+  default:
+    llvm_unreachable("passed in an unhandled type transformation built-in");
+  }
+}
 
+bool Parser::MaybeParseTypeTransformTypeSpecifier(DeclSpec &DS) {
+  if (!NextToken().is(tok::l_paren)) {
+    Tok.setKind(tok::identifier);
+    return false;
+  }
+  DeclSpec::TST TypeTransformTST = TypeTransformTokToDeclSpec();
   SourceLocation StartLoc = ConsumeToken();
+
   BalancedDelimiterTracker T(*this, tok::l_paren);
-  if (T.expectAndConsume(diag::err_expected_lparen_after, "__underlying_type",
-                         tok::r_paren)) {
-    return;
-  }
+  if (T.expectAndConsume(diag::err_expected_lparen_after, Tok.getName(),
+                         tok::r_paren))
+    return true;
 
   TypeResult Result = ParseTypeName();
   if (Result.isInvalid()) {
     SkipUntil(tok::r_paren, StopAtSemi);
-    return;
+    return true;
   }
 
-  // Match the ')'
   T.consumeClose();
   if (T.getCloseLocation().isInvalid())
-    return;
+    return true;
 
   const char *PrevSpec = nullptr;
   unsigned DiagID;
-  if (DS.SetTypeSpecType(DeclSpec::TST_underlyingType, StartLoc, PrevSpec,
-                         DiagID, Result.get(),
+  if (DS.SetTypeSpecType(TypeTransformTST, StartLoc, PrevSpec, DiagID,
+                         Result.get(),
                          Actions.getASTContext().getPrintingPolicy()))
     Diag(StartLoc, DiagID) << PrevSpec;
-  DS.setTypeofParensRange(T.getRange());
+  DS.setTypeArgumentRange(T.getRange());
+  return true;
 }
 
 /// ParseBaseTypeSpecifier - Parse a C++ base-type-specifier which is either a
 /// class name or decltype-specifier. Note that we only check that the result
 /// names a type; semantic analysis will need to verify that the type names a
 /// class. The result is either a type or null, depending on whether a type
 /// name was found.
 ///
void Parser::ParseClassSpecifier(tok::TokenKind TagTokKind,
 
   // 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,
+#define TRANSFORM_TYPE_TRAIT_DEF(_, Trait) tok::kw___##Trait,
+#include "clang/Basic/TransformTypeTraits.def"
+          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_trivially_constructible,
+          tok::kw___is_trivially_copyable,
+          tok::kw___is_union,
+          tok::kw___is_unsigned,
+          tok::kw___is_void,
           tok::kw___is_volatile))
     // 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);
 

clang/lib/Parse/ParseExpr.cpp

ExprResult Parser::ParseCastExpression(CastParseKind ParseKind,
   case tok::kw___super:
   case tok::kw_decltype:
     // Annotate the token and tail recurse.
     if (TryAnnotateTypeOrScopeToken())
       return ExprError();
     assert(Tok.isNot(tok::kw_decltype) && Tok.isNot(tok::kw___super));
     return ParseCastExpression(ParseKind, isAddressOfOperand, isTypeCast,
                                isVectorLiteral, NotPrimaryExpression);
 
-  case tok::identifier: {      // primary-expression: identifier
-                               // unqualified-id: identifier
-                               // constant: enumeration-constant
+  case tok::identifier:
+  ParseIdentifier: {    // primary-expression: identifier
     // Turn a potentially qualified name into a annot_typename or
     // annot_cxxscope if it would be valid.  This handles things like x::y, etc.
     if (getLangOpts().CPlusPlus) {
       // Avoid the unnecessary parse-time lookup in the common case
       // where the syntax forbids a type.
       const Token &Next = NextToken();
 
       // If this identifier was reverted from a token ID, and the next token
       // is a parenthesis, this is likely to be a use of a type trait. Check
       // those tokens.
       if (Next.is(tok::l_paren) &&
           Tok.is(tok::identifier) &&
           Tok.getIdentifierInfo()->hasRevertedTokenIDToIdentifier()) {
         IdentifierInfo *II = Tok.getIdentifierInfo();
         // Build up the mapping of revertible type traits, for future use.
         if (RevertibleTypeTraits.empty()) {
 #define RTT_JOIN(X,Y) X##Y
 #define REVERTIBLE_TYPE_TRAIT(Name)                         \
           RevertibleTypeTraits[PP.getIdentifierInfo(#Name)] \
             = RTT_JOIN(tok::kw_,Name)
 
           REVERTIBLE_TYPE_TRAIT(__is_abstract);
           REVERTIBLE_TYPE_TRAIT(__is_aggregate);
           REVERTIBLE_TYPE_TRAIT(__is_arithmetic);
           REVERTIBLE_TYPE_TRAIT(__is_array);
           REVERTIBLE_TYPE_TRAIT(__is_assignable);
           REVERTIBLE_TYPE_TRAIT(__is_base_of);
           REVERTIBLE_TYPE_TRAIT(__is_class);
           REVERTIBLE_TYPE_TRAIT(__is_complete_type);
           REVERTIBLE_TYPE_TRAIT(__is_compound);
           REVERTIBLE_TYPE_TRAIT(__is_const);
#define REVERTIBLE_TYPE_TRAIT(Name)                         \
           REVERTIBLE_TYPE_TRAIT(__is_trivial);
           REVERTIBLE_TYPE_TRAIT(__is_trivially_assignable);
           REVERTIBLE_TYPE_TRAIT(__is_trivially_constructible);
           REVERTIBLE_TYPE_TRAIT(__is_trivially_copyable);
           REVERTIBLE_TYPE_TRAIT(__is_union);
           REVERTIBLE_TYPE_TRAIT(__is_unsigned);
           REVERTIBLE_TYPE_TRAIT(__is_void);
           REVERTIBLE_TYPE_TRAIT(__is_volatile);
+#define TRANSFORM_TYPE_TRAIT_DEF(_, Trait)                                     \
+  REVERTIBLE_TYPE_TRAIT(RTT_JOIN(__, Trait));
+#include "clang/Basic/TransformTypeTraits.def"
 #undef REVERTIBLE_TYPE_TRAIT
 #undef RTT_JOIN
         }
 
         // If we find that this is in fact the name of a type trait,
         // update the token kind in place and parse again to treat it as
         // the appropriate kind of type trait.
         llvm::SmallDenseMap<IdentifierInfo *, tok::TokenKind>::iterator Known
case tok::caret:
     Res = ParseBlockLiteralExpression();
     break;
   case tok::code_completion: {
     cutOffParsing();
     Actions.CodeCompleteExpression(getCurScope(),
                                    PreferredType.get(Tok.getLocation()));
     return ExprError();
   }
+#define TRANSFORM_TYPE_TRAIT_DEF(_, Trait) case tok::kw___##Trait:
+#include "clang/Basic/TransformTypeTraits.def"
+    // HACK: libstdc++ uses some of the transform-type-traits as alias
+    // templates, so we need to work around this.
+    if (!NextToken().is(tok::l_paren)) {
+      Tok.setKind(tok::identifier);
+      Diag(Tok, diag::ext_keyword_as_ident)
+          << Tok.getIdentifierInfo()->getName() << 0;
+      goto ParseIdentifier;
+    }
+    goto ExpectedExpression;
   case tok::l_square:
     if (getLangOpts().CPlusPlus11) {
       if (getLangOpts().ObjC) {
         // C++11 lambda expressions and Objective-C message sends both start with a
         // square bracket.  There are three possibilities here:
         // we have a valid lambda expression, we have an invalid lambda
         // expression, or we have something that doesn't appear to be a lambda.
         // If we're in the last case, we fall back to ParseObjCMessageExpression.
if (getLangOpts().CPlusPlus11) {
       break;
     }
     if (getLangOpts().ObjC) {
       Res = ParseObjCMessageExpression();
       break;
     }
     [[fallthrough]];
   default:
+  ExpectedExpression:
     NotCastExpr = true;
     return ExprError();
   }
 
   // Check to see whether Res is a function designator only. If it is and we
   // are compiling for OpenCL, we need to return an error as this implies
   // that the address of the function is being taken, which is illegal in CL.
 

clang/lib/Parse/ParseExprCXX.cpp

 //===--- ParseExprCXX.cpp - C++ Expression Parsing ------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the Expression parsing implementation for C++.
 //
 //===----------------------------------------------------------------------===//
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/Decl.h"
 #include "clang/AST/DeclTemplate.h"
 #include "clang/AST/ExprCXX.h"
 #include "clang/Basic/PrettyStackTrace.h"
+#include "clang/Basic/TokenKinds.h"
 #include "clang/Lex/LiteralSupport.h"
 #include "clang/Parse/ParseDiagnostic.h"
 #include "clang/Parse/Parser.h"
 #include "clang/Parse/RAIIObjectsForParser.h"
 #include "clang/Sema/DeclSpec.h"
 #include "clang/Sema/ParsedTemplate.h"
 #include "clang/Sema/Scope.h"
+#include "llvm/Support/Compiler.h"
 #include "llvm/Support/ErrorHandling.h"
 #include <numeric>
 
 using namespace clang;
 
 static int SelectDigraphErrorMessage(tok::TokenKind Kind) {
   switch (Kind) {
     // template name
if (TemplateKWLoc && (ObjectType || SS.isSet())) {
         << FixItHint::CreateRemoval(TemplateLoc);
     }
   }
 
   // unqualified-id:
   //   identifier
   //   template-id (when it hasn't already been annotated)
   if (Tok.is(tok::identifier)) {
+  ParseIdentifier:
     // Consume the identifier.
     IdentifierInfo *Id = Tok.getIdentifierInfo();
     SourceLocation IdLoc = ConsumeToken();
 
     if (!getLangOpts().CPlusPlus) {
       // If we're not in C++, only identifiers matter. Record the
       // identifier and return.
       Result.setIdentifier(Id, IdLoc);
ParsedType Ty = Actions.getDestructorName(TildeLoc, *ClassName,
                                               EnteringContext);
     if (!Ty)
       return true;
 
     Result.setDestructorName(TildeLoc, Ty, ClassNameLoc);
     return false;
   }
 
-  Diag(Tok, diag::err_expected_unqualified_id)
-    << getLangOpts().CPlusPlus;
+  switch (Tok.getKind()) {
+#define TRANSFORM_TYPE_TRAIT_DEF(_, Trait) case tok::kw___##Trait:
+#include "clang/Basic/TransformTypeTraits.def"
+    if (!NextToken().is(tok::l_paren)) {
+      Tok.setKind(tok::identifier);
+      Diag(Tok, diag::ext_keyword_as_ident)
+          << Tok.getIdentifierInfo()->getName() << 0;
+      goto ParseIdentifier;
+    }
+    LLVM_FALLTHROUGH;
+  default:
+    Diag(Tok, diag::err_expected_unqualified_id) << getLangOpts().CPlusPlus;
     return true;
   }
+}
 
 /// ParseCXXNewExpression - Parse a C++ new-expression. New is used to allocate
 /// memory in a typesafe manner and call constructors.
 ///
 /// This method is called to parse the new expression after the optional :: has
 /// been already parsed.  If the :: was present, "UseGlobal" is true and "Start"
 /// is its location.  Otherwise, "Start" is the location of the 'new' token.
 ///

clang/lib/Parse/ParseStmt.cpp

 //===--- ParseStmt.cpp - Statement and Block Parser -----------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the Statement and Block portions of the Parser
 // interface.
 //
 //===----------------------------------------------------------------------===//
 
 #include "clang/AST/PrettyDeclStackTrace.h"
 #include "clang/Basic/Attributes.h"
 #include "clang/Basic/PrettyStackTrace.h"
+#include "clang/Basic/TokenKinds.h"
 #include "clang/Parse/LoopHint.h"
 #include "clang/Parse/Parser.h"
 #include "clang/Parse/RAIIObjectsForParser.h"
 #include "clang/Sema/DeclSpec.h"
 #include "clang/Sema/Scope.h"
 #include "clang/Sema/TypoCorrection.h"
 #include "llvm/ADT/STLExtras.h"
 
case tok::at: // May be a @try or @throw statement
       return ParseObjCAtStatement(AtLoc, StmtCtx);
     }
 
   case tok::code_completion:
     cutOffParsing();
     Actions.CodeCompleteOrdinaryName(getCurScope(), Sema::PCC_Statement);
     return StmtError();
 
-  case tok::identifier: {
+  case tok::identifier:
+  ParseIdentifier: {
     Token Next = NextToken();
     if (Next.is(tok::colon)) { // C99 6.8.1: labeled-statement
       // Both C++11 and GNU attributes preceding the label appertain to the
       // label, so put them in a single list to pass on to
       // ParseLabeledStatement().
       ParsedAttributes Attrs(AttrFactory);
       takeAndConcatenateAttrs(CXX11Attrs, GNUAttrs, Attrs);
 
       // identifier ':' statement
if ((getLangOpts().CPlusPlus || getLangOpts().MicrosoftExt ||
       return Actions.ActOnDeclStmt(Decl, DeclStart, DeclEnd);
     }
 
     if (Tok.is(tok::r_brace)) {
       Diag(Tok, diag::err_expected_statement);
       return StmtError();
     }
 
+    switch (Tok.getKind()) {
+#define TRANSFORM_TYPE_TRAIT_DEF(_, Trait) case tok::kw___##Trait:
+#include "clang/Basic/TransformTypeTraits.def"
+      if (NextToken().is(tok::less)) {
+        Tok.setKind(tok::identifier);
+        Diag(Tok, diag::ext_keyword_as_ident)
+            << Tok.getIdentifierInfo()->getName() << 0;
+        goto ParseIdentifier;
+      }
+      LLVM_FALLTHROUGH;
+    default:
       return ParseExprStatement(StmtCtx);
     }
+  }
 
   case tok::kw___attribute: {
     GNUAttributeLoc = Tok.getLocation();
     ParseGNUAttributes(GNUAttrs);
     goto Retry;
   }
 
   case tok::kw_case:                // C99 6.8.1: labeled-statement

clang/lib/Parse/ParseTentative.cpp

Parser::TPResult Parser::TryConsumeDeclarationSpecifier() {
   case tok::kw__Atomic:
     if (NextToken().isNot(tok::l_paren)) {
       ConsumeToken();
       break;
     }
     [[fallthrough]];
   case tok::kw_typeof:
   case tok::kw___attribute:
-  case tok::kw___underlying_type: {
+#define TRANSFORM_TYPE_TRAIT_DEF(_, Trait) case tok::kw___##Trait:
+#include "clang/Basic/TransformTypeTraits.def"
+  {
     ConsumeToken();
     if (Tok.isNot(tok::l_paren))
       return TPResult::Error;
     ConsumeParen();
     if (!SkipUntil(tok::r_paren))
       return TPResult::Error;
     break;
   }
if (isFollowedByParen)
       return TPResult::Ambiguous;
 
     if (getLangOpts().CPlusPlus11 && isFollowedByBrace)
       return BracedCastResult;
 
     return TPResult::True;
   }
 
-  // C++0x type traits support
-  case tok::kw___underlying_type:
+#define TRANSFORM_TYPE_TRAIT_DEF(_, Trait) case tok::kw___##Trait:
+#include "clang/Basic/TransformTypeTraits.def"
     return TPResult::True;
 
   // C11 _Atomic
   case tok::kw__Atomic:
     return TPResult::True;
 
   case tok::kw__BitInt:
   case tok::kw__ExtInt: {

 
 bool Parser::isCXXDeclarationSpecifierAType() {
   switch (Tok.getKind()) {
     // typename-specifier
   case tok::annot_decltype:
   case tok::annot_template_id:
   case tok::annot_typename:
   case tok::kw_typeof:
-  case tok::kw___underlying_type:
+#define TRANSFORM_TYPE_TRAIT_DEF(_, Trait) case tok::kw___##Trait:
+#include "clang/Basic/TransformTypeTraits.def"
     return true;
 
     // elaborated-type-specifier
   case tok::kw_class:
   case tok::kw_struct:
   case tok::kw_union:
   case tok::kw___interface:
   case tok::kw_enum:

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;
case TST_decltype_auto:
       return false;
 
     case TST_decltype:
     case TST_typeofExpr:
       if (Expr *E = DS.getRepAsExpr())
         return E->getType()->isFunctionType();
       return false;
 
-    case TST_underlyingType:
+#define TRANSFORM_TYPE_TRAIT_DEF(_, Trait) case TST_##Trait:
+#include "clang/Basic/TransformTypeTraits.def"
     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";
+#define TRANSFORM_TYPE_TRAIT_DEF(_, Trait)                                     \
+  case DeclSpec::TST_##Trait:                                                  \
+    return "__" #Trait;
+#include "clang/Basic/TransformTypeTraits.def"
   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_float:
   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:
+#define TRANSFORM_TYPE_TRAIT_DEF(_, Trait) case tok::kw___##Trait:
+#include "clang/Basic/TransformTypeTraits.def"
   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,
   // Of course, we also need to rebuild any type referencing such a
   // 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:
+#define TRANSFORM_TYPE_TRAIT_DEF(_, Trait) case DeclSpec::TST_##Trait:
+#include "clang/Basic/TransformTypeTraits.def"
   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

Optional<unsigned> Sema::getNumArgumentsInExpansion(QualType T,
   return Result;
 }
 
 bool Sema::containsUnexpandedParameterPacks(Declarator &D) {
   const DeclSpec &DS = D.getDeclSpec();
   switch (DS.getTypeSpecType()) {
   case TST_typename:
   case TST_typeofType:
-  case TST_underlyingType:
+#define TRANSFORM_TYPE_TRAIT_DEF(_, Trait) case TST_##Trait:
+#include "clang/Basic/TransformTypeTraits.def"
   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/SourceLocation.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"
 #include "clang/Sema/Template.h"
 #include "clang/Sema/TemplateInstCallback.h"
+#include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/Support/ErrorHandling.h"
 #include <bitset>
 
 using namespace clang;

 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) {
+#define TRANSFORM_TYPE_TRAIT_DEF(Enum, Trait)                                  \
+  case TST_##Trait:                                                            \
+    return UnaryTransformType::Enum;
+#include "clang/Basic/TransformTypeTraits.def"
+  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: {
     // TypeQuals handled by caller.
     Result = S.BuildDecltypeType(E);
     if (Result.isNull()) {
       Result = Context.IntTy;
       declarator.setInvalidType(true);
     }
     break;
   }
-  case DeclSpec::TST_underlyingType:
+#define TRANSFORM_TYPE_TRAIT_DEF(_, Trait) case DeclSpec::TST_##Trait:
+#include "clang/Basic/TransformTypeTraits.def"
     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()) {
       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.setUnderlyingTInfo(TInfo);
     }
     void VisitDecltypeTypeLoc(DecltypeTypeLoc TL) {
       assert(DS.getTypeSpecType() == DeclSpec::TST_decltype);
       TL.setDecltypeLoc(DS.getTypeSpecTypeLoc());
       TL.setRParenLoc(DS.getTypeofParensRange().getEnd());
     }
     void VisitUnaryTransformTypeLoc(UnaryTransformTypeLoc TL) {
-      // FIXME: This holds only because we only have one unary transform.
-      assert(DS.getTypeSpecType() == DeclSpec::TST_underlyingType);
+      assert(DS.isTransformTypeTrait(DS.getTypeSpecType()));
       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) {
       // By default, use the source location of the type specifier.
       TL.setBuiltinLoc(DS.getTypeSpecTypeLoc());
if (AsUnevaluated && CodeSynthesisContexts.empty() &&
     // context, so side effects could result in unintended consequences.
     // Exclude instantiation-dependent expressions, because 'decltype' is often
     // used to build SFINAE gadgets.
     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) {
-  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();
-        }
+static QualType GetEnumUnderlyingType(Sema &S, QualType BaseType,
+  assert(BaseType->isEnumeralType());
+  EnumDecl *ED = BaseType->castAs<EnumType>()->getDecl();
+  assert(ED && "EnumType has no EnumDecl");
+
+  S.DiagnoseUseOfDecl(ED, Loc);
+
+  QualType Underlying = ED->getIntegerType();
+  assert(!Underlying.isNull());
+
+  return Underlying;
+}
+
+QualType Sema::BuiltinEnumUnderlyingType(QualType BaseType,
+                                         SourceLocation Loc) {
+  if (!BaseType->isEnumeralType()) {
+  }
+
 
-        EnumDecl *ED = BaseType->castAs<EnumType>()->getDecl();
-        assert(ED && "EnumType has no EnumDecl");
+  return GetEnumUnderlyingType(*this, BaseType, Loc);
+}
 
-        DiagnoseUseOfDecl(ED, Loc);
+QualType Sema::BuiltinAddPointer(QualType BaseType, SourceLocation Loc) {
+  QualType Pointer = BaseType.isReferenceable() || BaseType->isVoidType()
+                         ? BuildPointerType(BaseType.getNonReferenceType(), Loc,
+                                            DeclarationName())
+                         : BaseType;
 
-        Underlying = ED->getIntegerType();
-        assert(!Underlying.isNull());
-      }
-      return Context.getUnaryTransformType(BaseType, Underlying,
-                                        UnaryTransformType::EnumUnderlyingType);
-    }
+  return Pointer.isNull() ? QualType() : Pointer;
+}
+
+QualType Sema::BuiltinRemovePointer(QualType BaseType, SourceLocation Loc) {
+  // We don't want block pointers or ObjectiveC's id type.
+  if (!BaseType->isAnyPointerType() || BaseType->isObjCIdType())
+    return BaseType;
+
+  return BaseType->getPointeeType();
+}
+
+QualType Sema::BuiltinDecay(QualType BaseType, SourceLocation Loc) {
+  QualType Underlying = BaseType.getNonReferenceType();
+  if (Underlying->isArrayType())
+    return Context.getDecayedType(Underlying);
+
+  if (Underlying->isFunctionType())
+    return BuiltinAddPointer(BaseType, Loc);
+
+  SplitQualType Split = Underlying.getSplitUnqualifiedType();
+  // std::decay is supposed to produce 'std::remove_cv', but since 'restrict' is
+  // in the same group of qualifiers as 'const' and 'volatile', we're extending
+  // '__decay(T)' so that it removes all qualifiers.
+  Split.Quals.removeCVRQualifiers();
+  return Context.getQualifiedType(Split);
+}
+
+QualType Sema::BuiltinAddReference(QualType BaseType, UTTKind UKind,
+                                   SourceLocation Loc) {
+  assert(LangOpts.CPlusPlus);
+  QualType Reference =
+      BaseType.isReferenceable()
+          ? BuildReferenceType(BaseType,
+                               UKind == UnaryTransformType::AddLvalueReference,
+                               Loc, DeclarationName())
+          : BaseType;
+  return Reference.isNull() ? QualType() : Reference;
+}
+
+QualType Sema::BuiltinRemoveExtent(QualType BaseType, UTTKind UKind,
+                                   SourceLocation Loc) {
+  if (UKind == UnaryTransformType::RemoveAllExtents)
+    return Context.getBaseElementType(BaseType);
+
+  if (const auto *AT = Context.getAsArrayType(BaseType))
+    return AT->getElementType();
+
+  return BaseType;
+}
+
+QualType Sema::BuiltinRemoveReference(QualType BaseType, UTTKind UKind,
+                                      SourceLocation Loc) {
+  assert(LangOpts.CPlusPlus);
+  QualType T = BaseType.getNonReferenceType();
+  if (UKind == UTTKind::RemoveCVRef &&
+      (T.isConstQualified() || T.isVolatileQualified())) {
+    Qualifiers Quals;
+    QualType Unqual = Context.getUnqualifiedArrayType(T, Quals);
+    Quals.removeConst();
+    Quals.removeVolatile();
+    T = Context.getQualifiedType(Unqual, Quals);
+  }
+  return T;
+}
+
+QualType Sema::BuiltinChangeCVRQualifiers(QualType BaseType, UTTKind UKind,
+                                          SourceLocation Loc) {
+  if ((BaseType->isReferenceType() && UKind != UTTKind::RemoveRestrict) ||
+      BaseType->isFunctionType())
+    return BaseType;
+
+  Qualifiers Quals;
+  QualType Unqual = Context.getUnqualifiedArrayType(BaseType, Quals);
+
+  if (UKind == UTTKind::RemoveConst || UKind == UTTKind::RemoveCV)
+    Quals.removeConst();
+  if (UKind == UTTKind::RemoveVolatile || UKind == UTTKind::RemoveCV)
+    Quals.removeVolatile();
+  if (UKind == UTTKind::RemoveRestrict)
+    Quals.removeRestrict();
+
+  return Context.getQualifiedType(Unqual, Quals);
+}
+
+static QualType ChangeIntegralSignedness(Sema &S, QualType BaseType,
+                                         bool IsMakeSigned,
+                                         SourceLocation Loc) {
+  if (BaseType->isEnumeralType()) {
+    QualType Underlying = GetEnumUnderlyingType(S, BaseType, Loc);
+    if (auto *BitInt = dyn_cast<BitIntType>(Underlying)) {
+      unsigned int Bits = BitInt->getNumBits();
+      if (Bits > 1)
+        return S.Context.getBitIntType(!IsMakeSigned, Bits);
+
+      S.Diag(Loc, diag::err_make_signed_integral_only)
+          << IsMakeSigned << /*_BitInt(1)*/ true << BaseType << 1 << Underlying;
+      return QualType();
+    }
+    if (Underlying->isBooleanType()) {
+      S.Diag(Loc, diag::err_make_signed_integral_only)
+          << IsMakeSigned << /*_BitInt(1)*/ false << BaseType << 1
+          << Underlying;
+      return QualType();
+    }
+  }
+
+  bool Int128Unsupported = !S.Context.getTargetInfo().hasInt128Type();
+  std::array<CanQualType *, 6> AllSignedIntegers = {
+      &S.Context.SignedCharTy, &S.Context.ShortTy,    &S.Context.IntTy,
+      &S.Context.LongTy,       &S.Context.LongLongTy, &S.Context.Int128Ty};
+  ArrayRef<CanQualType *> AvailableSignedIntegers(
+      AllSignedIntegers.data(), AllSignedIntegers.size() - Int128Unsupported);
+  std::array<CanQualType *, 6> AllUnsignedIntegers = {
+      &S.Context.UnsignedCharTy,     &S.Context.UnsignedShortTy,
+      &S.Context.UnsignedIntTy,      &S.Context.UnsignedLongTy,
+      &S.Context.UnsignedLongLongTy, &S.Context.UnsignedInt128Ty};
+  ArrayRef<CanQualType *> AvailableUnsignedIntegers(AllUnsignedIntegers.data(),
+                                                    AllUnsignedIntegers.size() -
+                                                        Int128Unsupported);
+  ArrayRef<CanQualType *> *Consider =
+      IsMakeSigned ? &AvailableSignedIntegers : &AvailableUnsignedIntegers;
+
+  uint64_t BaseSize = S.Context.getTypeSize(BaseType);
+  auto *Result =
+      llvm::find_if(*Consider, [&S, BaseSize](const CanQual<Type> *T) {
+        return BaseSize == S.Context.getTypeSize(T->getTypePtr());
+      });
+
+  assert(Result != Consider->end());
+  return QualType((*Result)->getTypePtr(), 0);
+}
+
+QualType Sema::BuiltinChangeSignedness(QualType BaseType, UTTKind UKind,
+                                       SourceLocation Loc) {
+  bool IsMakeSigned = UKind == UnaryTransformType::MakeSigned;
+  if ((!BaseType->isIntegerType() && !BaseType->isEnumeralType()) ||
+      BaseType->isBooleanType() ||
+      (BaseType->isBitIntType() &&
+       BaseType->getAs<BitIntType>()->getNumBits() < 2)) {
+    Diag(Loc, diag::err_make_signed_integral_only)
+        << IsMakeSigned << BaseType->isBitIntType() << BaseType << 0;
+    return QualType();
+  }
+
+  bool IsNonIntIntegral =
+      BaseType->isChar16Type() || BaseType->isChar32Type() ||
+      BaseType->isWideCharType() || BaseType->isEnumeralType();
+
+  QualType Underlying =
+      IsNonIntIntegral
+          ? ChangeIntegralSignedness(*this, BaseType, IsMakeSigned, Loc)
+      : IsMakeSigned ? Context.getCorrespondingSignedType(BaseType)
+                     : Context.getCorrespondingUnsignedType(BaseType);
+  if (Underlying.isNull())
+    return Underlying;
+  return Context.getQualifiedType(Underlying, BaseType.getQualifiers());
+}
+
+QualType Sema::BuildUnaryTransformType(QualType BaseType, UTTKind UKind,
+                                       SourceLocation Loc) {
+  if (BaseType->isDependentType())
+    return Context.getUnaryTransformType(BaseType, BaseType, UKind);
+  QualType Result;
+  switch (UKind) {
+  case UnaryTransformType::EnumUnderlyingType: {
+    Result = BuiltinEnumUnderlyingType(BaseType, Loc);
+    break;
+  }
+  case UnaryTransformType::AddPointer: {
+    Result = BuiltinAddPointer(BaseType, Loc);
+    break;
+  }
+  case UnaryTransformType::RemovePointer: {
+    Result = BuiltinRemovePointer(BaseType, Loc);
+    break;
+  }
+  case UnaryTransformType::Decay: {
+    Result = BuiltinDecay(BaseType, Loc);
+    break;
+  case UnaryTransformType::AddLvalueReference:
+  case UnaryTransformType::AddRvalueReference: {
+    Result = BuiltinAddReference(BaseType, UKind, Loc);
+    break;
+  }
+  case UnaryTransformType::RemoveAllExtents:
+  case UnaryTransformType::RemoveExtent: {
+    Result = BuiltinRemoveExtent(BaseType, UKind, Loc);
+    break;
+  case UnaryTransformType::RemoveCVRef:
+  case UnaryTransformType::RemoveReference: {
+    Result = BuiltinRemoveReference(BaseType, UKind, Loc);
+    break;
+  }
+  case UnaryTransformType::RemoveConst:
+  case UnaryTransformType::RemoveCV:
+  case UnaryTransformType::RemoveRestrict:
+  case UnaryTransformType::RemoveVolatile: {
+    Result = BuiltinChangeCVRQualifiers(BaseType, UKind, Loc);
+    break;
   }
+  case UnaryTransformType::MakeSigned:
+  case UnaryTransformType::MakeUnsigned: {
+    Result = BuiltinChangeSignedness(BaseType, UKind, Loc);
+    break;
+  }
+  default:
     llvm_unreachable("unknown unary transform type");
   }
 
+  return !Result.isNull()
+             ? Context.getUnaryTransformType(BaseType, Result, UKind)
+             : Result;
+}
+
 QualType Sema::BuildAtomicType(QualType T, SourceLocation Loc) {
   if (!isDependentOrGNUAutoType(T)) {
     // 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;

clang/test/CodeGenCXX/mangle.cpp

 
 namespace N { int i; }
 
 namespace N { int f(int, int) { static int b; return b; } }
 
 namespace N { int h(); void g() { static int a = h(); } }
 
 // CHECK-LABEL: define{{.*}} void @_Z1fno
-void f(__int128_t, __uint128_t) { } 
+void f(__int128_t, __uint128_t) {}
 
 template <typename T> struct S1 {};
 
 // CHECK-LABEL: define{{.*}} void @_Z1f2S1IiE
 void f(S1<int>) {}
 
 // CHECK-LABEL: define{{.*}} void @_Z1f2S1IdE
 void f(S1<double>) {}

 
 namespace NS {
   template<typename T> void ft1(T) { }
 }
 
 void g1() {
   // CHECK: @_Z3ft1IidEvT0_T_
   ft1<int, double>(1, 0);
-  
   // CHECK: @_Z3ft2IcEvT_PFvS0_ES2_
   ft2<char>(1, 0, 0);
-  
   // CHECK: @_Z3ft3IiEvP2S4IT_2S1IS1_EE
   ft3<int>(0);
-  
   // CHECK: @_ZN2NS3ft1IiEEvT_
   NS::ft1<int>(1);
 }
 
 // Expressions
 template<int I> struct S5 { };
 
 template<int I> void ft4(S5<I>) { }
 void g2() {
   // CHECK: @_Z3ft4ILi10EEv2S5IXT_EE
   ft4(S5<10>());
-  
   // CHECK: @_Z3ft4ILi20EEv2S5IXT_EE
   ft4(S5<20>());
 }
 
 extern "C++" {
   // CHECK: @_Z1hv
- void h() { } 
+void h() {}
 }
 
 // PR5019
 extern "C" { struct a { int b; }; }
 
 // CHECK: @_Z1fP1a
 int f(struct a *x) {
     return x->b;

 void extern_f(void);
 };
 
 // CHECK: @extern_f
 void extern_f(void) { }
 
 struct S7 {
   S7();
-  
   struct S { S(); };
   struct {
     S s;
   } a;
 };
 
 // PR5139
 // CHECK: @_ZN2S7C2Ev

 template void f4<true>(int (*)[1]);
 }
 
 struct Ops {
   Ops& operator+(const Ops&);
   Ops& operator-(const Ops&);
   Ops& operator&(const Ops&);
   Ops& operator*(const Ops&);
-  
   void *v;
 };
 
 // CHECK-LABEL: define{{.*}} nonnull align {{[0-9]+}} dereferenceable({{[0-9]+}}) %struct.Ops* @_ZN3OpsplERKS_
 Ops& Ops::operator+(const Ops&) { return *this; }
 // CHECK-LABEL: define{{.*}} nonnull align {{[0-9]+}} dereferenceable({{[0-9]+}}) %struct.Ops* @_ZN3OpsmiERKS_
 Ops& Ops::operator-(const Ops&) { return *this; }
 // CHECK-LABEL: define{{.*}} nonnull align {{[0-9]+}} dereferenceable({{[0-9]+}}) %struct.Ops* @_ZN3OpsanERKS_

 
 namespace test11 {
   // CHECK: @_ZN6test111fEz
   void f(...) { }
 
   struct A {
     void f(...);
   };
-  
   // CHECK: @_ZN6test111A1fEz
   void A::f(...) { }
 }
 
 namespace test12 {
 
   // CHECK: _ZN6test121fENS_1AILt33000EEE
   template <unsigned short> struct A { };
namespace test34 {
   template<typename T> void f4(::test34::A<sizeof(sizeof(decltype(T() + T())))>) { }
 
   // CHECK-LABEL: define weak_odr void @_ZN6test342f4IiEEvNS_1AIXszstDTplcvT__EcvS2__EEEEE
   template void f4<int>(A<sizeof(sizeof(int))>);
 }
 
 namespace test35 {
   // Dependent operator names of unknown arity.
-  struct A { 
-    template<typename U> A operator+(U) const;
-  };
+struct A {
+  template <typename U> A operator+(U) const;
 
   template<typename T>
   void f1(decltype(sizeof(&T::template operator+<int>))) {}
 
   // CHECK-LABEL: define weak_odr void @_ZN6test352f1INS_1AEEEvDTszadsrT_onplIiEE
   template void f1<A>(__SIZE_TYPE__);
 }
 
struct c {
   // CHECK-LABEL: @_ZN6test541cC2EPNS0_Ut_E
   // CHECK-LABEL: @_ZN6test541cC2EPNS0_Ut0_E
 };
 }
 
 namespace test55 {
 enum E { R };
 
 template <typename T>
-void fn(T, __underlying_type(T)) {}
-
-template void fn<E>(E, __underlying_type(E));
-// CHECK-LABEL: @_ZN6test552fnINS_1EEEEvT_U3eutS2_
-}
+void f1(T, __underlying_type(T)) {}
+template void f1<E>(E, __underlying_type(E));
+// CHECK-LABEL: @_ZN6test552f1INS_1EEEEvT_u17__underlying_typeIS2_E
+
+template <typename T> void f2(T, __add_lvalue_reference(T)) {}
+template void f2<int>(int, __add_lvalue_reference(int));
+// CHECK-LABEL: @_ZN6test552f2IiEEvT_u22__add_lvalue_referenceIS1_E
+
+template <typename T> void f3(T, __add_pointer(T)) {}
+template void f3<int>(int, __add_pointer(int));
+// CHECK-LABEL: @_ZN6test552f3IiEEvT_u13__add_pointerIS1_E
+
+template <typename T> void f4(T, __add_rvalue_reference(T)) {}
+template void f4<int>(int, __add_rvalue_reference(int));
+// CHECK-LABEL: @_ZN6test552f4IiEEvT_u22__add_rvalue_referenceIS1_E
+
+template <typename T> void f5(T, __decay(T)) {}
+template void f5<int>(int, __decay(int));
+// CHECK-LABEL: @_ZN6test552f5IiEEvT_u7__decayIS1_E
+
+template <typename T> void f6(T, __make_signed(T)) {}
+template void f6<int>(int, __make_signed(int));
+// CHECK-LABEL: @_ZN6test552f6IiEEvT_u13__make_signedIS1_E
+
+template <typename T> void f7(T, __make_unsigned(T)) {}
+template void f7<int>(int, __make_unsigned(int));
+// CHECK-LABEL: @_ZN6test552f7IiEEvT_u15__make_unsignedIS1_E
+
+template <typename T> void f8(T, __remove_const(T)) {}
+template void f8<int>(int, __remove_const(int));
+// CHECK-LABEL: @_ZN6test552f8IiEEvT_u14__remove_constIS1_E
+
+template <typename T> void f9(T, __remove_cv(T)) {}
+template void f9<int>(int, __remove_cv(int));
+// CHECK-LABEL: @_ZN6test552f9IiEEvT_u11__remove_cvIS1_E
+
+template <typename T> void f10(T, __remove_cvref(T)) {}
+template void f10<int>(int, __remove_cvref(int));
+// CHECK-LABEL: @_ZN6test553f10IiEEvT_u14__remove_cvrefIS1_E
+
+template <typename T> void f11(T, __remove_volatile(T)) {}
+template void f11<int>(int, __remove_volatile(int));
+// CHECK-LABEL: @_ZN6test553f11IiEEvT_u17__remove_volatileIS1_E
+
+template <typename T> void f12(T, __remove_extent(T)) {}
+template void f12<int>(int, __remove_extent(int));
+// CHECK-LABEL: @_ZN6test553f12IiEEvT_u15__remove_extentIS1_E
+
+template <typename T> void f13(T, __remove_all_extents(T)) {}
+template void f13<int>(int, __remove_all_extents(int));
+// CHECK-LABEL: @_ZN6test553f13IiEEvT_u20__remove_all_extentsIS1_E
+
+template <typename T> void f14(T, __remove_pointer(T)) {}
+template void f14<int>(int, __remove_pointer(int));
+// CHECK-LABEL: @_ZN6test553f14IiEEvT_u16__remove_pointerIS1_E
+
+template <typename T> void f15(T, __remove_reference(T)) {}
+template void f15<int>(int, __remove_reference(int));
+// CHECK-LABEL: @_ZN6test553f15IiEEvT_u18__remove_referenceIS1_E
+
+template <typename T> void f16(T, __remove_volatile(T)) {}
+template void f16<int>(int, __remove_volatile(int));
+// CHECK-LABEL: @_ZN6test553f16IiEEvT_u17__remove_volatileIS1_E
+
+template <typename T> void f17(T, __remove_restrict(T)) {}
+template void f17<int>(int, __remove_restrict(int));
+// CHECK-LABEL: @_ZN6test553f17IiEEvT_u17__remove_restrictIS1_E
+} // namespace test55
 
 namespace test56 {
   struct A { A *operator->(); int n; } a;
   template<int N> void f(decltype(a->n + N)) {}
   // CHECK-LABEL: @_ZN6test561fILi0EEEvDTplptL_ZNS_1aEE1nT_E
   template void f<0>(int);
 }
 

 namespace test60 {
   struct X { int i, j; };
   auto [a,b] = X{1,2};
   template<typename T> void f(decltype(a + T())) {}
   // CHECK-LABEL: @_ZN6test601fIiEEvDTplL_ZNS_1aEEcvT__EE
   template void f<int>(int);
 }
 
 namespace test61 {
   struct X {
     struct Y {
       using a = int;
       using b = int;
     };
   };
   template <typename T> void f(typename T::Y::a, typename T::Y::b) {}
   // CHECK-LABEL: @_ZN6test611fINS_1XEEEvNT_1Y1aENS3_1bE
   template void f<X>(int, int);
 }

clang/test/SemaCXX/libstdcxx_transform_type_traits_hack.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
+
+// libstdc++ uses __remove_cv as an alias, so we make our transform type traits alias-revertible
+template <class T, class U>
+struct Same {
+  static constexpr auto value = __is_same(T, U);
+};
+
+template <class T>
+using __remove_const = int; // expected-warning{{keyword '__remove_const' will be made available as an identifier here}}
+template <class T>
+using A = Same<__remove_const<T>, __remove_const<T>>;
+
+template <class T>
+using __remove_restrict = int; // expected-warning{{keyword '__remove_restrict' will be made available as an identifier here}}
+template <class T>
+using B = Same<__remove_restrict<T>, __remove_restrict<T>>;
+
+template <class T>
+using __remove_volatile = int; // expected-warning{{keyword '__remove_volatile' will be made available as an identifier here}}
+template <class T>
+using C = Same<__remove_volatile<T>, __remove_volatile<T>>;
+
+template <class T>
+using __remove_cv = int; // expected-warning{{keyword '__remove_cv' will be made available as an identifier here}}
+template <class T>
+using D = Same<__remove_cv<T>, __remove_cv<T>>;
+
+template <class T>
+using __add_pointer = int; // expected-warning{{keyword '__add_pointer' will be made available as an identifier here}}
+template <class T>
+using E = Same<__add_pointer<T>, __add_pointer<T>>;
+
+template <class T>
+using __remove_pointer = int; // expected-warning{{keyword '__remove_pointer' will be made available as an identifier here}}
+template <class T>
+using F = Same<__remove_pointer<T>, __remove_pointer<T>>;
+
+template <class T>
+using __add_lvalue_reference = int; // expected-warning{{keyword '__add_lvalue_reference' will be made available as an identifier here}}
+template <class T>
+using G = Same<__add_lvalue_reference<T>, __add_lvalue_reference<T>>;
+
+template <class T>
+using __add_rvalue_reference = int; // expected-warning{{keyword '__add_rvalue_reference' will be made available as an identifier here}}
+template <class T>
+using H = Same<__add_rvalue_reference<T>, __add_rvalue_reference<T>>;
+
+template <class T>
+using __remove_reference = int; // expected-warning{{keyword '__remove_reference' will be made available as an identifier here}}
+template <class T>
+using I = Same<__remove_reference<T>, __remove_reference<T>>;
+
+template <class T>
+using __remove_cvref = int; // expected-warning{{keyword '__remove_cvref' will be made available as an identifier here}}
+template <class T>
+using J = Same<__remove_cvref<T>, __remove_cvref<T>>;
+
+template <class T>
+using __decay = int; // expected-warning{{keyword '__decay' will be made available as an identifier here}}
+template <class T>
+using K = Same<__decay<T>, __decay<T>>;
+
+template <class T>
+using __make_signed = int; // expected-warning{{keyword '__make_signed' will be made available as an identifier here}}
+template <class T>
+using L = Same<__make_signed<T>, __make_signed<T>>;
+
+template <class T>
+using __make_unsigned = int; // expected-warning{{keyword '__make_unsigned' will be made available as an identifier here}}
+template <class T>
+using M = Same<__make_unsigned<T>, __make_unsigned<T>>;
+
+template <class T>
+using __remove_extent = int; // expected-warning{{keyword '__remove_extent' will be made available as an identifier here}}
+template <class T>
+using N = Same<__remove_extent<T>, __remove_extent<T>>;
+
+template <class T>
+using __remove_all_extents = int; // expected-warning{{keyword '__remove_all_extents' will be made available as an identifier here}}
+template <class T>
+using O = Same<__remove_all_extents<T>, __remove_all_extents<T>>;

clang/test/SemaCXX/remove_pointer.mm

+// RUN: %clang_cc1 -fsyntax-only -verify %s
+
+// expected-no-diagnostics
+
+@class X;
+
+static_assert(__is_same(__remove_pointer(X *), X), "");
+static_assert(__is_same(__remove_pointer(id), id), "");

clang/test/SemaCXX/type-traits.cpp

-// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only -verify -std=gnu++11 -Wno-deprecated-builtins -fms-extensions -Wno-microsoft %s
-// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only -verify -std=gnu++14 -Wno-deprecated-builtins -fms-extensions -Wno-microsoft %s
-// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only -verify -std=gnu++1z -Wno-deprecated-builtins -fms-extensions -Wno-microsoft %s
+// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only -verify -std=gnu++11 -fblocks -Wno-deprecated-builtins -fms-extensions -Wno-microsoft %s
+// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only -verify -std=gnu++14 -fblocks -Wno-deprecated-builtins -fms-extensions -Wno-microsoft %s
+// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -fsyntax-only -verify -std=gnu++1z -fblocks -Wno-deprecated-builtins -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 T256
 #undef T1024
 #undef T4096
 #undef T16384
 #undef T32768
 } // namespace type_trait_expr_numargs_overflow
 
 namespace is_trivially_relocatable {
 
 static_assert(!__is_trivially_relocatable(void), "");
 static_assert(__is_trivially_relocatable(int), "");
 static_assert(__is_trivially_relocatable(int[]), "");
 
 enum Enum {};
 static_assert(__is_trivially_relocatable(Enum), "");
 static_assert(__is_trivially_relocatable(Enum[]), "");
 
 union Union {int x;};
 static_assert(__is_trivially_relocatable(Union), "");
 static_assert(__is_trivially_relocatable(Union[]), "");

 // clang/test/SemaCXX/attr-trivial-abi.cpp
 struct [[clang::trivial_abi]] TrivialAbiNontrivialMoveCtor {
   TrivialAbiNontrivialMoveCtor(TrivialAbiNontrivialMoveCtor&&) {}
 };
 static_assert(__is_trivially_relocatable(TrivialAbiNontrivialMoveCtor), "");
 static_assert(__is_trivially_relocatable(TrivialAbiNontrivialMoveCtor[]), "");
 
 } // namespace is_trivially_relocatable
+
+struct S {};
+template <class T> using remove_const_t = __remove_const(T);
+
+void check_remove_const() {
+  static_assert(__is_same(remove_const_t<void>, void), "");
+  static_assert(__is_same(remove_const_t<const void>, void), "");
+  static_assert(__is_same(remove_const_t<int>, int), "");
+  static_assert(__is_same(remove_const_t<const int>, int), "");
+  static_assert(__is_same(remove_const_t<volatile int>, volatile int), "");
+  static_assert(__is_same(remove_const_t<const volatile int>, volatile int), "");
+  static_assert(__is_same(remove_const_t<int *>, int *), "");
+  static_assert(__is_same(remove_const_t<int *const>, int *), "");
+  static_assert(__is_same(remove_const_t<int const *const>, int const *), "");
+  static_assert(__is_same(remove_const_t<int const *const __restrict>, int const *__restrict), "");
+  static_assert(__is_same(remove_const_t<int &>, int &), "");
+  static_assert(__is_same(remove_const_t<int const &>, int const &), "");
+  static_assert(__is_same(remove_const_t<int &&>, int &&), "");
+  static_assert(__is_same(remove_const_t<int const &&>, int const &&), "");
+  static_assert(__is_same(remove_const_t<int()>, int()), "");
+  static_assert(__is_same(remove_const_t<int (*const)()>, int (*)()), "");
+  static_assert(__is_same(remove_const_t<int (&)()>, int (&)()), "");
+
+  static_assert(__is_same(remove_const_t<S>, S), "");
+  static_assert(__is_same(remove_const_t<const S>, S), "");
+  static_assert(__is_same(remove_const_t<volatile S>, volatile S), "");
+  static_assert(__is_same(remove_const_t<S *__restrict>, S *__restrict), "");
+  static_assert(__is_same(remove_const_t<const volatile S>, volatile S), "");
+  static_assert(__is_same(remove_const_t<S *const volatile __restrict>, S *volatile __restrict), "");
+  static_assert(__is_same(remove_const_t<int S::*const>, int S::*), "");
+  static_assert(__is_same(remove_const_t<int (S::*const)()>, int(S::*)()), "");
+}
+
+template <class T> using remove_restrict_t = __remove_restrict(T);
+
+void check_remove_restrict() {
+  static_assert(__is_same(remove_restrict_t<void>, void), "");
+  static_assert(__is_same(remove_restrict_t<int>, int), "");
+  static_assert(__is_same(remove_restrict_t<const int>, const int), "");
+  static_assert(__is_same(remove_restrict_t<volatile int>, volatile int), "");
+  static_assert(__is_same(remove_restrict_t<int *__restrict>, int *), "");
+  static_assert(__is_same(remove_restrict_t<int *const volatile __restrict>, int *const volatile), "");
+  static_assert(__is_same(remove_restrict_t<int *>, int *), "");
+  static_assert(__is_same(remove_restrict_t<int *__restrict>, int *), "");
+  static_assert(__is_same(remove_restrict_t<int &>, int &), "");
+  static_assert(__is_same(remove_restrict_t<int &__restrict>, int &), "");
+  static_assert(__is_same(remove_restrict_t<int &&>, int &&), "");
+  static_assert(__is_same(remove_restrict_t<int &&__restrict>, int &&), "");
+  static_assert(__is_same(remove_restrict_t<int()>, int()), "");
+  static_assert(__is_same(remove_restrict_t<int (*const volatile)()>, int (*const volatile)()), "");
+  static_assert(__is_same(remove_restrict_t<int (&)()>, int (&)()), "");
+
+  static_assert(__is_same(remove_restrict_t<S>, S), "");
+  static_assert(__is_same(remove_restrict_t<const S>, const S), "");
+  static_assert(__is_same(remove_restrict_t<volatile S>, volatile S), "");
+  static_assert(__is_same(remove_restrict_t<S *__restrict>, S *), "");
+  static_assert(__is_same(remove_restrict_t<S *const volatile __restrict>, S *const volatile), "");
+  static_assert(__is_same(remove_restrict_t<int S::*__restrict>, int S::*), "");
+  static_assert(__is_same(remove_restrict_t<int (S::*const volatile)()>, int(S::*const volatile)()), "");
+}
+
+template <class T> using remove_volatile_t = __remove_volatile(T);
+
+void check_remove_volatile() {
+  static_assert(__is_same(remove_volatile_t<void>, void), "");
+  static_assert(__is_same(remove_volatile_t<volatile void>, void), "");
+  static_assert(__is_same(remove_volatile_t<int>, int), "");
+  static_assert(__is_same(remove_volatile_t<const int>, const int), "");
+  static_assert(__is_same(remove_volatile_t<volatile int>, int), "");
+  static_assert(__is_same(remove_volatile_t<int *__restrict>, int *__restrict), "");
+  static_assert(__is_same(remove_volatile_t<const volatile int>, const int), "");
+  static_assert(__is_same(remove_volatile_t<int *const volatile __restrict>, int *const __restrict), "");
+  static_assert(__is_same(remove_volatile_t<int *>, int *), "");
+  static_assert(__is_same(remove_volatile_t<int *volatile>, int *), "");
+  static_assert(__is_same(remove_volatile_t<int volatile *volatile>, int volatile *), "");
+  static_assert(__is_same(remove_volatile_t<int &>, int &), "");
+  static_assert(__is_same(remove_volatile_t<int volatile &>, int volatile &), "");
+  static_assert(__is_same(remove_volatile_t<int &&>, int &&), "");
+  static_assert(__is_same(remove_volatile_t<int volatile &&>, int volatile &&), "");
+  static_assert(__is_same(remove_volatile_t<int()>, int()), "");
+  static_assert(__is_same(remove_volatile_t<int (*volatile)()>, int (*)()), "");
+  static_assert(__is_same(remove_volatile_t<int (&)()>, int (&)()), "");
+
+  static_assert(__is_same(remove_volatile_t<S>, S), "");
+  static_assert(__is_same(remove_volatile_t<const S>, const S), "");
+  static_assert(__is_same(remove_volatile_t<volatile S>, S), "");
+  static_assert(__is_same(remove_volatile_t<const volatile S>, const S), "");
+  static_assert(__is_same(remove_volatile_t<int S::*volatile>, int S::*), "");
+  static_assert(__is_same(remove_volatile_t<int (S::*volatile)()>, int(S::*)()), "");
+}
+
+template <class T> using remove_cv_t = __remove_cv(T);
+
+void check_remove_cv() {
+  static_assert(__is_same(remove_cv_t<void>, void), "");
+  static_assert(__is_same(remove_cv_t<const volatile void>, void), "");
+  static_assert(__is_same(remove_cv_t<int>, int), "");
+  static_assert(__is_same(remove_cv_t<const int>, int), "");
+  static_assert(__is_same(remove_cv_t<volatile int>, int), "");
+  static_assert(__is_same(remove_cv_t<const volatile int>, int), "");
+  static_assert(__is_same(remove_cv_t<int *>, int *), "");
+  static_assert(__is_same(remove_cv_t<int *const volatile>, int *), "");
+  static_assert(__is_same(remove_cv_t<int const *const volatile>, int const *), "");
+  static_assert(__is_same(remove_cv_t<int const *const volatile __restrict>, int const *__restrict), "");
+  static_assert(__is_same(remove_cv_t<int const *const volatile _Nonnull>, int const *_Nonnull), "");
+  static_assert(__is_same(remove_cv_t<int &>, int &), "");
+  static_assert(__is_same(remove_cv_t<int const volatile &>, int const volatile &), "");
+  static_assert(__is_same(remove_cv_t<int &&>, int &&), "");
+  static_assert(__is_same(remove_cv_t<int const volatile &&>, int const volatile &&), "");
+  static_assert(__is_same(remove_cv_t<int()>, int()), "");
+  static_assert(__is_same(remove_cv_t<int (*const volatile)()>, int (*)()), "");
+  static_assert(__is_same(remove_cv_t<int (&)()>, int (&)()), "");
+
+  static_assert(__is_same(remove_cv_t<S>, S), "");
+  static_assert(__is_same(remove_cv_t<const S>, S), "");
+  static_assert(__is_same(remove_cv_t<volatile S>, S), "");
+  static_assert(__is_same(remove_cv_t<const volatile S>, S), "");
+  static_assert(__is_same(remove_cv_t<int S::*const volatile>, int S::*), "");
+  static_assert(__is_same(remove_cv_t<int (S::*const volatile)()>, int(S::*)()), "");
+}
+
+template <class T> using add_pointer_t = __add_pointer(T);
+
+void add_pointer() {
+  static_assert(__is_same(add_pointer_t<void>, void *), "");
+  static_assert(__is_same(add_pointer_t<const void>, const void *), "");
+  static_assert(__is_same(add_pointer_t<volatile void>, volatile void *), "");
+  static_assert(__is_same(add_pointer_t<const volatile void>, const volatile void *), "");
+  static_assert(__is_same(add_pointer_t<int>, int *), "");
+  static_assert(__is_same(add_pointer_t<const int>, const int *), "");
+  static_assert(__is_same(add_pointer_t<volatile int>, volatile int *), "");
+  static_assert(__is_same(add_pointer_t<const volatile int>, const volatile int *), "");
+  static_assert(__is_same(add_pointer_t<int *>, int **), "");
+  static_assert(__is_same(add_pointer_t<int &>, int *), "");
+  static_assert(__is_same(add_pointer_t<int &&>, int *), "");
+  static_assert(__is_same(add_pointer_t<int()>, int (*)()), "");
+  static_assert(__is_same(add_pointer_t<int (*)()>, int (**)()), "");
+  static_assert(__is_same(add_pointer_t<int (&)()>, int (*)()), "");
+
+  static_assert(__is_same(add_pointer_t<S>, S *), "");
+  static_assert(__is_same(add_pointer_t<const S>, const S *), "");
+  static_assert(__is_same(add_pointer_t<volatile S>, volatile S *), "");
+  static_assert(__is_same(add_pointer_t<const volatile S>, const volatile S *), "");
+  static_assert(__is_same(add_pointer_t<int S::*>, int S::**), "");
+  static_assert(__is_same(add_pointer_t<int (S::*)()>, int(S::**)()), "");
+
+  static_assert(__is_same(add_pointer_t<int __attribute__((address_space(1)))>, int __attribute__((address_space(1))) *), "");
+  static_assert(__is_same(add_pointer_t<S __attribute__((address_space(2)))>, S __attribute__((address_space(2))) *), "");
+}
+
+template <class T> using remove_pointer_t = __remove_pointer(T);
+
+void remove_pointer() {
+  static_assert(__is_same(remove_pointer_t<void>, void), "");
+  static_assert(__is_same(remove_pointer_t<const void>, const void), "");
+  static_assert(__is_same(remove_pointer_t<volatile void>, volatile void), "");
+  static_assert(__is_same(remove_pointer_t<const volatile void>, const volatile void), "");
+  static_assert(__is_same(remove_pointer_t<int>, int), "");
+  static_assert(__is_same(remove_pointer_t<const int>, const int), "");
+  static_assert(__is_same(remove_pointer_t<volatile int>, volatile int), "");
+  static_assert(__is_same(remove_pointer_t<const volatile int>, const volatile int), "");
+  static_assert(__is_same(remove_pointer_t<int *>, int), "");
+  static_assert(__is_same(remove_pointer_t<const int *>, const int), "");
+  static_assert(__is_same(remove_pointer_t<volatile int *>, volatile int), "");
+  static_assert(__is_same(remove_pointer_t<const volatile int *>, const volatile int), "");
+  static_assert(__is_same(remove_pointer_t<int *const>, int), "");
+  static_assert(__is_same(remove_pointer_t<int *volatile>, int), "");
+  static_assert(__is_same(remove_pointer_t<int *const volatile>, int), "");
+  static_assert(__is_same(remove_pointer_t<int &>, int &), "");
+  static_assert(__is_same(remove_pointer_t<int &&>, int &&), "");
+  static_assert(__is_same(remove_pointer_t<int()>, int()), "");
+  static_assert(__is_same(remove_pointer_t<int (*)()>, int()), "");
+  static_assert(__is_same(remove_pointer_t<int (&)()>, int (&)()), "");
+
+  static_assert(__is_same(remove_pointer_t<S>, S), "");
+  static_assert(__is_same(remove_pointer_t<const S>, const S), "");
+  static_assert(__is_same(remove_pointer_t<volatile S>, volatile S), "");
+  static_assert(__is_same(remove_pointer_t<const volatile S>, const volatile S), "");
+  static_assert(__is_same(remove_pointer_t<int S::*>, int S::*), "");
+  static_assert(__is_same(remove_pointer_t<int (S::*)()>, int(S::*)()), "");
+
+  static_assert(__is_same(remove_pointer_t<int __attribute__((address_space(1))) *>, int __attribute__((address_space(1)))), "");
+  static_assert(__is_same(remove_pointer_t<S __attribute__((address_space(2))) *>, S  __attribute__((address_space(2)))), "");
+
+  static_assert(__is_same(remove_pointer_t<int (^)(char)>, int (^)(char)), "");
+}
+
+template <class T> using add_lvalue_reference_t = __add_lvalue_reference(T);
+
+void add_lvalue_reference() {
+  static_assert(__is_same(add_lvalue_reference_t<void>, void), "");
+  static_assert(__is_same(add_lvalue_reference_t<const void>, const void), "");
+  static_assert(__is_same(add_lvalue_reference_t<volatile void>, volatile void), "");
+  static_assert(__is_same(add_lvalue_reference_t<const volatile void>, const volatile void), "");
+  static_assert(__is_same(add_lvalue_reference_t<int>, int &), "");
+  static_assert(__is_same(add_lvalue_reference_t<const int>, const int &), "");
+  static_assert(__is_same(add_lvalue_reference_t<volatile int>, volatile int &), "");
+  static_assert(__is_same(add_lvalue_reference_t<const volatile int>, const volatile int &), "");
+  static_assert(__is_same(add_lvalue_reference_t<int *>, int *&), "");
+  static_assert(__is_same(add_lvalue_reference_t<int &>, int &), "");
+  static_assert(__is_same(add_lvalue_reference_t<int &&>, int &), ""); // reference collapsing
+  static_assert(__is_same(add_lvalue_reference_t<int()>, int (&)()), "");
+  static_assert(__is_same(add_lvalue_reference_t<int (*)()>, int (*&)()), "");
+  static_assert(__is_same(add_lvalue_reference_t<int (&)()>, int (&)()), "");
+
+  static_assert(__is_same(add_lvalue_reference_t<S>, S &), "");
+  static_assert(__is_same(add_lvalue_reference_t<const S>, const S &), "");
+  static_assert(__is_same(add_lvalue_reference_t<volatile S>, volatile S &), "");
+  static_assert(__is_same(add_lvalue_reference_t<const volatile S>, const volatile S &), "");
+  static_assert(__is_same(add_lvalue_reference_t<int S::*>, int S::*&), "");
+  static_assert(__is_same(add_lvalue_reference_t<int (S::*)()>, int(S::*&)()), "");
+}
+
+template <class T> using add_rvalue_reference_t = __add_rvalue_reference(T);
+
+void add_rvalue_reference() {
+  static_assert(__is_same(add_rvalue_reference_t<void>, void), "");
+  static_assert(__is_same(add_rvalue_reference_t<const void>, const void), "");
+  static_assert(__is_same(add_rvalue_reference_t<volatile void>, volatile void), "");
+  static_assert(__is_same(add_rvalue_reference_t<const volatile void>, const volatile void), "");
+  static_assert(__is_same(add_rvalue_reference_t<int>, int &&), "");
+  static_assert(__is_same(add_rvalue_reference_t<const int>, const int &&), "");
+  static_assert(__is_same(add_rvalue_reference_t<volatile int>, volatile int &&), "");
+  static_assert(__is_same(add_rvalue_reference_t<const volatile int>, const volatile int &&), "");
+  static_assert(__is_same(add_rvalue_reference_t<int *>, int *&&), "");
+  static_assert(__is_same(add_rvalue_reference_t<int &>, int &), ""); // reference collapsing
+  static_assert(__is_same(add_rvalue_reference_t<int &&>, int &&), "");
+  static_assert(__is_same(add_rvalue_reference_t<int()>, int(&&)()), "");
+  static_assert(__is_same(add_rvalue_reference_t<int (*)()>, int (*&&)()), "");
+  static_assert(__is_same(add_rvalue_reference_t<int (&)()>, int (&)()), ""); // reference collapsing
+
+  static_assert(__is_same(add_rvalue_reference_t<S>, S &&), "");
+  static_assert(__is_same(add_rvalue_reference_t<const S>, const S &&), "");
+  static_assert(__is_same(add_rvalue_reference_t<volatile S>, volatile S &&), "");
+  static_assert(__is_same(add_rvalue_reference_t<const volatile S>, const volatile S &&), "");
+  static_assert(__is_same(add_rvalue_reference_t<int S::*>, int S::*&&), "");
+  static_assert(__is_same(add_rvalue_reference_t<int (S::*)()>, int(S::* &&)()), "");
+}
+
+template <class T> using remove_reference_t = __remove_reference(T);
+
+void check_remove_reference() {
+  static_assert(__is_same(remove_reference_t<void>, void), "");
+  static_assert(__is_same(remove_reference_t<const volatile void>, const volatile void), "");
+  static_assert(__is_same(remove_reference_t<int>, int), "");
+  static_assert(__is_same(remove_reference_t<const int>, const int), "");
+  static_assert(__is_same(remove_reference_t<volatile int>, volatile int), "");
+  static_assert(__is_same(remove_reference_t<const volatile int>, const volatile int), "");
+  static_assert(__is_same(remove_reference_t<int *>, int *), "");
+  static_assert(__is_same(remove_reference_t<int *const volatile>, int *const volatile), "");
+  static_assert(__is_same(remove_reference_t<int const *const volatile>, int const *const volatile), "");
+  static_assert(__is_same(remove_reference_t<int &>, int), "");
+  static_assert(__is_same(remove_reference_t<int const volatile &>, int const volatile), "");
+  static_assert(__is_same(remove_reference_t<int &&>, int), "");
+  static_assert(__is_same(remove_reference_t<int const volatile &&>, int const volatile), "");
+  static_assert(__is_same(remove_reference_t<int()>, int()), "");
+  static_assert(__is_same(remove_reference_t<int (*const volatile)()>, int (*const volatile)()), "");
+  static_assert(__is_same(remove_reference_t<int (&)()>, int()), "");
+
+  static_assert(__is_same(remove_reference_t<S>, S), "");
+  static_assert(__is_same(remove_reference_t<S &>, S), "");
+  static_assert(__is_same(remove_reference_t<S &&>, S), "");
+  static_assert(__is_same(remove_reference_t<const S>, const S), "");
+  static_assert(__is_same(remove_reference_t<const S &>, const S), "");
+  static_assert(__is_same(remove_reference_t<const S &&>, const S), "");
+  static_assert(__is_same(remove_reference_t<volatile S>, volatile S), "");
+  static_assert(__is_same(remove_reference_t<volatile S &>, volatile S), "");
+  static_assert(__is_same(remove_reference_t<volatile S &&>, volatile S), "");
+  static_assert(__is_same(remove_reference_t<const volatile S>, const volatile S), "");
+  static_assert(__is_same(remove_reference_t<const volatile S &>, const volatile S), "");
+  static_assert(__is_same(remove_reference_t<const volatile S &&>, const volatile S), "");
+  static_assert(__is_same(remove_reference_t<int S::*const volatile &>, int S::*const volatile), "");
+  static_assert(__is_same(remove_reference_t<int (S::*const volatile &)()>, int(S::*const volatile)()), "");
+  static_assert(__is_same(remove_reference_t<int (S::*const volatile &&)() &>, int(S::*const volatile)() &), "");
+}
+
+template <class T> using remove_cvref_t = __remove_cvref(T);
+
+void check_remove_cvref() {
+  static_assert(__is_same(remove_cvref_t<void>, void), "");
+  static_assert(__is_same(remove_cvref_t<const volatile void>, void), "");
+  static_assert(__is_same(remove_cvref_t<int>, int), "");
+  static_assert(__is_same(remove_cvref_t<const int>, int), "");
+  static_assert(__is_same(remove_cvref_t<volatile int>, int), "");
+  static_assert(__is_same(remove_cvref_t<const volatile int>, int), "");
+  static_assert(__is_same(remove_cvref_t<int *>, int *), "");
+  static_assert(__is_same(remove_cvref_t<int *const volatile>, int *), "");
+  static_assert(__is_same(remove_cvref_t<int const *const volatile>, int const *), "");
+  static_assert(__is_same(remove_cvref_t<int const *const volatile __restrict>, int const *__restrict), "");
+  static_assert(__is_same(remove_cvref_t<int const *const volatile _Nonnull>, int const *_Nonnull), "");
+  static_assert(__is_same(remove_cvref_t<int &>, int), "");
+  static_assert(__is_same(remove_cvref_t<int const volatile &>, int), "");
+  static_assert(__is_same(remove_cvref_t<int &&>, int), "");
+  static_assert(__is_same(remove_cvref_t<int const volatile &&>, int), "");
+  static_assert(__is_same(remove_cvref_t<int()>, int()), "");
+  static_assert(__is_same(remove_cvref_t<int (*const volatile)()>, int (*)()), "");
+  static_assert(__is_same(remove_cvref_t<int (&)()>, int()), "");
+
+  static_assert(__is_same(remove_cvref_t<S>, S), "");
+  static_assert(__is_same(remove_cvref_t<S &>, S), "");
+  static_assert(__is_same(remove_cvref_t<S &&>, S), "");
+  static_assert(__is_same(remove_cvref_t<const S>, S), "");
+  static_assert(__is_same(remove_cvref_t<const S &>, S), "");
+  static_assert(__is_same(remove_cvref_t<const S &&>, S), "");
+  static_assert(__is_same(remove_cvref_t<volatile S>, S), "");
+  static_assert(__is_same(remove_cvref_t<volatile S &>, S), "");
+  static_assert(__is_same(remove_cvref_t<volatile S &&>, S), "");
+  static_assert(__is_same(remove_cvref_t<const volatile S>, S), "");
+  static_assert(__is_same(remove_cvref_t<const volatile S &>, S), "");
+  static_assert(__is_same(remove_cvref_t<const volatile S &&>, S), "");
+  static_assert(__is_same(remove_cvref_t<int S::*const volatile>, int S::*), "");
+  static_assert(__is_same(remove_cvref_t<int (S::*const volatile)()>, int(S::*)()), "");
+  static_assert(__is_same(remove_cvref_t<int (S::*const volatile)() &>, int(S::*)() &), "");
+  static_assert(__is_same(remove_cvref_t<int (S::*const volatile)() &&>, int(S::*)() &&), "");
+}
+
+template <class T> using decay_t = __decay(T);
+template <class T> struct dne;
+
+void check_decay() {
+  static_assert(__is_same(decay_t<void>, void), "");
+  static_assert(__is_same(decay_t<const volatile void>, void), "");
+  static_assert(__is_same(decay_t<int>, int), "");
+  static_assert(__is_same(decay_t<const int>, int), "");
+  static_assert(__is_same(decay_t<volatile int>, int), "");
+  static_assert(__is_same(decay_t<const volatile int>, int), "");
+  static_assert(__is_same(decay_t<int *>, int *), "");
+  static_assert(__is_same(decay_t<int *const volatile>, int *), "");
+  static_assert(__is_same(decay_t<int *const volatile __restrict>, int *), "");
+  static_assert(__is_same(decay_t<int const *const volatile>, int const *), "");
+  static_assert(__is_same(decay_t<int const *const volatile _Nonnull>, int const *), "");
+  static_assert(__is_same(decay_t<int &>, int), "");
+  static_assert(__is_same(decay_t<int const volatile &>, int), "");
+  static_assert(__is_same(decay_t<int &&>, int), "");
+  static_assert(__is_same(decay_t<int const volatile &&>, int), "");
+  static_assert(__is_same(decay_t<int()>, int (*)()), "");
+  static_assert(__is_same(decay_t<int (*)()>, int (*)()), "");
+  static_assert(__is_same(decay_t<int (*const)()>, int (*)()), "");
+  static_assert(__is_same(decay_t<int (*volatile)()>, int (*)()), "");
+  static_assert(__is_same(decay_t<int (*const volatile)()>, int (*)()), "");
+  static_assert(__is_same(decay_t<int (&)()>, int (*)()), "");
+  static_assert(__is_same(decay_t<IntAr>, int *), "");
+  static_assert(__is_same(decay_t<IntArNB>, int *), "");
+
+  static_assert(__is_same(decay_t<S>, S), "");
+  static_assert(__is_same(decay_t<S &>, S), "");
+  static_assert(__is_same(decay_t<S &&>, S), "");
+  static_assert(__is_same(decay_t<const S>, S), "");
+  static_assert(__is_same(decay_t<const S &>, S), "");
+  static_assert(__is_same(decay_t<const S &&>, S), "");
+  static_assert(__is_same(decay_t<volatile S>, S), "");
+  static_assert(__is_same(decay_t<volatile S &>, S), "");
+  static_assert(__is_same(decay_t<volatile S &&>, S), "");
+  static_assert(__is_same(decay_t<const volatile S>, S), "");
+  static_assert(__is_same(decay_t<const volatile S &>, S), "");
+  static_assert(__is_same(decay_t<const volatile S &&>, S), "");
+  static_assert(__is_same(decay_t<int S::*const volatile>, int S::*), "");
+  static_assert(__is_same(decay_t<int (S::*const volatile)()>, int(S::*)()), "");
+  static_assert(__is_same(decay_t<int S::*const volatile &>, int S::*), "");
+  static_assert(__is_same(decay_t<int (S::*const volatile &)()>, int(S::*)()), "");
+  static_assert(__is_same(decay_t<int S::*const volatile &&>, int S::*), "");
+}
+
+template <class T> struct CheckAbominableFunction {};
+template <class M>
+struct CheckAbominableFunction<M S::*> {
+  static void checks() {
+    static_assert(__is_same(add_lvalue_reference_t<M>, M), "");
+    static_assert(__is_same(add_pointer_t<M>, M), "");
+    static_assert(__is_same(add_rvalue_reference_t<M>, M), "");
+    static_assert(__is_same(decay_t<M>, M), "");
+    static_assert(__is_same(remove_const_t<M>, M), "");
+    static_assert(__is_same(remove_volatile_t<M>, M), "");
+    static_assert(__is_same(remove_cv_t<M>, M), "");
+    static_assert(__is_same(remove_cvref_t<M>, M), "");
+    static_assert(__is_same(remove_pointer_t<M>, M), "");
+    static_assert(__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);
+template <class T, class Expected>
+void check_make_signed() {
+  static_assert(__is_same(make_signed_t<T>, Expected), "");
+  static_assert(__is_same(make_signed_t<const T>, const Expected), "");
+  static_assert(__is_same(make_signed_t<volatile T>, volatile Expected), "");
+  static_assert(__is_same(make_signed_t<const volatile T>, const volatile Expected), "");
+}
+
+#if defined(__ILP32__) || defined(__LLP64__)
+  using Int64 = long long;
+  using UInt64 = unsigned long long;
+#elif defined(__LP64__) || defined(__ILP64__) || defined(__SILP64__)
+  using Int64 = long;
+  using UInt64 = unsigned long;
+#else
+#error Programming model currently unsupported; please add a new entry.
+#endif
+
+enum UnscopedBool : bool {}; // deliberately char
+enum class ScopedBool : bool {}; // deliberately char
+enum UnscopedChar : char {}; // deliberately char
+enum class ScopedChar : char {}; // deliberately char
+enum UnscopedUChar : unsigned char {};
+enum class ScopedUChar : unsigned char {};
+enum UnscopedLongLong : long long {};
+enum UnscopedULongLong : unsigned long long {};
+enum class ScopedLongLong : long long {};
+enum class ScopedULongLong : unsigned long long {};
+enum class UnscopedInt128 : __int128 {};
+enum class ScopedInt128 : __int128 {};
+enum class UnscopedUInt128 : unsigned __int128 {};
+enum class ScopedUInt128 : unsigned __int128 {};
+enum UnscopedBit : unsigned _BitInt(1) {};
+enum ScopedBit : unsigned _BitInt(1) {};
+enum UnscopedIrregular : _BitInt(21) {};
+enum UnscopedUIrregular : unsigned _BitInt(21) {};
+enum class ScopedIrregular : _BitInt(21) {};
+enum class ScopedUIrregular : unsigned _BitInt(21) {};
+
+void make_signed() {
+  check_make_signed<char, signed char>();
+  check_make_signed<signed char, signed char>();
+  check_make_signed<unsigned char, signed char>();
+  check_make_signed<short, short>();
+  check_make_signed<unsigned short, short>();
+  check_make_signed<int, int>();
+  check_make_signed<unsigned int, int>();
+  check_make_signed<long, long>();
+  check_make_signed<unsigned long, long>();
+  check_make_signed<long long, long long>();
+  check_make_signed<unsigned long long, long long>();
+  check_make_signed<__int128, __int128>();
+  check_make_signed<__uint128_t, __int128>();
+  check_make_signed<_BitInt(65), _BitInt(65)>();
+  check_make_signed<unsigned _BitInt(65), _BitInt(65)>();
+
+  check_make_signed<wchar_t, int>();
+#if __cplusplus >= 202002L
+  check_make_signed<char8_t, signed char>();
+#endif
+#if __cplusplus >= 201103L
+  check_make_signed<char16_t, short>();
+  check_make_signed<char32_t, int>();
+#endif
+
+  check_make_signed<UnscopedChar, signed char>();
+  check_make_signed<ScopedChar, signed char>();
+  check_make_signed<UnscopedUChar, signed char>();
+  check_make_signed<ScopedUChar, signed char>();
+
+  check_make_signed<UnscopedLongLong, Int64>();
+  check_make_signed<UnscopedULongLong, Int64>();
+  check_make_signed<ScopedLongLong, Int64>();
+  check_make_signed<ScopedULongLong, Int64>();
+
+  check_make_signed<UnscopedInt128, __int128>();
+  check_make_signed<ScopedInt128, __int128>();
+  check_make_signed<UnscopedUInt128, __int128>();
+  check_make_signed<ScopedUInt128, __int128>();
+
+  check_make_signed<UnscopedIrregular, _BitInt(21)>();
+  check_make_signed<UnscopedUIrregular, _BitInt(21)>();
+  check_make_signed<ScopedIrregular, _BitInt(21)>();
+  check_make_signed<ScopedUIrregular, _BitInt(21)>();
+
+  { using ExpectedError = __make_signed(bool); }
+  // expected-error@*:*{{'make_signed' is only compatible with non-bool integers and enum types, but was given 'bool'}}
+  { using ExpectedError = __make_signed(UnscopedBool); }
+  // expected-error@*:*{{'make_signed' is only compatible with non-bool integers and enum types, but was given 'UnscopedBool' whose underlying type is 'bool'}}
+  { using ExpectedError = __make_signed(ScopedBool); }
+  // expected-error@*:*{{'make_signed' is only compatible with non-bool integers and enum types, but was given 'ScopedBool' whose underlying type is 'bool'}}
+  { using ExpectedError = __make_signed(unsigned _BitInt(1)); }
+  // expected-error@*:*{{'make_signed' is only compatible with non-_BitInt(1) integers and enum types, but was given 'unsigned _BitInt(1)'}}
+  { using ExpectedError = __make_signed(UnscopedBit); }
+  // expected-error@*:*{{'make_signed' is only compatible with non-_BitInt(1) integers and enum types, but was given 'UnscopedBit' whose underlying type is 'unsigned _BitInt(1)'}}
+  { using ExpectedError = __make_signed(ScopedBit); }
+  // expected-error@*:*{{'make_signed' is only compatible with non-_BitInt(1) integers and enum types, but was given 'ScopedBit' whose underlying type is 'unsigned _BitInt(1)'}}
+  { using ExpectedError = __make_signed(int[]); }
+  // expected-error@*:*{{'make_signed' is only compatible with non-bool integers and enum types, but was given 'int[]'}}
+  { using ExpectedError = __make_signed(int[5]); }
+  // expected-error@*:*{{'make_signed' is only compatible with non-bool integers and enum types, but was given 'int[5]'}}
+  { using ExpectedError = __make_signed(void); }
+  // expected-error@*:*{{'make_signed' is only compatible with non-bool integers and enum types, but was given 'void'}}
+  { using ExpectedError = __make_signed(int *); }
+  // expected-error@*:*{{'make_signed' is only compatible with non-bool integers and enum types, but was given 'int *'}}
+  { using ExpectedError = __make_signed(int &); }
+  // expected-error@*:*{{'make_signed' is only compatible with non-bool integers and enum types, but was given 'int &'}}
+  { using ExpectedError = __make_signed(int &&); }
+  // expected-error@*:*{{'make_signed' is only compatible with non-bool integers and enum types, but was given 'int &&'}}
+  { using ExpectedError = __make_signed(float); }
+  // expected-error@*:*{{'make_signed' is only compatible with non-bool integers and enum types, but was given 'float'}}
+  { using ExpectedError = __make_signed(double); }
+  // expected-error@*:*{{'make_signed' is only compatible with non-bool integers and enum types, but was given 'double'}}
+  { using ExpectedError = __make_signed(long double); }
+  // expected-error@*:*{{'make_signed' is only compatible with non-bool integers and enum types, but was given 'long double'}}
+  { using ExpectedError = __make_signed(S); }
+  // expected-error@*:*{{'make_signed' is only compatible with non-bool integers and enum types, but was given 'S'}}
+  { using ExpectedError = __make_signed(S *); }
+  // expected-error@*:*{{'make_signed' is only compatible with non-bool integers and enum types, but was given 'S *'}}
+  { using ExpectedError = __make_signed(int S::*); }
+  // expected-error@*:*{{'make_signed' is only compatible with non-bool integers and enum types, but was given 'int S::*'}}
+  { using ExpectedError = __make_signed(int(S::*)()); }
+  // expected-error@*:*{{'make_signed' is only compatible with non-bool integers and enum types, but was given 'int (S::*)()'}}
+}
+
+template <class T>
+using make_unsigned_t = __make_unsigned(T);
+
+template <class T, class Expected>
+void check_make_unsigned() {
+  static_assert(__is_same(make_unsigned_t<T>, Expected), "");
+  static_assert(__is_same(make_unsigned_t<const T>, const Expected), "");
+  static_assert(__is_same(make_unsigned_t<volatile T>, volatile Expected), "");
+  static_assert(__is_same(make_unsigned_t<const volatile T>, const volatile Expected), "");
+}
+
+void make_unsigned() {
+  check_make_unsigned<char, unsigned char>();
+  check_make_unsigned<signed char, unsigned char>();
+  check_make_unsigned<unsigned char, unsigned char>();
+  check_make_unsigned<short, unsigned short>();
+  check_make_unsigned<unsigned short, unsigned short>();
+  check_make_unsigned<int, unsigned int>();
+  check_make_unsigned<unsigned int, unsigned int>();
+  check_make_unsigned<long, unsigned long>();
+  check_make_unsigned<unsigned long, unsigned long>();
+  check_make_unsigned<long long, unsigned long long>();
+  check_make_unsigned<unsigned long long, unsigned long long>();
+  check_make_unsigned<__int128, __uint128_t>();
+  check_make_unsigned<__uint128_t, __uint128_t>();
+  check_make_unsigned<_BitInt(65), unsigned _BitInt(65)>();
+  check_make_unsigned<unsigned _BitInt(65), unsigned _BitInt(65)>();
+
+  check_make_unsigned<wchar_t, unsigned int>();
+#if __cplusplus >= 202002L
+  check_make_unsigned<char8_t, unsigned char>();
+#endif
+#if __cplusplus >= 201103L
+  check_make_unsigned<char16_t, unsigned short>();
+  check_make_unsigned<char32_t, unsigned int>();
+#endif
+
+  check_make_unsigned<UnscopedChar, unsigned char>();
+  check_make_unsigned<ScopedChar, unsigned char>();
+  check_make_unsigned<UnscopedUChar, unsigned char>();
+  check_make_unsigned<ScopedUChar, unsigned char>();
+
+  check_make_unsigned<UnscopedLongLong, UInt64>();
+  check_make_unsigned<UnscopedULongLong, UInt64>();
+  check_make_unsigned<ScopedLongLong, UInt64>();
+  check_make_unsigned<ScopedULongLong, UInt64>();
+
+  check_make_unsigned<UnscopedInt128, unsigned __int128>();
+  check_make_unsigned<ScopedInt128, unsigned __int128>();
+  check_make_unsigned<UnscopedUInt128, unsigned __int128>();
+  check_make_unsigned<ScopedUInt128, unsigned __int128>();
+
+  check_make_unsigned<UnscopedIrregular, unsigned _BitInt(21)>();
+  check_make_unsigned<UnscopedUIrregular, unsigned _BitInt(21)>();
+  check_make_unsigned<ScopedIrregular, unsigned _BitInt(21)>();
+  check_make_unsigned<ScopedUIrregular, unsigned _BitInt(21)>();
+
+  { using ExpectedError = __make_unsigned(bool); }
+  // expected-error@*:*{{'make_unsigned' is only compatible with non-bool integers and enum types, but was given 'bool'}}
+  { using ExpectedError = __make_unsigned(UnscopedBool); }
+  // expected-error@*:*{{'make_unsigned' is only compatible with non-bool integers and enum types, but was given 'UnscopedBool' whose underlying type is 'bool'}}
+  { using ExpectedError = __make_unsigned(ScopedBool); }
+  // expected-error@*:*{{'make_unsigned' is only compatible with non-bool integers and enum types, but was given 'ScopedBool' whose underlying type is 'bool'}}
+  { using ExpectedError = __make_unsigned(unsigned _BitInt(1)); }
+  // expected-error@*:*{{'make_unsigned' is only compatible with non-_BitInt(1) integers and enum types, but was given 'unsigned _BitInt(1)'}}
+  { using ExpectedError = __make_unsigned(UnscopedBit); }
+  // expected-error@*:*{{'make_unsigned' is only compatible with non-_BitInt(1) integers and enum types, but was given 'UnscopedBit'}}
+  { using ExpectedError = __make_unsigned(ScopedBit); }
+  // expected-error@*:*{{'make_unsigned' is only compatible with non-_BitInt(1) integers and enum types, but was given 'ScopedBit'}}
+  { using ExpectedError = __make_unsigned(int[]); }
+  // expected-error@*:*{{'make_unsigned' is only compatible with non-bool integers and enum types, but was given 'int[]'}}
+  { using ExpectedError = __make_unsigned(int[5]); }
+  // expected-error@*:*{{'make_unsigned' is only compatible with non-bool integers and enum types, but was given 'int[5]'}}
+  { using ExpectedError = __make_unsigned(void); }
+  // expected-error@*:*{{'make_unsigned' is only compatible with non-bool integers and enum types, but was given 'void'}}
+  { using ExpectedError = __make_unsigned(int *); }
+  // expected-error@*:*{{'make_unsigned' is only compatible with non-bool integers and enum types, but was given 'int *'}}
+  { using ExpectedError = __make_unsigned(int &); }
+  // expected-error@*:*{{'make_unsigned' is only compatible with non-bool integers and enum types, but was given 'int &'}}
+  { using ExpectedError = __make_unsigned(int &&); }
+  // expected-error@*:*{{'make_unsigned' is only compatible with non-bool integers and enum types, but was given 'int &&'}}
+  { using ExpectedError = __make_unsigned(float); }
+  // expected-error@*:*{{'make_unsigned' is only compatible with non-bool integers and enum types, but was given 'float'}}
+  { using ExpectedError = __make_unsigned(double); }
+  // expected-error@*:*{{'make_unsigned' is only compatible with non-bool integers and enum types, but was given 'double'}}
+  { using ExpectedError = __make_unsigned(long double); }
+  // expected-error@*:*{{'make_unsigned' is only compatible with non-bool integers and enum types, but was given 'long double'}}
+  { using ExpectedError = __make_unsigned(S); }
+  // expected-error@*:*{{'make_unsigned' is only compatible with non-bool integers and enum types, but was given 'S'}}
+  { using ExpectedError = __make_unsigned(S *); }
+  // expected-error@*:*{{'make_unsigned' is only compatible with non-bool integers and enum types, but was given 'S *'}}
+  { using ExpectedError = __make_unsigned(int S::*); }
+  // expected-error@*:*{{'make_unsigned' is only compatible with non-bool integers and enum types, but was given 'int S::*'}}
+  { using ExpectedError = __make_unsigned(int(S::*)()); }
+  // expected-error@*:*{{'make_unsigned' is only compatible with non-bool integers and enum types, but was given 'int (S::*)()'}}
+}
+
+template <class T> using remove_extent_t = __remove_extent(T);
+
+void remove_extent() {
+  static_assert(__is_same(remove_extent_t<void>, void), "");
+  static_assert(__is_same(remove_extent_t<int>, int), "");
+  static_assert(__is_same(remove_extent_t<int[]>, int), "");
+  static_assert(__is_same(remove_extent_t<int[1]>, int), "");
+  static_assert(__is_same(remove_extent_t<int[1][2]>, int[2]), "");
+  static_assert(__is_same(remove_extent_t<int[][2]>, int[2]), "");
+  static_assert(__is_same(remove_extent_t<const int[]>, const int), "");
+  static_assert(__is_same(remove_extent_t<const int[1]>, const int), "");
+  static_assert(__is_same(remove_extent_t<const int[1][2]>, const int[2]), "");
+  static_assert(__is_same(remove_extent_t<const int[][2]>, const int[2]), "");
+  static_assert(__is_same(remove_extent_t<volatile int[]>, volatile int), "");
+  static_assert(__is_same(remove_extent_t<volatile int[1]>, volatile int), "");
+  static_assert(__is_same(remove_extent_t<volatile int[1][2]>, volatile int[2]), "");
+  static_assert(__is_same(remove_extent_t<volatile int[][2]>, volatile int[2]), "");
+  static_assert(__is_same(remove_extent_t<const volatile int[]>, const volatile int), "");
+  static_assert(__is_same(remove_extent_t<const volatile int[1]>, const volatile int), "");
+  static_assert(__is_same(remove_extent_t<const volatile int[1][2]>, const volatile int[2]), "");
+  static_assert(__is_same(remove_extent_t<const volatile int[][2]>, const volatile int[2]), "");
+  static_assert(__is_same(remove_extent_t<int *>, int *), "");
+  static_assert(__is_same(remove_extent_t<int &>, int &), "");
+  static_assert(__is_same(remove_extent_t<int &&>, int &&), "");
+  static_assert(__is_same(remove_extent_t<int()>, int()), "");
+  static_assert(__is_same(remove_extent_t<int (*)()>, int (*)()), "");
+  static_assert(__is_same(remove_extent_t<int (&)()>, int (&)()), "");
+
+  static_assert(__is_same(remove_extent_t<S>, S), "");
+  static_assert(__is_same(remove_extent_t<int S::*>, int S::*), "");
+  static_assert(__is_same(remove_extent_t<int (S::*)()>, int(S::*)()), "");
+
+  using SomeArray = int[1][2];
+  static_assert(__is_same(remove_extent_t<const SomeArray>, const int[2]), "");
+}
+
+template <class T> using remove_all_extents_t = __remove_all_extents(T);
+
+void remove_all_extents() {
+  static_assert(__is_same(remove_all_extents_t<void>, void), "");
+  static_assert(__is_same(remove_all_extents_t<int>, int), "");
+  static_assert(__is_same(remove_all_extents_t<const int>, const int), "");
+  static_assert(__is_same(remove_all_extents_t<volatile int>, volatile int), "");
+  static_assert(__is_same(remove_all_extents_t<const volatile int>, const volatile int), "");
+  static_assert(__is_same(remove_all_extents_t<int[]>, int), "");
+  static_assert(__is_same(remove_all_extents_t<int[1]>, int), "");
+  static_assert(__is_same(remove_all_extents_t<int[1][2]>, int), "");
+  static_assert(__is_same(remove_all_extents_t<int[][2]>, int), "");
+  static_assert(__is_same(remove_all_extents_t<const int[]>, const int), "");
+  static_assert(__is_same(remove_all_extents_t<const int[1]>, const int), "");
+  static_assert(__is_same(remove_all_extents_t<const int[1][2]>, const int), "");
+  static_assert(__is_same(remove_all_extents_t<const int[][2]>, const int), "");
+  static_assert(__is_same(remove_all_extents_t<volatile int[]>, volatile int), "");
+  static_assert(__is_same(remove_all_extents_t<volatile int[1]>, volatile int), "");
+  static_assert(__is_same(remove_all_extents_t<volatile int[1][2]>, volatile int), "");
+  static_assert(__is_same(remove_all_extents_t<volatile int[][2]>, volatile int), "");
+  static_assert(__is_same(remove_all_extents_t<const volatile int[]>, const volatile int), "");
+  static_assert(__is_same(remove_all_extents_t<const volatile int[1]>, const volatile int), "");
+  static_assert(__is_same(remove_all_extents_t<const volatile int[1][2]>, const volatile int), "");
+  static_assert(__is_same(remove_all_extents_t<const volatile int[][2]>, const volatile int), "");
+  static_assert(__is_same(remove_all_extents_t<int *>, int *), "");
+  static_assert(__is_same(remove_all_extents_t<int &>, int &), "");
+  static_assert(__is_same(remove_all_extents_t<int &&>, int &&), "");
+  static_assert(__is_same(remove_all_extents_t<int()>, int()), "");
+  static_assert(__is_same(remove_all_extents_t<int (*)()>, int (*)()), "");
+  static_assert(__is_same(remove_all_extents_t<int (&)()>, int (&)()), "");
+
+  static_assert(__is_same(remove_all_extents_t<S>, S), "");
+  static_assert(__is_same(remove_all_extents_t<int S::*>, int S::*), "");
+  static_assert(__is_same(remove_all_extents_t<int (S::*)()>, int(S::*)()), "");
+
+  using SomeArray = int[1][2];
+  static_assert(__is_same(remove_all_extents_t<const SomeArray>, const int), "");
+}

clang/utils/ClangVisualizers/clang.natvis

 <?xml version="1.0" encoding="utf-8"?>
 <!--
 Visual Studio Native Debugging Visualizers for LLVM
 
-For Visual Studio 2013 only, put this file into 
+For Visual Studio 2013 only, put this file into
 "%USERPROFILE%\Documents\Visual Studio 2013\Visualizers" or create a symbolic link so it updates automatically.
 
 For later versions of Visual Studio, no setup is required-->
 <AutoVisualizer xmlns="http://schemas.microsoft.com/vstudio/debugger/natvis/2010">
 
   <Type Name="clang::Type">
     <!-- To visualize clang::Types, we need to look at TypeBits.TC to determine the actual
          type subclass and manually dispatch accordingly (Visual Studio can't identify the real type
-         because clang::Type has no virtual members hence no RTTI). 
-         
+         because clang::Type has no virtual members hence no RTTI).
          Views:
            "cmn": Visualization that is common to all clang::Type subclasses
            "poly": Visualization that is specific to the actual clang::Type subclass. The subtype-specific
                    <DisplayString> is typically as C++-like as possible (like in dump()) with <Expand>
                    containing all the gory details.
            "cpp": Only occasionally used when we need to distinguish between an ordinary view and a C++-like view.
     -->
     <DisplayString IncludeView="cmn" Condition="TypeBits.TC==clang::LocInfoType::LocInfo">LocInfoType</DisplayString>
<Type Name="clang::RValueReferenceType">
     <Expand>
       <ExpandedItem>*(clang::Type *)this, view(cmn)</ExpandedItem>
       <Item Name="PointeeType">PointeeType</Item>
     </Expand>
   </Type>
   <Type Name="clang::AttributedType">
     <DisplayString>{ModifiedType} Attribute={(clang::AttributedType::Kind)AttributedTypeBits.AttrKind}</DisplayString>
   </Type>
-  
   <!-- Unfortunately, Visual Studio has trouble seeing the PointerBitMask member PointerIntUnion, so I hardwire it to 2 bits-->
   <Type Name="clang::DeclContext">
     <DisplayString>{(clang::Decl::Kind)DeclContextBits.DeclKind,en}Decl</DisplayString>
     <Expand>
       <Item Name="DeclKind">(clang::Decl::Kind)DeclContextBits.DeclKind,en</Item>
       <Synthetic Name="Members">
         <DisplayString></DisplayString>
         <Expand>
<Type Name="clang::TemplateTypeParmDecl">
     <DisplayString IncludeView="TorC" Condition="!Typename">class</DisplayString>
     <DisplayString IncludeView="MaybeEllipses" Condition="TypeForDecl == nullptr">(not yet known if parameter pack) </DisplayString>
     <DisplayString IncludeView="MaybeEllipses" Condition="((TemplateTypeParmType *)(((clang::ExtQualsTypeCommonBase *)(((uintptr_t)TypeForDecl->CanonicalType.Value.Value) &amp; ~(uintptr_t)((1 &lt;&lt; 4) - 1)))-&gt;BaseType))->CanTTPTInfo.ParameterPack">...</DisplayString>
     <DisplayString IncludeView="MaybeEllipses" Condition="!((TemplateTypeParmType *)(((clang::ExtQualsTypeCommonBase *)(((uintptr_t)TypeForDecl->CanonicalType.Value.Value) &amp; ~(uintptr_t)((1 &lt;&lt; 4) - 1)))-&gt;BaseType))->CanTTPTInfo.ParameterPack"></DisplayString>
     <DisplayString IncludeView="DefaultArg" Condition="(DefaultArgument.ValueOrInherited.Val.Value&amp;3LL) == 0">{(TypeSourceInfo *)(DefaultArgument.ValueOrInherited.Val.Value&amp;~3LL),view(cpp)}</DisplayString>
     <DisplayString IncludeView="DefaultArg">{{InheritedInitializer}}</DisplayString>
     <DisplayString IncludeView="Initializer" Condition="DefaultArgument.ValueOrInherited.Val.Value&amp;~3LL">= {this,view(DefaultArg)na}</DisplayString>
     <DisplayString IncludeView="Initializer"></DisplayString>
-    <DisplayString>{*this,view(TorC)} {*this,view(MaybeEllipses)}{Name,view(cpp)} {this,view(Initializer)na}</DisplayString> 
+    <DisplayString>{*this,view(TorC)} {*this,view(MaybeEllipses)}{Name,view(cpp)} {this,view(Initializer)na}</DisplayString>
   </Type>
   <Type Name="clang::TemplateDecl">
     <DisplayString IncludeView="cpp">{*TemplatedDecl,view(cpp)}</DisplayString>
     <DisplayString>template{TemplateParams,na} {*TemplatedDecl};</DisplayString>
     <Expand>
       <Item Name="TemplateParams">TemplateParams,na</Item>
       <Item Name="TemplatedDecl">TemplatedDecl,na</Item>
     </Expand>
<Type Name="clang::DeclarationName">
     <DisplayString Condition="(Ptr &amp; PtrMask) == StoredIdentifier" IncludeView="cpp">{*(clang::IdentifierInfo *)(Ptr &amp; ~PtrMask)}</DisplayString>
     <DisplayString Condition="(Ptr &amp; PtrMask) == StoredIdentifier">{{Identifier ({*(clang::IdentifierInfo *)(Ptr &amp; ~PtrMask)})}}</DisplayString>
     <DisplayString Condition="(Ptr &amp; PtrMask) == StoredObjCZeroArgSelector">{{ObjC Zero Arg Selector (*{(clang::IdentifierInfo *)(Ptr &amp; ~PtrMask)})}}</DisplayString>
     <DisplayString Condition="(Ptr &amp; PtrMask) == StoredObjCOneArgSelector">{{ObjC One Arg Selector (*{(clang::IdentifierInfo *)(Ptr &amp; ~PtrMask)})}}</DisplayString>
     <DisplayString Condition="(Ptr &amp; PtrMask) == StoredCXXConstructorName" IncludeView="cpp">{(clang::detail::CXXSpecialNameExtra *)(Ptr &amp; ~PtrMask),view(cpp)na}</DisplayString>
     <DisplayString Condition="(Ptr &amp; PtrMask) == StoredCXXConstructorName">C++ Constructor {{{(clang::detail::CXXSpecialNameExtra *)(Ptr &amp; ~PtrMask),view(cpp)na}}}</DisplayString>
     <DisplayString Condition="(Ptr &amp; PtrMask) == StoredCXXDestructorName">C++ Destructor {{*(clang::detail::CXXSpecialNameExtra *)(Ptr &amp; ~PtrMask)}}</DisplayString>
     <DisplayString Condition="(Ptr &amp; PtrMask) == StoredCXXConversionFunctionName">C++ Conversion function {{*(clang::detail::CXXSpecialNameExtra *)(Ptr &amp; ~PtrMask)}}</DisplayString>
-    <DisplayString Condition="(Ptr &amp; PtrMask) == StoredCXXOperatorName">C++ Operator {{*(clang::detail::CXXOperatorIdName *)(Ptr &amp; ~PtrMask)}}</DisplayString>    
+    <DisplayString Condition="(Ptr &amp; PtrMask) == StoredCXXOperatorName">C++ Operator {{*(clang::detail::CXXOperatorIdName *)(Ptr &amp; ~PtrMask)}}</DisplayString>
     <DisplayString Condition="(Ptr &amp; PtrMask) == StoredDeclarationNameExtra"
                    IncludeView="cpp">{*(clang::detail::DeclarationNameExtra *)(Ptr &amp; ~PtrMask),view(cpp)}</DisplayString>
     <DisplayString Condition="(Ptr &amp; PtrMask) == StoredDeclarationNameExtra">{{Extra ({*(clang::detail::DeclarationNameExtra *)(Ptr &amp; ~PtrMask)})}}</DisplayString>
     <Expand>
       <Item Name="Kind">StoredNameKind(Ptr &amp; PtrMask),en</Item>
       <Item Condition="(Ptr &amp; PtrMask) == StoredIdentifier" Name="[Identifier]">*(clang::IdentifierInfo *)(Ptr &amp; ~PtrMask),na</Item>
       <Item Condition="(Ptr &amp; PtrMask) == StoredObjCZeroArgSelector" Name="[ObjC Zero Arg Selector]">*(clang::IdentifierInfo *)(Ptr &amp; ~PtrMask),na</Item>
       <Item Condition="(Ptr &amp; PtrMask) == StoredObjCOneArgSelector" Name="[ObjC One Arg Selector]">*(clang::IdentifierInfo *)(Ptr &amp; ~PtrMask),na</Item>
       <Item Condition="(Ptr &amp; PtrMask) == StoredCXXConstructorName" Name="[C++ Constructor]">*(clang::detail::CXXSpecialNameExtra *)(Ptr &amp; ~PtrMask),na</Item>
       <Item Condition="(Ptr &amp; PtrMask) == StoredCXXDestructorName" Name="[C++ Destructor]">*(clang::detail::CXXSpecialNameExtra *)(Ptr &amp; ~PtrMask),na</Item>
       <Item Condition="(Ptr &amp; PtrMask) == StoredCXXConversionFunctionName" Name="[C++ Conversion function]">*(clang::detail::CXXSpecialNameExtra *)(Ptr &amp; ~PtrMask),na</Item>
-      <Item Condition="(Ptr &amp; PtrMask) == StoredCXXOperatorName" Name="[C++ Operator]">*(clang::detail::CXXOperatorIdName *)(Ptr &amp; ~PtrMask),na</Item>      
+      <Item Condition="(Ptr &amp; PtrMask) == StoredCXXOperatorName" Name="[C++ Operator]">*(clang::detail::CXXOperatorIdName *)(Ptr &amp; ~PtrMask),na</Item>
       <Item Condition="(Ptr &amp; PtrMask) == StoredDeclarationNameExtra" Name="[Extra]">(clang::detail::DeclarationNameExtra *)(Ptr &amp; ~PtrMask),na</Item>
     </Expand>
   </Type>
   <Type Name="clang::detail::DeclarationNameExtra">
     <DisplayString Condition="ExtraKindOrNumArgs == CXXDeductionGuideName" IncludeView="cpp">
       {(CXXDeductionGuideNameExtra *)this,view(cpp)nand}
     </DisplayString>
     <DisplayString Condition="ExtraKindOrNumArgs == CXXDeductionGuideName">
       {(CXXDeductionGuideNameExtra *)this,nand}
     </DisplayString>
     <DisplayString Condition="ExtraKindOrNumArgs == CXXLiteralOperatorName">C++ Literal operator</DisplayString>
-    <DisplayString Condition="ExtraKindOrNumArgs == CXXUsingDirective">C++ Using directive</DisplayString>  
+    <DisplayString Condition="ExtraKindOrNumArgs == CXXUsingDirective">C++ Using directive</DisplayString>
     <DisplayString>{(clang::detail::DeclarationNameExtra::ExtraKind)ExtraKindOrNumArgs,en}{"  ",sb}{*this,view(cpp)}</DisplayString>
     <Expand>
       <ExpandedItem Condition="ExtraKindOrNumArgs == CXXDeductionGuideName">(CXXDeductionGuideNameExtra *)this</ExpandedItem>
       <Item Name="ExtraKindOrNumArgs" Condition="ExtraKindOrNumArgs != CXXDeductionGuideName">ExtraKindOrNumArgs</Item>
     </Expand>
   </Type>
   <Type Name="clang::detail::CXXDeductionGuideNameExtra">
     <DisplayString IncludeView="cpp">{Template->TemplatedDecl,view(cpp)}</DisplayString>
<Type Name="clang::LambdaIntroducer">
     <DisplayString IncludeView="capture1">,{(LambdaCapture *)(Captures.BeginX)+1,na}{this,view(capture2)na}</DisplayString>
     <DisplayString IncludeView="capture2" Condition="Captures.Size==2"></DisplayString>
     <DisplayString IncludeView="capture2">,{(LambdaCapture *)(Captures.BeginX)+2,na}{this,view(capture3)na}</DisplayString>
     <DisplayString IncludeView="capture3" Condition="Captures.Size==3"></DisplayString>
     <DisplayString IncludeView="capture3">,...</DisplayString>
     <DisplayString>[{this,view(default)na}{this,view(capture0)na}]</DisplayString>
   </Type>
   <Type Name="clang::DeclSpec">
-    <DisplayString IncludeView="extra" Condition="TypeSpecType == TST_typename || TypeSpecType == TST_typeofType || TypeSpecType == TST_underlyingType || TypeSpecType == TST_atomic">
+    <DisplayString IncludeView="extra" Condition="TypeSpecType == TST_typename || TypeSpecType == TST_typeofType || TypeSpecType == TST_underlying_type || TypeSpecType == TST_atomic">
       , [{TypeRep}]
     </DisplayString>
     <DisplayString IncludeView="extra" Condition="TypeSpecType == TST_typeofExpr || TypeSpecType == TST_decltype">
       , [{ExprRep}]
     </DisplayString>
     <DisplayString IncludeView="extra" Condition="TypeSpecType == TST_enum || TypeSpecType == TST_struct || TypeSpecType == TST_interface || TypeSpecType == TST_union || TypeSpecType == TST_class">
       , [{DeclRep}]
     </DisplayString>
     <DisplayString IncludeView="extra"></DisplayString>
     <DisplayString>[{(clang::DeclSpec::SCS)StorageClassSpec,en}], [{(clang::TypeSpecifierType)TypeSpecType,en}]{this,view(extra)na}</DisplayString>
     <Expand>
       <Item Name="StorageClassSpec">(clang::DeclSpec::SCS)StorageClassSpec</Item>
       <Item Name="TypeSpecType">(clang::TypeSpecifierType)TypeSpecType</Item>
-      <Item Name="TypeRep" Condition="TypeSpecType == TST_typename || TypeSpecType == TST_typeofType || TypeSpecType == TST_underlyingType || TypeSpecType == TST_atomic">
+      <Item Name="TypeRep" Condition="TypeSpecType == TST_typename || TypeSpecType == TST_typeofType || TypeSpecType == TST_underlying_type || TypeSpecType == TST_atomic">
         TypeRep
       </Item>
       <Item Name="ExprRep" Condition="TypeSpecType == TST_typeofExpr || TypeSpecType == TST_decltype">
         ExprRep
       </Item>
       <Item Name="DeclRep" Condition="TypeSpecType == TST_enum || TypeSpecType == TST_struct || TypeSpecType == TST_interface || TypeSpecType == TST_union || TypeSpecType == TST_class">
         DeclRep
       </Item>