[clang] retain type sugar in auto / template argument deduction

[mizvekov]

Summary

This implements the following changes:

• AutoType retains sugared deduced-as-type.
• Template argument deduction machinery analyses the sugared type all the way

down. It would previously lose the sugar on first recursion.

• Undeduced AutoType will be properly canonicalized, including the constraint

template arguments.

• Remove the decltype node created from the decltype(auto) deduction.

As a result, we start seeing sugared types in a lot more test cases,
including some which showed very unfriendly type-parameter-*-* types.

Signed-off-by: Matheus Izvekov <[e-mail]>

[mizvekov]

clang-tools-extra/clangd/unittests/InlayHintTests.cpp

470

Could you explain to me why the former behavior is more desirable here?

I initially understood that this hint should provide the type written in a form that would actually work if it replaced the 'auto'.
It is strange, but if it is just meant as a hint, it's still fine I guess.

Or maybe this was broken in the first place and just was just missing a FIXME?

[nridge]

clang-tools-extra/clangd/unittests/InlayHintTests.cpp

470

The type is being printed with a PrintingPolicy which has the non-default SuppressScope flag set.

The documentation of this flag says "Suppresses printing of scope specifiers", which I understand to mean both namespace and class scope specifiers.

If you're asking why we are using this flag for inlay hints, it's to keep the hints short so they don't take up too much horizontal space. Since the hints are displayed inline, hints that are too long can result in the line of code visually extending past the width of the editor window, and we try to minimize the impact of this.

[mizvekov]

clang-tools-extra/clangd/unittests/InlayHintTests.cpp

470

I see.

The problem is that the ElaboratedType sugar does not respect this when printing the nested name specifier it contains.
The quick fix of trying to make it respect it shows that there are a bunch of tests that expect it not to.
It seems that specific policy is used in places that need it to recover the type as written.

So if we want this behavior, we probably need to extend the printing policy with a new flag here.

[nridge]

clang-tools-extra/clangd/unittests/InlayHintTests.cpp

470

Thanks for the explanation!

I think this test expectation change is fine then, and would just suggest adding a "// FIXME: SuppressScope is not respected in this case" comment perhaps.

[rsmith]

Thanks, this is very exciting, and the diagnostic changes in the test suite look great!

clang-tools-extra/clangd/unittests/ASTTests.cpp

180

Very true. But probably not worth keeping the comment. :)

clang-tools-extra/test/clang-tidy/checkers/cert-static-object-exception.cpp

276 ↗

(On Diff #375314)

What happened here? It looks like nothing this expression does can actually throw. (This lambda's operator() isn't noexcept, but the functions it calls all are.) Was this only avoiding a false positive by accident before?

clang-tools-extra/test/clang-tidy/checkers/cppcoreguidelines-owning-memory.cpp

94–96

@JonasToth What was the intent here -- is there a specification for how gsl::owner is supposed to interact with auto deduction? That is, is this a bug fix or a regression?

clang/lib/Sema/SemaTemplateDeduction.cpp

242

I wonder if we can come up with a good heuristic for determining which of X and Y we want to return here. One thing that immediately springs to mind is: if either type is canonical, we should return the other one.

1037–1038

Hm, do we need the getUnqualifiedType() calls here? I'd expect that we'd have the TDF_IgnoreQualifiers flag set in this case, so we should be ignoring qualifiers anyway. Perhaps DeduceTemplateArgumentsByTypeMatch should be removing qualifiers itself if that flag is set?

1339

Par is an unusual name for a parameter type; Parm or Param would be more common and I'd find either of those to be clearer. (Ideally use the same spelling for Param and ParDesug.) Given that the description in the standard uses P and A as the names of these types, those names would be fine here too if you want something short.

1339–1351

Instead of tracking two types here, I think it'd be clearer to follow the more usual pattern in Clang: track only Param and Arg, use Arg->getAs<T>() instead of dyn_cast<T>(ArgDesug) to identify if Arg is sugar for a T, and use Arg->getAs<T>() instead of cast<T>(ArgDesug) to get a minimally-desugared T* from Arg.

The only place where I think we'd want something different from that is in the switch (Param->getTypeClass()) below, where I think we should switch on the type class of the canonical type (or equivalently on the type class of the desugared type, but it's cheaper and more obviously correct to ask for the type class of the canonical type).

1528–1529

Can we remove these? It looks like we're almost not using them at all, and that we shouldn't need to use them: any type matching should work equally well with the desugared type, and we never want to include these in our deduced results or our diagnostics.

1594–1599

This looks wrong to me: we should be comparing the types, not how they're written. Context.hasSameType(Param, Arg) (or Context.hasSameUnqualifiedType(Param, Arg) in the TDF_IgnoreQualifiers case) would be appropriate here.

1742–1743

Ignoring qualifiers here doesn't seem right to me. For example:

template<typename T> void f(T(T));
const int g(int);
void h() { f(g); }

... should result in a deduction failure, because we should get T = const int from the return type but T = int from the parameter type.

2181

Presumably this indentation change is unintended?

2248–2259

This suggests that we're passing in unresolved template arguments to this function. That seems problematic to me: those unresolved template arguments (as-written) will not be properly converted to the template's parameter type, will miss default arguments, and might not have had arguments properly combined into packs.

For *type* template arguments, I think it's fine to pass the argument as written if we're sure we know what it is, because basically no conversions apply for type template parameters and there may be meaningful sugar we want to preserve, but otherwise I think we should be passing in the resolved template argument.

4684

Hm, I see, adding the type sugar here presumably means that we get better diagnostic quality: we can complain that we can't deduce (eg) auto* against int instead of complaining that we can't deduce type-parameter-0-0* against int, right?

Can we remove the UseTypeSugar flag entirely now, or is it used for something else too?

clang/test/SemaCXX/cxx1z-class-template-argument-deduction.cpp

565

It'd be nice to check that this deduces the right type for T. I think this case would also be useful to test:

template<class T> void foo0(fptr1<T>) {
   using ExpectedT = const char*; 
   using ExpectedT = T;
}
void bar0(const char *const volatile __restrict);
void t0() { foo0(&bar0); }

569

Interesting, GCC rejects this due to the restrict qualifier mismatch. But I think accepting is correct.

clang/test/SemaTemplate/attributes.cpp

127–129

Looks like we'll need to use a different mechanism to remove the type sugar in this test. (Maybe one day we'll run out of ways to remove type sugar and we won't need this test any more!)

[v.g.vassilev]

Thanks for working on this! How hard would it be to support:

using size_t = __SIZE_TYPE__;
template<typename T> struct Id { typedef T type; };
int main() {
  struct S {} s;
  Id<size_t>::type f = s; // just 'unsigned long', 'size_t' sugar has been lost
}

[mizvekov]

In D110216#3032626, @v.g.vassilev wrote:

Thanks for working on this!How hard would it be to support:

using size_t = __SIZE_TYPE__;
template<typename T> struct Id { typedef T type; };
int main() {
  struct S {} s;
  Id<size_t>::type f = s; // just 'unsigned long', 'size_t' sugar has been lost
}

Actually supporting that is in my radar :)

Getting the basic idea up is not too complicated.
We need to support 'alias' template specializations which can carry non-canonical arguments,
and they would just point to the canonical template specializations.
We would then have to implement our desugaring of 'SubstTemplateTypeParmType' so it's able to access some context where it can get the correctly sugared ReplacementType for the given replaced 'TemplateTypeParmType'.

But there are some little details that need to be implemented so that it is reasonably usable.
For example, in the general case we cannot currently, for any given declaration, figure out the template arguments used to instantiate it. We can do it for class and function templates, but not for alias and variable templates.
We need to make anything that carries template arguments also be a declaration context, so we can walk up from any declaration and see those.

There is also the trouble that some elements are not properly parented. For example in a requires clause:
template <class T> requires WHATEVER struct X {}, WHATEVER is not currently parented to the class template, so we would not be able to recover the instantiation arguments there unless we fixed it.

And who knows what other non-obvious problems might be lurking :)

A lot of what I said also overlaps with what we need to properly support lazy substitution, such as required by C++20 concepts, which is also something I am working on.

Getting the 'template argument deduction' machinery to preserve the sugar, which we do in this patch, certainly benefits when we get there.

In D110216#3031531, @rsmith wrote:

Thanks, this is very exciting, and the diagnostic changes in the test suite look great!

Thank you, much appreciated, and also thanks for the review!

clang-tools-extra/test/clang-tidy/checkers/cert-static-object-exception.cpp

276 ↗

(On Diff #375314)

I haven't debugged it, I was hoping @aaron.ballman would know something about it and it would save me the trouble :)

clang/lib/Sema/SemaTemplateDeduction.cpp

242

I was thinking about the opposite actually, something along the lines of returning the common sugar between them. Starting from the cannonical type and going 'backwards' (adding back the sugar), we return the type just before adding sugar back would make them different.

1037–1038

The case I am worried about is checking the parameters in the function prototype case, and TDF_IgnoreQualifiers is neither set there, nor it would help if it was set anyway.
I will take a look again, but this was the simplest solution I could come up at the time.

1742–1743

Right, I must have simply assumed we had the same situation here with regards to function prototype parameters.

This feels like a standard defect to me, we should not be looking at top level qualifiers on return types :)

2181

arc lint decided to add it automatically, and I decided not to fight it :-)

2248–2259

Sure, I will revert that, presumably because this would be a separate can of worms we should not deal in this patch, but ideally we would get back to this so we can actually see some sugar here?

4684

The primary reason for it was moving in the direction of removing this flag.
We don't need it anymore in this case, although there are other users of it that need to be cleaned up. This one was just flipping the flag here, so I said why the heck not.
But other users are a bit more complicated, and I was afraid the patch was getting too big.

This could help improving the diagnostics in the future I suppose, but right now we are not using the result of the template argument deduction here very much, just for inconsistent deduction from initializer lists, the rest we defer to a generic variable 'foo' with type 'bar' has incompatible initializer of type 'baz'.

[mizvekov]

clang/lib/Sema/SemaTemplateDeduction.cpp

1594–1599

You are right, but the reason we don't get into any troubles here is because this is dead code anyway, the non-dependent case will always be handled above :)

Although perhaps, I wonder if we should dig down into non-dependent types anyway, in case the types are too complex and it's not immediately obvious what does not match, we could perhaps improve the diagnostic?

I will experiment a little bit with this idea.

[mizvekov]

clang/lib/Sema/SemaTemplateDeduction.cpp

1594–1599

Here are the results of this experiment:

error: 'note' diagnostics expected but not seen:
  File SemaCXX\cxx1z-noexcept-function-type.cpp Line 21: could not match 'void (I) noexcept(false)' (aka 'void (int) noexcept(false)') against 'void (int) noexcept'
error: 'note' diagnostics seen but not expected:
  File SemaCXX\cxx1z-noexcept-function-type.cpp Line 21: candidate template ignored: failed template argument deduction

error: 'note' diagnostics expected but not seen:
  File SemaCXX\deduced-return-type-cxx14.cpp Line 146: candidate template ignored: could not match 'auto ()' against 'int ()'
  File SemaCXX\deduced-return-type-cxx14.cpp Line 161: candidate template ignored: could not match 'auto ()' against 'void ()'
error: 'note' diagnostics seen but not expected:
  File SemaCXX\deduced-return-type-cxx14.cpp Line 146: candidate template ignored: could not match 'auto' against 'int'
  File SemaCXX\deduced-return-type-cxx14.cpp Line 161: candidate template ignored: could not match 'auto' against 'void'

error: 'note' diagnostics expected but not seen:
  File SemaCXX\pass-object-size.cpp Line 62 (directive at SemaCXX\pass-object-size.cpp:69): candidate address cannot be taken because parameter 1 has pass_object_size attribute
  File SemaCXX\pass-object-size.cpp Line 56 (directive at SemaCXX\pass-object-size.cpp:74): candidate address cannot be taken because parameter 1 has pass_object_size attribute
  File SemaCXX\pass-object-size.cpp Line 62 (directive at SemaCXX\pass-object-size.cpp:75): candidate address cannot be taken because parameter 1 has pass_object_size attribute
error: 'note' diagnostics seen but not expected:
  File SemaCXX\pass-object-size.cpp Line 56: candidate template ignored: failed template argument deduction
  File SemaCXX\pass-object-size.cpp Line 62: candidate template ignored: failed template argument deduction
  File SemaCXX\pass-object-size.cpp Line 62: candidate template ignored: failed template argument deduction

error: 'note' diagnostics expected but not seen:
  File SemaTemplate\deduction.cpp Line 316: deduced non-type template argument does not have the same type as the corresponding template parameter ('std::nullptr_t' vs 'int *')
  File SemaTemplate\deduction.cpp Line 323: values of conflicting types
error: 'note' diagnostics seen but not expected:
  File SemaTemplate\deduction.cpp Line 275: candidate template ignored: could not match 'const int' against 'int'
  File SemaTemplate\deduction.cpp Line 316: candidate template ignored: could not match 'int *' against 'std::nullptr_t'
  File SemaTemplate\deduction.cpp Line 323: candidate template ignored: could not match 'int *' against 'std::nullptr_t'

error: 'note' diagnostics expected but not seen:
  File SemaTemplate\explicit-instantiation.cpp Line 64: candidate template ignored: could not match 'void ()' against 'void (float *)'
  File SemaTemplate\explicit-instantiation.cpp Line 70: candidate template ignored: could not match 'void (int *)' against 'void (float *)'
error: 'note' diagnostics seen but not expected:
  File SemaTemplate\explicit-instantiation.cpp Line 70: candidate template ignored: could not match 'int' against 'float'
  File SemaTemplate\explicit-instantiation.cpp Line 64: candidate template ignored: failed template argument deduction

It's interesting to note that it reveals several cases we give too generic 'failed template argument deduction' errors, like the different noexcept specifications, function prototypes with different amount of parameters, and the 'pass_object_size attribute' case.

[mizvekov]

• Address most comments / requests.

Still missing:

• Maybe do something about ASTImporter regression.
• Debug change in behavior in cert-static-object-exception.cpp.

[mizvekov]

clang-tools-extra/clangd/unittests/ASTTests.cpp

180

Such a party pooper =)

clang/lib/Sema/SemaTemplateDeduction.cpp

1339–1351

There was one small catch in your suggestion:
Using getAs on TemplateSpecializationType is a bit tricky because that type can be sugar as well, so you might end up with a type alias instead of the underlying thing you wanted. I think that was the only tricky type though.
And it was productive that I ran into this problem, because I ended up discovering some cases where we were losing some sugar there, and there was a tiny diagnostic improvement in one of the test cases as a result.

[mizvekov]

• Fix issue with ASTMatcher only looking through one layer of DeducedType. This fix makes cert-static-object-exception.cpp not affected by this patch anymore.

[mizvekov]

• Fix ASTImporter regression.

[v.g.vassilev]

In D110216#3035041, @mizvekov wrote:

In D110216#3032626, @v.g.vassilev wrote:

Thanks for working on this!How hard would it be to support:

using size_t = __SIZE_TYPE__;
template<typename T> struct Id { typedef T type; };
int main() {
  struct S {} s;
  Id<size_t>::type f = s; // just 'unsigned long', 'size_t' sugar has been lost
}

Actually supporting that is in my radar :)

Over the years we had some interest from people but never actually got implemented. Here were some ideas @rsmith and I discussed over the years. If that is helpful, let me know if I should dig a bit more into private email exchange.

[mizvekov]

In D110216#3038797, @v.g.vassilev wrote:

Over the years we had some interest from people but never actually got implemented. Here were some ideas @rsmith and I discussed over the years. If that is helpful, let me know if I should dig a bit more into private email exchange.

Sure, that is helpful :)

There is other lower hanging fruit where we are losing sugar, and it would be a shame if we implemented this but then did not get much benefit from it because the sugar never got into the template argument in the first place.

One such example is that we do not mark as 'elaborate' types which are written bare, without any scope specifiers.

So for example in a case like this:

namespace foo {
  struct Foo {};
  Foo x = 0;
};

We would still diagnose that assignment with the type of the variable printed as 'foo::Foo' instead of just 'Foo', as it was written, because the parser will have produced a type that is not wrapped in an ElaboratedType (or perhaps some other cheaper mechanism).

[v.g.vassilev]

In D110216#3038826, @mizvekov wrote:

In D110216#3038797, @v.g.vassilev wrote:

Over the years we had some interest from people but never actually got implemented. Here were some ideas @rsmith and I discussed over the years. If that is helpful, let me know if I should dig a bit more into private email exchange.

Sure, that is helpful :)

There is other lower hanging fruit where we are losing sugar, and it would be a shame if we implemented this but then did not get much benefit from it because the sugar never got into the template argument in the first place.

One such example is that we do not mark as 'elaborate' types which are written bare, without any scope specifiers.

So for example in a case like this:

namespace foo {
  struct Foo {};
  Foo x = 0;
};

We would still diagnose that assignment with the type of the variable printed as 'foo::Foo' instead of just 'Foo', as it was written, because the parser will have produced a type that is not wrapped in an ElaboratedType (or perhaps some other cheaper mechanism).

Handling that case is nice. I am more interested in retaining the sugar in template instantiations as it is essential for an optimization in our I/O system which uses clang as a library. If implement the instantiation diagnostic we can get rid of several hacky patches: https://github.com/vgvassilev/clang/commit/d87e2bbc8a266e295ee5a2065f1e587b325d4284 https://github.com/vgvassilev/clang/commit/fcc492fcab14e8b8dc156688dda6f237a04563a7 and https://github.com/vgvassilev/clang/commit/fe17b953325530267643f3391bfd59ac1519ef39

clang/lib/Sema/SemaTemplateDeduction.cpp

1419–1421

1778

[mizvekov]

• Address v.g.vassilev's suggestions.

[craig.topper]

clang/include/clang/ASTMatchers/ASTMatchersInternal.h

1031–1032

gcc 8.4.1 doesn't like T being the same name as a template parameter for this class.

[craig.topper]

Looks like this fixes PR51282.

[mizvekov]

In D110216#3040748, @craig.topper wrote:

Looks like this fixes PR51282.

Okay, interesting. This could be just papering over the bug.
I will take a careful look at it later.

clang/include/clang/ASTMatchers/ASTMatchersInternal.h

1031–1032

Oh wow, didn't even realize, thanks!!

[mizvekov]

• Rename variable so it doesn't shadow template parameter.

[mizvekov]

In D110216#3040748, @craig.topper wrote:

Looks like this fixes PR51282.

I guess it does fix it, but the underlying implementation of alignment is very fragile. The alignment is stored in AttributedType nodes, which are always sugar, so they are not considered part of the type in a structural sense...

[aaronpuchert]

In D110216#3041117, @mizvekov wrote:

In D110216#3040748, @craig.topper wrote:

Looks like this fixes PR51282.

I guess it does fix it, but the underlying implementation of alignment is very fragile. The alignment is stored in AttributedType nodes, which are always sugar, so they are not considered part of the type in a structural sense...

Unless I'm missing something, alignment on aliases is itself fragile. Let's say you have some template, then the instantiation with the alias is of course the same as the instantiation with the canonical type, so if that template has a member or local variable of that type parameter that won't get the alignment.

[mizvekov]

In D110216#3044102, @aaronpuchert wrote:

Unless I'm missing something, alignment on aliases is itself fragile. Let's say you have some template, then the instantiation with the alias is of course the same as the instantiation with the canonical type, so if that template has a member or local variable of that type parameter that won't get the alignment.

If the attribute was not just type sugar and could be made part of the canonical type, then the attribute would have to be attached to the canonical type of the alias when building it,
in a similar way to how you don't lose other structural parts of the type when canonicalizing it.

But then you would have to deal with the whole mess this would cause in the rest of clang :)

[mizvekov]

clang/lib/Sema/SemaTemplateDeduction.cpp

242

I have a proposal for what to do here in this patch: https://reviews.llvm.org/D111283

I think it's ready except that it needs more manual labor to support digging down into more types.

Anyway, this patch above refines the behavior of the present one, by implementing a criteria to fold the type sugar when deduction happens from multiple arguments,
or in the case of deducing from auto returning function, to fold them from the multiple return statements.

Otherwise, as in the present patch, the sugar is considered only from the first argument deduced from.

So any stakeholders, please subscribe and provide feedback about the rules as they are implemented :)

[mizvekov]

rebase.

[mizvekov]

.

[rsmith]

clang/include/clang/AST/Type.h

4960–4962

clang/lib/AST/ASTImporter.cpp

3182

3190–3191

(Preparing for D112374)

clang/lib/Sema/SemaTemplateDeduction.cpp

1153–1154

The == comparisons here and below should presumably be hasSameType comparisons now that we're preserving sugar.

1238–1254

I think we should:

• track ToVisit as a vector of QualType, so we preserve the type sugar as written in base specifier lists
• track Visited as a set of (canonical) const CXXRecordDecl*s rather than relying on RecordTypes always being canonical (they currently are, but I don't think that's intended to be guaranteed)

1390–1393

Do we need to use Context.getUnqualifiedArrayType here, for cases like:

typedef const int CInt;
// Partial ordering should deduce `T = int` from both parameters here,
// even though `T = const int` might make more sense for the first one.
template<int N> void f(CInt (&)[N], int*);
template<int N, typename T> void f(T (&)[N], T*);
CInt arr[5];
void g() { f(arr, arr); }

? I think getUnqualifiedType() on CInt[N] will not remove the indirect const qualifier.

1442

A could be sugar for an array type here.

1551–1568

I think we can excise CanA and CanP entirely here so people aren't tempted to use them and lose sugar.

1594–1599

Hm, this doesn't seem to be an improvement; I think it's better to present the larger non-matching types and use %diff in the diagnostic to highlight the part that differs. Especially because we don't provide a source location for (eg) where in the type we found a float, providing the more complete context of (eg) void (float*) seems more useful.

[mizvekov]

Address rsmith's review comments.

[mizvekov]

clang/lib/AST/ASTImporter.cpp

3190–3191

Good catch, thanks :)

clang/lib/Sema/SemaTemplateDeduction.cpp

1390–1393

I see, that is true, if P and A could be sugared here, we would need getUnqualifiedArrayType.

But this issue had been sidestepped because we were not handling sugar in the PartialOrdering case, because that was only used in the isAtLeastAsSpecialized path where we were still using the canonical type, as we don't care about what types where actually deduced there.

I just changed it to not use the canonical type anymore and took this change.

1551–1568

Nice suggestion!

Though we must keep the last return as conditional, as I did there, otherwise we
break a test case such as the one from PR12132:

template<typename S> void fun(const int* const S::* member) {}
struct A { int* x; };
void foo() {
    fun(&A::x);
}

When ignoring qualifiers, hasSameUnqualifiedType being false is not enough to deduce a mismatch, so this is the one corner case where we analyze with a non-dependent parameter type.

That is what I tried to explain in that comment, but I have just reworded it to be clearer on this point.

[rsmith]

Awesome!

clang/lib/Sema/SemaTemplateDeduction.cpp

559

Does this matter on the P side? (Can we remove this FIXME?)

561

Can we avoid using the Internal version here? (The only difference is whether we preserve top-level qualifiers that are outside any type sugar.)

Might also be worth a comment here explaining that we're going to the canonical type first here to step over any alias templates.

566–569

I think we can retain type sugar here without too much effort.

568

[mizvekov]

address last comments, one last CI push.

[mizvekov]

clang/lib/Sema/SemaTemplateDeduction.cpp

559

Even though P sugar is not relevant to the deduced type, it is relevant to diagnostics when there is a deduction failure. This has been relevant in the other parts of this patch, so I don't see why we would not at least want to preserve it here, though it might be too much trouble to be worth the effort.

I will keep the comment for now, if we have any discussion where it becomes clear there would be no difference here, I will make a one line NFC and remove it.

561

The Internal version is more convenient because TP is a Type * not a QualType, so the suggestion as you have written would not work.

Removing the alias template would be handled by getUnqualifiedDesugaredType, above, which my understanding is that will remove all top level sugar.

But I see that I went all this way around to preserving the non-canonical TP but all I needed really from it was the templateName, which probably is always the same as the canonical one, though not sure if that is by design.

I just made a change to get the canonical type on TP above instead, and we can circle back to this later.

566–569

That does not work, blows up some 80 tests.
I will leave the FIXME and circle back to this after I am done with my pile of patches.

[phosek]

This change seems to have broken two libc++ tests:

libc++ :: std/utilities/any/any.nonmembers/any.cast/const_correctness.fail.cpp

Script:
--
: 'COMPILED WITH';  /b/s/w/ir/x/w/staging/llvm_build/./bin/clang++ /b/s/w/ir/x/w/llvm-project/libcxx/test/std/utilities/any/any.nonmembers/any.cast/const_correctness.fail.cpp -v --sysroot=/b/s/w/ir/x/w/cipd/linux --target=x86_64-unknown-linux-gnu -include /b/s/w/ir/x/w/llvm-project/libcxx/test/support/nasty_macros.h -nostdinc++ -I/b/s/w/ir/x/w/staging/llvm_build/include/x86_64-unknown-linux-gnu/c++/v1 -I/b/s/w/ir/x/w/staging/llvm_build/include/c++/v1 -I/b/s/w/ir/x/w/staging/llvm_build/runtimes/runtimes-x86_64-unknown-linux-gnu-bins/libcxx/include/c++build -D__STDC_FORMAT_MACROS -D__STDC_LIMIT_MACROS -D__STDC_CONSTANT_MACROS -I/b/s/w/ir/x/w/llvm-project/libcxx/test/support -std=c++2b -Werror -Wall -Wextra -Wshadow -Wundef -Wno-unused-command-line-argument -Wno-attributes -Wno-pessimizing-move -Wno-c++11-extensions -Wno-user-defined-literals -Wno-noexcept-type -Wno-atomic-alignment -Wsign-compare -Wunused-variable -Wunused-parameter -Wunreachable-code -Wno-unused-local-typedef -D_LIBCPP_DISABLE_AVAILABILITY -fcoroutines-ts -Werror=thread-safety -Wuser-defined-warnings -D_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER -Wno-macro-redefined -D_LIBCPP_HAS_THREAD_API_PTHREAD -Wno-macro-redefined -D_LIBCPP_ABI_VERSION=2  -fsyntax-only -Wno-error -Xclang -verify -Xclang -verify-ignore-unexpected=note -ferror-limit=0
--
Exit Code: 1

Command Output (stdout):
--
$ ":" "COMPILED WITH"
$ "/b/s/w/ir/x/w/staging/llvm_build/./bin/clang++" "/b/s/w/ir/x/w/llvm-project/libcxx/test/std/utilities/any/any.nonmembers/any.cast/const_correctness.fail.cpp" "-v" "--sysroot=/b/s/w/ir/x/w/cipd/linux" "--target=x86_64-unknown-linux-gnu" "-include" "/b/s/w/ir/x/w/llvm-project/libcxx/test/support/nasty_macros.h" "-nostdinc++" "-I/b/s/w/ir/x/w/staging/llvm_build/include/x86_64-unknown-linux-gnu/c++/v1" "-I/b/s/w/ir/x/w/staging/llvm_build/include/c++/v1" "-I/b/s/w/ir/x/w/staging/llvm_build/runtimes/runtimes-x86_64-unknown-linux-gnu-bins/libcxx/include/c++build" "-D__STDC_FORMAT_MACROS" "-D__STDC_LIMIT_MACROS" "-D__STDC_CONSTANT_MACROS" "-I/b/s/w/ir/x/w/llvm-project/libcxx/test/support" "-std=c++2b" "-Werror" "-Wall" "-Wextra" "-Wshadow" "-Wundef" "-Wno-unused-command-line-argument" "-Wno-attributes" "-Wno-pessimizing-move" "-Wno-c++11-extensions" "-Wno-user-defined-literals" "-Wno-noexcept-type" "-Wno-atomic-alignment" "-Wsign-compare" "-Wunused-variable" "-Wunused-parameter" "-Wunreachable-code" "-Wno-unused-local-typedef" "-D_LIBCPP_DISABLE_AVAILABILITY" "-fcoroutines-ts" "-Werror=thread-safety" "-Wuser-defined-warnings" "-D_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER" "-Wno-macro-redefined" "-D_LIBCPP_HAS_THREAD_API_PTHREAD" "-Wno-macro-redefined" "-D_LIBCPP_ABI_VERSION=2" "-fsyntax-only" "-Wno-error" "-Xclang" "-verify" "-Xclang" "-verify-ignore-unexpected=note" "-ferror-limit=0"
# command stderr:
Fuchsia clang version 14.0.0 (https://llvm.googlesource.com/a/llvm-project e1d6f29a1e640e267e1d2b94d0d761e1d15e99bd)
Target: x86_64-unknown-linux-gnu
Thread model: posix
InstalledDir: /b/s/w/ir/x/w/staging/llvm_build/./bin
Found candidate GCC installation: /b/s/w/ir/x/w/cipd/linux/usr/lib/gcc/i586-linux-gnu/4.8
Found candidate GCC installation: /b/s/w/ir/x/w/cipd/linux/usr/lib/gcc/x86_64-linux-gnu/4.8
Selected GCC installation: /b/s/w/ir/x/w/cipd/linux/usr/lib/gcc/x86_64-linux-gnu/4.8
Candidate multilib: .;@m64
Selected multilib: .;@m64
 (in-process)
 "/b/s/w/ir/x/w/staging/llvm_build/bin/clang-14" -cc1 -triple x86_64-unknown-linux-gnu -fsyntax-only -disable-free -clear-ast-before-backend -main-file-name const_correctness.fail.cpp -mrelocation-model static -mframe-pointer=all -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -v -fcoverage-compilation-dir=/b/s/w/ir/x/w/staging/llvm_build/runtimes/runtimes-x86_64-unknown-linux-gnu-bins/libcxx/test/std/utilities/any/any.nonmembers/any.cast -nostdinc++ -resource-dir /b/s/w/ir/x/w/staging/llvm_build/lib/clang/14.0.0 -include /b/s/w/ir/x/w/llvm-project/libcxx/test/support/nasty_macros.h -I /b/s/w/ir/x/w/staging/llvm_build/include/x86_64-unknown-linux-gnu/c++/v1 -I /b/s/w/ir/x/w/staging/llvm_build/include/c++/v1 -I /b/s/w/ir/x/w/staging/llvm_build/runtimes/runtimes-x86_64-unknown-linux-gnu-bins/libcxx/include/c++build -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -D __STDC_CONSTANT_MACROS -I /b/s/w/ir/x/w/llvm-project/libcxx/test/support -D _LIBCPP_DISABLE_AVAILABILITY -D _LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER -D _LIBCPP_HAS_THREAD_API_PTHREAD -D _LIBCPP_ABI_VERSION=2 -isysroot /b/s/w/ir/x/w/cipd/linux -internal-isystem /b/s/w/ir/x/w/staging/llvm_build/lib/clang/14.0.0/include -internal-isystem /b/s/w/ir/x/w/cipd/linux/usr/local/include -internal-isystem /b/s/w/ir/x/w/cipd/linux/usr/lib/gcc/x86_64-linux-gnu/4.8/../../../../x86_64-linux-gnu/include -internal-externc-isystem /b/s/w/ir/x/w/cipd/linux/usr/include/x86_64-linux-gnu -internal-externc-isystem /b/s/w/ir/x/w/cipd/linux/include -internal-externc-isystem /b/s/w/ir/x/w/cipd/linux/usr/include -Werror -Wall -Wextra -Wshadow -Wundef -Wno-unused-command-line-argument -Wno-attributes -Wno-pessimizing-move -Wno-c++11-extensions -Wno-user-defined-literals -Wno-noexcept-type -Wno-atomic-alignment -Wsign-compare -Wunused-variable -Wunused-parameter -Wunreachable-code -Wno-unused-local-typedef -Werror=thread-safety -Wuser-defined-warnings -Wno-macro-redefined -Wno-macro-redefined -Wno-error -std=c++2b -fdeprecated-macro -fdebug-compilation-dir=/b/s/w/ir/x/w/staging/llvm_build/runtimes/runtimes-x86_64-unknown-linux-gnu-bins/libcxx/test/std/utilities/any/any.nonmembers/any.cast -ferror-limit 0 -fcoroutines-ts -fgnuc-version=4.2.1 -fcxx-exceptions -fexceptions -verify -verify-ignore-unexpected=note -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -x c++ /b/s/w/ir/x/w/llvm-project/libcxx/test/std/utilities/any/any.nonmembers/any.cast/const_correctness.fail.cpp
clang -cc1 version 14.0.0 based upon LLVM 14.0.0git default target x86_64-unknown-linux-gnu
ignoring nonexistent directory "/b/s/w/ir/x/w/cipd/linux/usr/local/include"
ignoring nonexistent directory "/b/s/w/ir/x/w/cipd/linux/usr/lib/gcc/x86_64-linux-gnu/4.8/../../../../x86_64-linux-gnu/include"
ignoring nonexistent directory "/b/s/w/ir/x/w/cipd/linux/include"
#include "..." search starts here:
#include <...> search starts here:
 /b/s/w/ir/x/w/staging/llvm_build/include/x86_64-unknown-linux-gnu/c++/v1
 /b/s/w/ir/x/w/staging/llvm_build/include/c++/v1
 /b/s/w/ir/x/w/staging/llvm_build/runtimes/runtimes-x86_64-unknown-linux-gnu-bins/libcxx/include/c++build
 /b/s/w/ir/x/w/llvm-project/libcxx/test/support
 /b/s/w/ir/x/w/staging/llvm_build/lib/clang/14.0.0/include
 /b/s/w/ir/x/w/cipd/linux/usr/include/x86_64-linux-gnu
 /b/s/w/ir/x/w/cipd/linux/usr/include
End of search list.
error: 'error' diagnostics expected but not seen: 
  File /b/s/w/ir/x/w/staging/llvm_build/include/c++/v1/any Line * (directive at /b/s/w/ir/x/w/llvm-project/libcxx/test/std/utilities/any/any.nonmembers/any.cast/const_correctness.fail.cpp:37): cannot cast from lvalue of type 'const TestType' to rvalue reference type 'TestType &&'; types are not compatible
  File /b/s/w/ir/x/w/staging/llvm_build/include/c++/v1/any Line * (directive at /b/s/w/ir/x/w/llvm-project/libcxx/test/std/utilities/any/any.nonmembers/any.cast/const_correctness.fail.cpp:45): cannot cast from lvalue of type 'const TestType2' to rvalue reference type 'TestType2 &&'; types are not compatible
error: 'error' diagnostics seen but not expected: 
  File /b/s/w/ir/x/w/staging/llvm_build/include/c++/v1/any Line 605: cannot cast from lvalue of type 'typename remove_reference<const TestType>::type' (aka 'const TestType') to rvalue reference type 'TestType &&'; types are not compatible
  File /b/s/w/ir/x/w/staging/llvm_build/include/c++/v1/any Line 605: cannot cast from lvalue of type 'typename remove_reference<const TestType2>::type' (aka 'const TestType2') to rvalue reference type 'TestType2 &&'; types are not compatible
4 errors generated.

error: command failed with exit status: 1

--

libc++ :: std/utilities/any/any.nonmembers/any.cast/not_copy_constructible.fail.cpp

Script:
--
: 'COMPILED WITH';  /b/s/w/ir/x/w/staging/llvm_build/./bin/clang++ /b/s/w/ir/x/w/llvm-project/libcxx/test/std/utilities/any/any.nonmembers/any.cast/not_copy_constructible.fail.cpp -v --sysroot=/b/s/w/ir/x/w/cipd/linux --target=x86_64-unknown-linux-gnu -include /b/s/w/ir/x/w/llvm-project/libcxx/test/support/nasty_macros.h -nostdinc++ -I/b/s/w/ir/x/w/staging/llvm_build/include/x86_64-unknown-linux-gnu/c++/v1 -I/b/s/w/ir/x/w/staging/llvm_build/include/c++/v1 -I/b/s/w/ir/x/w/staging/llvm_build/runtimes/runtimes-x86_64-unknown-linux-gnu-bins/libcxx/include/c++build -D__STDC_FORMAT_MACROS -D__STDC_LIMIT_MACROS -D__STDC_CONSTANT_MACROS -I/b/s/w/ir/x/w/llvm-project/libcxx/test/support -std=c++2b -Werror -Wall -Wextra -Wshadow -Wundef -Wno-unused-command-line-argument -Wno-attributes -Wno-pessimizing-move -Wno-c++11-extensions -Wno-user-defined-literals -Wno-noexcept-type -Wno-atomic-alignment -Wsign-compare -Wunused-variable -Wunused-parameter -Wunreachable-code -Wno-unused-local-typedef -D_LIBCPP_DISABLE_AVAILABILITY -fcoroutines-ts -Werror=thread-safety -Wuser-defined-warnings -D_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER -Wno-macro-redefined -D_LIBCPP_HAS_THREAD_API_PTHREAD -Wno-macro-redefined -D_LIBCPP_ABI_VERSION=2  -fsyntax-only -Wno-error -Xclang -verify -Xclang -verify-ignore-unexpected=note -ferror-limit=0
--
Exit Code: 1

Command Output (stdout):
--
$ ":" "COMPILED WITH"
$ "/b/s/w/ir/x/w/staging/llvm_build/./bin/clang++" "/b/s/w/ir/x/w/llvm-project/libcxx/test/std/utilities/any/any.nonmembers/any.cast/not_copy_constructible.fail.cpp" "-v" "--sysroot=/b/s/w/ir/x/w/cipd/linux" "--target=x86_64-unknown-linux-gnu" "-include" "/b/s/w/ir/x/w/llvm-project/libcxx/test/support/nasty_macros.h" "-nostdinc++" "-I/b/s/w/ir/x/w/staging/llvm_build/include/x86_64-unknown-linux-gnu/c++/v1" "-I/b/s/w/ir/x/w/staging/llvm_build/include/c++/v1" "-I/b/s/w/ir/x/w/staging/llvm_build/runtimes/runtimes-x86_64-unknown-linux-gnu-bins/libcxx/include/c++build" "-D__STDC_FORMAT_MACROS" "-D__STDC_LIMIT_MACROS" "-D__STDC_CONSTANT_MACROS" "-I/b/s/w/ir/x/w/llvm-project/libcxx/test/support" "-std=c++2b" "-Werror" "-Wall" "-Wextra" "-Wshadow" "-Wundef" "-Wno-unused-command-line-argument" "-Wno-attributes" "-Wno-pessimizing-move" "-Wno-c++11-extensions" "-Wno-user-defined-literals" "-Wno-noexcept-type" "-Wno-atomic-alignment" "-Wsign-compare" "-Wunused-variable" "-Wunused-parameter" "-Wunreachable-code" "-Wno-unused-local-typedef" "-D_LIBCPP_DISABLE_AVAILABILITY" "-fcoroutines-ts" "-Werror=thread-safety" "-Wuser-defined-warnings" "-D_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER" "-Wno-macro-redefined" "-D_LIBCPP_HAS_THREAD_API_PTHREAD" "-Wno-macro-redefined" "-D_LIBCPP_ABI_VERSION=2" "-fsyntax-only" "-Wno-error" "-Xclang" "-verify" "-Xclang" "-verify-ignore-unexpected=note" "-ferror-limit=0"
# command stderr:
Fuchsia clang version 14.0.0 (https://llvm.googlesource.com/a/llvm-project e1d6f29a1e640e267e1d2b94d0d761e1d15e99bd)
Target: x86_64-unknown-linux-gnu
Thread model: posix
InstalledDir: /b/s/w/ir/x/w/staging/llvm_build/./bin
Found candidate GCC installation: /b/s/w/ir/x/w/cipd/linux/usr/lib/gcc/i586-linux-gnu/4.8
Found candidate GCC installation: /b/s/w/ir/x/w/cipd/linux/usr/lib/gcc/x86_64-linux-gnu/4.8
Selected GCC installation: /b/s/w/ir/x/w/cipd/linux/usr/lib/gcc/x86_64-linux-gnu/4.8
Candidate multilib: .;@m64
Selected multilib: .;@m64
 (in-process)
 "/b/s/w/ir/x/w/staging/llvm_build/bin/clang-14" -cc1 -triple x86_64-unknown-linux-gnu -fsyntax-only -disable-free -clear-ast-before-backend -main-file-name not_copy_constructible.fail.cpp -mrelocation-model static -mframe-pointer=all -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -v -fcoverage-compilation-dir=/b/s/w/ir/x/w/staging/llvm_build/runtimes/runtimes-x86_64-unknown-linux-gnu-bins/libcxx/test/std/utilities/any/any.nonmembers/any.cast -nostdinc++ -resource-dir /b/s/w/ir/x/w/staging/llvm_build/lib/clang/14.0.0 -include /b/s/w/ir/x/w/llvm-project/libcxx/test/support/nasty_macros.h -I /b/s/w/ir/x/w/staging/llvm_build/include/x86_64-unknown-linux-gnu/c++/v1 -I /b/s/w/ir/x/w/staging/llvm_build/include/c++/v1 -I /b/s/w/ir/x/w/staging/llvm_build/runtimes/runtimes-x86_64-unknown-linux-gnu-bins/libcxx/include/c++build -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -D __STDC_CONSTANT_MACROS -I /b/s/w/ir/x/w/llvm-project/libcxx/test/support -D _LIBCPP_DISABLE_AVAILABILITY -D _LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER -D _LIBCPP_HAS_THREAD_API_PTHREAD -D _LIBCPP_ABI_VERSION=2 -isysroot /b/s/w/ir/x/w/cipd/linux -internal-isystem /b/s/w/ir/x/w/staging/llvm_build/lib/clang/14.0.0/include -internal-isystem /b/s/w/ir/x/w/cipd/linux/usr/local/include -internal-isystem /b/s/w/ir/x/w/cipd/linux/usr/lib/gcc/x86_64-linux-gnu/4.8/../../../../x86_64-linux-gnu/include -internal-externc-isystem /b/s/w/ir/x/w/cipd/linux/usr/include/x86_64-linux-gnu -internal-externc-isystem /b/s/w/ir/x/w/cipd/linux/include -internal-externc-isystem /b/s/w/ir/x/w/cipd/linux/usr/include -Werror -Wall -Wextra -Wshadow -Wundef -Wno-unused-command-line-argument -Wno-attributes -Wno-pessimizing-move -Wno-c++11-extensions -Wno-user-defined-literals -Wno-noexcept-type -Wno-atomic-alignment -Wsign-compare -Wunused-variable -Wunused-parameter -Wunreachable-code -Wno-unused-local-typedef -Werror=thread-safety -Wuser-defined-warnings -Wno-macro-redefined -Wno-macro-redefined -Wno-error -std=c++2b -fdeprecated-macro -fdebug-compilation-dir=/b/s/w/ir/x/w/staging/llvm_build/runtimes/runtimes-x86_64-unknown-linux-gnu-bins/libcxx/test/std/utilities/any/any.nonmembers/any.cast -ferror-limit 0 -fcoroutines-ts -fgnuc-version=4.2.1 -fcxx-exceptions -fexceptions -verify -verify-ignore-unexpected=note -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -x c++ /b/s/w/ir/x/w/llvm-project/libcxx/test/std/utilities/any/any.nonmembers/any.cast/not_copy_constructible.fail.cpp
clang -cc1 version 14.0.0 based upon LLVM 14.0.0git default target x86_64-unknown-linux-gnu
ignoring nonexistent directory "/b/s/w/ir/x/w/cipd/linux/usr/local/include"
ignoring nonexistent directory "/b/s/w/ir/x/w/cipd/linux/usr/lib/gcc/x86_64-linux-gnu/4.8/../../../../x86_64-linux-gnu/include"
ignoring nonexistent directory "/b/s/w/ir/x/w/cipd/linux/include"
#include "..." search starts here:
#include <...> search starts here:
 /b/s/w/ir/x/w/staging/llvm_build/include/x86_64-unknown-linux-gnu/c++/v1
 /b/s/w/ir/x/w/staging/llvm_build/include/c++/v1
 /b/s/w/ir/x/w/staging/llvm_build/runtimes/runtimes-x86_64-unknown-linux-gnu-bins/libcxx/include/c++build
 /b/s/w/ir/x/w/llvm-project/libcxx/test/support
 /b/s/w/ir/x/w/staging/llvm_build/lib/clang/14.0.0/include
 /b/s/w/ir/x/w/cipd/linux/usr/include/x86_64-linux-gnu
 /b/s/w/ir/x/w/cipd/linux/usr/include
End of search list.
error: 'error' diagnostics expected but not seen: 
  File /b/s/w/ir/x/w/staging/llvm_build/include/c++/v1/any Line * (directive at /b/s/w/ir/x/w/llvm-project/libcxx/test/std/utilities/any/any.nonmembers/any.cast/not_copy_constructible.fail.cpp:48): static_cast from 'no_copy' to 'no_copy' uses deleted function
  File /b/s/w/ir/x/w/staging/llvm_build/include/c++/v1/any Line * (directive at /b/s/w/ir/x/w/llvm-project/libcxx/test/std/utilities/any/any.nonmembers/any.cast/not_copy_constructible.fail.cpp:52): static_cast from 'const no_copy' to 'no_copy' uses deleted function
error: 'error' diagnostics seen but not expected: 
  File /b/s/w/ir/x/w/staging/llvm_build/include/c++/v1/any Line 620: static_cast from 'typename remove_reference<no_copy>::type' (aka 'no_copy') to 'no_copy' uses deleted function
  File /b/s/w/ir/x/w/staging/llvm_build/include/c++/v1/any Line 605: static_cast from 'typename remove_reference<const no_copy>::type' (aka 'const no_copy') to 'no_copy' uses deleted function
4 errors generated.

error: command failed with exit status: 1

--

Would it be possible to take a look or revert the change?

[aaronpuchert]

Obviously the error message was just extended by the as-written type. Could have just adapted the expected results instead of reverting...

[mizvekov]

Exactly what Aaron said :-)

Though might be a complication here if libcxx tests this with both ToT and stable clang, so could be perhaps this needs to be changed in a way that works in both.

I will check this much later today, having a busy day.

Adding Louis for the libcxx expertise.

[ldionne]

In D110216#3127530, @mizvekov wrote:

Exactly what Aaron said :-)

Though might be a complication here if libcxx tests this with both ToT and stable clang, so could be perhaps this needs to be changed in a way that works in both.

I will check this much later today, having a busy day.

Adding Louis for the libcxx expertise.

Thanks for the heads up, I'm thinking about a fix right now. I'll paste the diff here and you can incorporate it to this review, which should trigger libc++ CI and make sure everything works.

We should probably start running the libc++ CI on Clang changes systematically, but I'm somewhat concerned about the bandwidth of our CI.

[ldionne]

I think this should do it:

diff --git a/libcxx/test/std/utilities/any/any.nonmembers/any.cast/const_correctness.fail.cpp b/libcxx/test/std/utilities/any/any.nonmembers/any.cast/const_correctness.verify.cpp
similarity index 81%
rename from libcxx/test/std/utilities/any/any.nonmembers/any.cast/const_correctness.fail.cpp
rename to libcxx/test/std/utilities/any/any.nonmembers/any.cast/const_correctness.verify.cpp
index 234efc83423b..a28e3fc9d1d7 100644
--- a/libcxx/test/std/utilities/any/any.nonmembers/any.cast/const_correctness.fail.cpp
+++ b/libcxx/test/std/utilities/any/any.nonmembers/any.cast/const_correctness.verify.cpp
@@ -18,6 +18,13 @@
 
 // Try and cast away const.
 
+// This test only checks that we static_assert in any_cast when the
+// constraints are not respected, however Clang will sometimes emit
+// additional errors while trying to instantiate the rest of any_cast
+// following the static_assert. We ignore unexpected errors in
+// clang-verify to make the test more robust to changes in Clang.
+// ADDITIONAL_COMPILE_FLAGS: -Xclang -verify-ignore-unexpected=error
+
 #include <any>
 
 struct TestType {};
@@ -30,19 +37,15 @@ int main(int, char**)
 
     any a;
 
-    // expected-error@any:* {{drops 'const' qualifier}}
     // expected-error-re@any:* {{static_assert failed{{.*}} "ValueType is required to be a const lvalue reference or a CopyConstructible type"}}
     any_cast<TestType &>(static_cast<any const&>(a)); // expected-note {{requested here}}
 
-    // expected-error@any:* {{cannot cast from lvalue of type 'const TestType' to rvalue reference type 'TestType &&'; types are not compatible}}
     // expected-error-re@any:* {{static_assert failed{{.*}} "ValueType is required to be a const lvalue reference or a CopyConstructible type"}}
     any_cast<TestType &&>(static_cast<any const&>(a)); // expected-note {{requested here}}
 
-    // expected-error@any:* {{drops 'const' qualifier}}
     // expected-error-re@any:* {{static_assert failed{{.*}} "ValueType is required to be a const lvalue reference or a CopyConstructible type"}}
     any_cast<TestType2 &>(static_cast<any const&&>(a)); // expected-note {{requested here}}
 
-    // expected-error@any:* {{cannot cast from lvalue of type 'const TestType2' to rvalue reference type 'TestType2 &&'; types are not compatible}}
     // expected-error-re@any:* {{static_assert failed{{.*}} "ValueType is required to be a const lvalue reference or a CopyConstructible type"}}
     any_cast<TestType2 &&>(static_cast<any const&&>(a)); // expected-note {{requested here}}
 
diff --git a/libcxx/test/std/utilities/any/any.nonmembers/any.cast/not_copy_constructible.fail.cpp b/libcxx/test/std/utilities/any/any.nonmembers/any.cast/not_copy_constructible.verify.cpp
similarity index 81%
rename from libcxx/test/std/utilities/any/any.nonmembers/any.cast/not_copy_constructible.fail.cpp
rename to libcxx/test/std/utilities/any/any.nonmembers/any.cast/not_copy_constructible.verify.cpp
index 44a67f7aa03d..ec40eeeec11b 100644
--- a/libcxx/test/std/utilities/any/any.nonmembers/any.cast/not_copy_constructible.fail.cpp
+++ b/libcxx/test/std/utilities/any/any.nonmembers/any.cast/not_copy_constructible.verify.cpp
@@ -24,6 +24,13 @@
 
 // Test instantiating the any_cast with a non-copyable type.
 
+// This test only checks that we static_assert in any_cast when the
+// constraints are not respected, however Clang will sometimes emit
+// additional errors while trying to instantiate the rest of any_cast
+// following the static_assert. We ignore unexpected errors in
+// clang-verify to make the test more robust to changes in Clang.
+// ADDITIONAL_COMPILE_FLAGS: -Xclang -verify-ignore-unexpected=error
+
 #include <any>
 
 using std::any;
@@ -45,17 +52,14 @@ struct no_move {
 int main(int, char**) {
     any a;
     // expected-error-re@any:* {{static_assert failed{{.*}} "ValueType is required to be an lvalue reference or a CopyConstructible type"}}
-    // expected-error@any:* {{static_cast from 'no_copy' to 'no_copy' uses deleted function}}
     any_cast<no_copy>(static_cast<any&>(a)); // expected-note {{requested here}}
 
     // expected-error-re@any:* {{static_assert failed{{.*}} "ValueType is required to be a const lvalue reference or a CopyConstructible type"}}
-    // expected-error@any:* {{static_cast from 'const no_copy' to 'no_copy' uses deleted function}}
     any_cast<no_copy>(static_cast<any const&>(a)); // expected-note {{requested here}}
 
     any_cast<no_copy>(static_cast<any &&>(a)); // OK
 
     // expected-error-re@any:* {{static_assert failed{{.*}} "ValueType is required to be an rvalue reference or a CopyConstructible type"}}
-    // expected-error@any:* {{static_cast from 'typename remove_reference<no_move &>::type' (aka 'no_move') to 'no_move' uses deleted function}}
     any_cast<no_move>(static_cast<any &&>(a));
 
   return 0;

Use git apply -- in particular mind the renaming of the files.

[mizvekov]

• Incorporating fixes for post-commit failures.

One last CI push, hopefully for real this time :-)

And thanks Louis, that fix is indeed much better!

(by the way git apply needs the --3way option to handle that rename nicely)

[mizvekov]

use --nolint this time, it seems to have flubbed the rename somehow.

[mizvekov]

Okay, libcxx pipeline passes, disregarding the clang-format failure for pre-existing badness in those files, which would need to be fixed separately or else git loses track of the rename.
The AIX failures also seem completely unrelated.

[mstorsjo]

This broke building ANGLE as part of Qt 5.15 for a mingw target, with the following error:

../../../3rdparty/angle/src/libANGLE/renderer/d3d/d3d11/ResourceManager11.cpp:532:38: error: explicit instantiation of 'allocate' does not refer to a function template, variable template, member function, member class, or static data member
ANGLE_RESOURCE_TYPE_OP(Instantitate, ANGLE_INSTANTIATE_OP)
                                     ^
../../../3rdparty/angle/src/libANGLE/renderer/d3d/d3d11/ResourceManager11.h:301:15: note: candidate template ignored: could not match 'GetInitDataFromD3D11<T>' (aka 'typename InitDataType<ResourceTypeFromD3D11<type-parameter-0-0>::Value>::Value') against 'const D3D11_SUBRESOURCE_DATA' 
    gl::Error allocate(Renderer11 *renderer,
              ^
../../../3rdparty/angle/src/libANGLE/renderer/d3d/d3d11/ResourceManager11.cpp:358:30: note: candidate template ignored: could not match 'GetInitDataFromD3D11<T>' (aka 'typename InitDataType<ResourceTypeFromD3D11<type-parameter-0-0>::Value>::Value') against 'const D3D11_SUBRESOURCE_DATA'
gl::Error ResourceManager11::allocate(Renderer11 *renderer,
                             ^

Do you happen to know what's going on here? The files mentioned are https://code.qt.io/cgit/qt/qtbase.git/tree/src/3rdparty/angle/src/libANGLE/renderer/d3d/d3d11/ResourceManager11.cpp?h=5.15.1 and https://code.qt.io/cgit/qt/qtbase.git/tree/src/3rdparty/angle/src/libANGLE/renderer/d3d/d3d11/ResourceManager11.h?h=5.15.1.

[mizvekov]

In D110216#3130184, @mstorsjo wrote:

Do you happen to know what's going on here? The files mentioned are https://code.qt.io/cgit/qt/qtbase.git/tree/src/3rdparty/angle/src/libANGLE/renderer/d3d/d3d11/ResourceManager11.cpp?h=5.15.1 and https://code.qt.io/cgit/qt/qtbase.git/tree/src/3rdparty/angle/src/libANGLE/renderer/d3d/d3d11/ResourceManager11.h?h=5.15.1.

Thanks for the report!

Not immediately obvious to me, would need some time to isolate / create a minimal test case.
Would you be in a position to extract a preprocessed source file + command line which repros this error?

Also, feel free to revert if it helps you.

[mstorsjo]

In D110216#3130193, @mizvekov wrote:

In D110216#3130184, @mstorsjo wrote:

Do you happen to know what's going on here? The files mentioned are https://code.qt.io/cgit/qt/qtbase.git/tree/src/3rdparty/angle/src/libANGLE/renderer/d3d/d3d11/ResourceManager11.cpp?h=5.15.1 and https://code.qt.io/cgit/qt/qtbase.git/tree/src/3rdparty/angle/src/libANGLE/renderer/d3d/d3d11/ResourceManager11.h?h=5.15.1.

Thanks for the report!

Not immediately obvious to me, would need some time to isolate / create a minimal test case.
Would you be in a position to extract a preprocessed source file + command line which repros this error?

Sure: https://martin.st/temp/angle-preproc.cpp, built with clang -target x86_64-w64-mingw32 -std=c++17 -w -c angle-preproc.cpp.

Also, feel free to revert if it helps you.

No big hurry for me wrt that yet, at least until we know which part is at fault here.

(I haven't tested with the very latest Qt and/or ANGLE - the full build setup for this is rather complex.)

[RobRich999]

Hit libANGLE in Chromium today, too.

https://bugs.chromium.org/p/chromium/issues/detail?id=1270154

[mizvekov]

Reverting for now.

[mizvekov]

FYI this is a minimal repro taken from Martin's preprocessed source (Thanks!):

template <class> struct a { using b = const float; };
template <class c> using d = typename a<c>::b;  

template <class c> void e(d<c> *, c) {}
template void e(const float *, int);

[mizvekov]

• IsPossiblyOpaquelyQualifiedType should use canonical type.
• Add test

[ldionne]

LGTM from the libc++ perspective.

Unsubscribing to reduce spam, please ping me on Discord if you need further input. Thanks!

[hans]

We're seeing a diagnostic change in Chromium which looks funny. For the following code (span<> is our own class):

int WontCompile() {
  const std::vector<int> v;
  span<int> s = make_span(v);
}

the diagnostic changes from:

fatal error: no viable conversion from 'span<const int, [...]>' to 'span<int, [...]>

to

fatal error: no viable conversion from 'span<T, [...]>' to 'span<int, [...]>

This looks very strange.

[mizvekov]

In D110216#3135461, @hans wrote:

We're seeing a diagnostic change in Chromium which looks funny. For the following code (span<> is our own class):
....
the diagnostic changes from:

fatal error: no viable conversion from 'span<const int, [...]>' to 'span<int, [...]>

to

fatal error: no viable conversion from 'span<T, [...]>' to 'span<int, [...]>

This looks very strange.

Hi! thanks for the report.

I am not sure how to reproduce this.

I tried mocking this situation:

template <class T> struct vector {};
template <class T, class=void> struct span {};

template <class T> auto make_span(const vector<T> &) { return span<const T>(); }

void WontCompile() {
  const vector<int> v;

  span<int> s1 = make_span(v);
}

Which I get:

error: no viable conversion from 'span<const int>' to 'span<int>'

Looking at the dump of that type:

AutoType 0x246b83676c0 'span<const int>' sugar
`-ElaboratedType 0x246b8366d60 'span<const int>' sugar
  `-TemplateSpecializationType 0x246b8366d20 'span<const int>' sugar span
    |-TemplateArgument type 'const int':'const int'
    | `-QualType 0x246b8366751 'const int' const
    |   `-SubstTemplateTypeParmType 0x246b8366750 'int' sugar
    |     |-TemplateTypeParmType 0x246b835c790 'T' dependent depth 0 index 0
    |     | `-TemplateTypeParm 0x246b835c740 'T'
    |     `-BuiltinType 0x246b82e81e0 'int'
    `-RecordType 0x246b8366d00 'struct span<const int>'
      `-ClassTemplateSpecialization 0x246b8366be8 'span'

In particular, the SubstTemplateTypeParmType desugars to int, not T, and I am not sure how you managed to get that ellipsis (from the type diff) on the template specialization arguments.

I am looking though at a clang built from D112374, which is main with other patches that have no effect here besides the addition of the ElaboratedType node on that dump.

[hans]

I am not sure how to reproduce this.

Attaching preprocessed source. With Clang built at 508aa4fe0c82b3b409e2e194d591ee6d665c8623 it reproduces for me like this:

$ clang++ -c /tmp/a.ii
../../base/containers/span_unittest.cc:11:13: error: no viable conversion from 'span<T, [...]>' to 'span<int, [...]>'
  span<int> s = make_span(v);
            ^   ~~~~~~~~~~~~
../../base/containers/span.h:340:13: note: candidate constructor not viable: no known conversion from 'span<T, Extent::value>' (aka 'span<const int, Extent::value>') to 'const base::span<int, 18446744073709551615> &' for 1st argument
  constexpr span(const span& other) noexcept = default;
            ^
../../base/containers/span.h:303:13: note: candidate template ignored: could not match 'int[N]' against 'span<T, Extent::value>' (aka 'span<const int, Extent::value>')
  constexpr span(T (&array)[N]) noexcept : span(base::data(array), N) {}
            ^
../../base/containers/span.h:310:13: note: candidate template ignored: could not match 'array' against 'span'
  constexpr span(std::array<U, N>& array) noexcept
            ^
../../base/containers/span.h:317:13: note: candidate template ignored: could not match 'array' against 'span'
  constexpr span(const std::array<U, N>& array) noexcept
            ^
../../base/containers/span.h:328:13: note: candidate template ignored: requirement 'conjunction<base::negation<base::internal::IsSpanImpl<base::span<const int, 18446744073709551615>>>, base::negation<base::internal::IsStdArrayImpl<base::span<const int, 18446744073709551615>>>, base::negation<std::is_array<base::span<const int, 18446744073709551615>>>, std::is_convertible<const int (*)[], int (*)[]>, std::is_integral<unsigned long>>::value' was not satisfied [with Container = base::span<const int, 18446744073709551615>]
  constexpr span(Container& container) noexcept{F20424748}
            ^
../../base/containers/span.h:337:13: note: candidate template ignored: requirement 'conjunction<base::negation<base::internal::IsSpanImpl<base::span<const int, 18446744073709551615>>>, base::negation<base::internal::IsStdArrayImpl<base::span<const int, 18446744073709551615>>>, base::negation<std::is_array<const base::span<const int, 18446744073709551615>>>, std::is_convertible<const int (*)[], int (*)[]>, std::is_integral<unsigned long>>::value' was not satisfied [with Container = base::span<const int, 18446744073709551615>]
  constexpr span(const Container& container) noexcept
            ^
../../base/containers/span.h:350:13: note: candidate template ignored: requirement 'is_convertible<const int (*)[], int (*)[]>::value' was not satisfied [with U = const int, OtherExtent = 18446744073709551615]
  constexpr span(const span<U, OtherExtent>& other)
            ^
1 error generated.

[hans]

Sorry, the attached file is here:

a.ii1 MBDownload

[mizvekov]

In D110216#3137375, @hans wrote:

I am not sure how to reproduce this.

Attaching preprocessed source. With Clang built at 508aa4fe0c82b3b409e2e194d591ee6d665c8623 it reproduces for me like this:

$ clang++ -c /tmp/a.ii
../../base/containers/span_unittest.cc:11:13: error: no viable conversion from 'span<T, [...]>' to 'span<int, [...]>'
  span<int> s = make_span(v);
            ^   ~~~~~~~~~~~~
../../base/containers/span.h:340:13: note: candidate constructor not viable: no known conversion from 'span<T, Extent::value>' (aka 'span<const int, Extent::value>') to 'const base::span<int, 18446744073709551615> &' for 1st argument
  constexpr span(const span& other) noexcept = default;
            ^

Oh so that one was a curve ball!!!! T was not a template parameter, just a typedef, see the implementation of make_span in that preprocessed file:

template <int&... ExplicitArgumentBarrier, typename Container>
constexpr auto make_span(Container&& container) noexcept {
  using T =
      std::remove_pointer_t<decltype(base::data(std::declval<Container>()))>;
  using Extent = internal::Extent<Container>;
  return span<T, Extent::value>(std::forward<Container>(container));
}

So, some notes:

• We should probably also do an AKA on the type diff.
• Chromium should use a clearer name for that typedef perhaps? Though calling the first template parameter of span as T is common, maybe a better name here would be element_type.

Having a convenient way to just name a type like that also seems useful, so maybe the rename coupled with the AKA would be an improvement overall?

Otherwise, if we get too much trouble with with legacy codebases which cannot be updated with that simple rename, we could perhaps make the type printer be context sensitive, and when printing type nodes tied to NamedDecls, just step over those that refer to a name which is not accessible in the current context?

[mizvekov]

Isolated example:

template <class T, int=0> struct span {};

auto make_span() {
  using T = int;
  return span<const T, 0>();
}

void WontCompile() {
  span<int> s1 = make_span();
}

https://godbolt.org/z/rjd6Y6f9d

testcc:9:13: error: no viable conversion from 'span<const T, [...]>' to 'span<int, [...]>'
  span<int> s1 = make_span();
            ^    ~~~~~~~~~~~
test.cc:1:34: note: candidate constructor (the implicit copy constructor) not viable: no known conversion from 'span<const T, 0>'
      (aka 'span<const int, 0>') to 'const span<int, 0> &' for 1st argument
template <class T, int=0> struct span {};
                                 ^
test.cc:1:34: note: candidate constructor (the implicit move constructor) not viable: no known conversion from 'span<const T, 0>'
      (aka 'span<const int, 0>') to 'span<int, 0> &&' for 1st argument
template <class T, int=0> struct span {};

[lkail]

Hi we found regression in our internal tests. It compiles with clang-13.0.0 https://godbolt.org/z/3abGrcf7o and gcc https://godbolt.org/z/K9oj3Grs1, but fails with clang-trunk https://godbolt.org/z/1Tehxa1x9. Is it an intended change? If so, do we have to document this?

[thakis]

So, some notes:

• We should probably also do an AKA on the type diff.
• Chromium should use a clearer name for that typedef perhaps? Though calling the first template parameter of span as T is common, maybe a better name here would be element_type.

Having a convenient way to just name a type like that also seems useful, so maybe the rename coupled with the AKA would be an improvement overall?

Haha :) Thanks for taking a look. aka for typedefs sounds like a nice approach to me.

[mizvekov]

In D110216#3139129, @lkail wrote:

Hi we found regression in our internal tests. It compiles with clang-13.0.0 https://godbolt.org/z/3abGrcf7o and gcc https://godbolt.org/z/K9oj3Grs1, but fails with clang-trunk https://godbolt.org/z/1Tehxa1x9. Is it an intended change? If so, do we have to document this?

Thanks for the report!

No it was not intended change, this patch should not affect partial ordering like that, modulo any bugs we might have accidentally fixed.
What happened here is that we lost a very small piece of code in the refactoring, which was introduced more than 10 years ago, but had no test coverage.
You just provided it though, and I am working on a patch to restore it shortly.

In D110216#3140678, @thakis wrote:

Haha :) Thanks for taking a look. aka for typedefs sounds like a nice approach to me.

Thanks, low on bandwidth right now but I will get to it :-)

[mizvekov]

Fix pushed to https://reviews.llvm.org/D114207

clang-tools-extra/clang-tidy/cppcoreguidelines/OwningMemoryCheck.cpp

Finder->addMatcher(binaryOperator(isAssignmentOperator(),
                                     hasLHS(unless(IsOwnerType)),
                                     hasRHS(CreatesOwner))
                          .bind("bad_owner_creation_assignment"),
                      this);
 
   // Matching on initialization operations where the initial value is a newly
   // created owner, but the LHS is not an owner.
   Finder->addMatcher(
-      traverse(
-          TK_AsIs,
-          namedDecl(
-              varDecl(eachOf(allOf(hasInitializer(CreatesOwner),
-                                   unless(IsOwnerType)),
-                             allOf(hasInitializer(ConsideredOwner),
-                                   hasType(autoType().bind("deduced_type")))))
+      traverse(TK_AsIs, namedDecl(varDecl(allOf(hasInitializer(CreatesOwner),
+                                                unless(IsOwnerType)))
                                       .bind("bad_owner_creation_variable"))),
       this);
 
   // Match on all function calls that expect owners as arguments, but didn't
   // get them.
   Finder->addMatcher(
       callExpr(forEachArgumentWithParam(
           expr(unless(ConsideredOwner)).bind("expected_owner_argument"),
           parmVarDecl(IsOwnerType))),
bool OwningMemoryCheck::handleAssignmentFromNewOwner(const BoundNodes &Nodes) {
   if (BadOwnerInitialization) {
     diag(BadOwnerInitialization->getBeginLoc(),
          "initializing non-owner %0 with a newly created 'gsl::owner<>'")
         << BadOwnerInitialization->getType()
         << BadOwnerInitialization->getSourceRange();
 
     // FIXME: FixitHint to rewrite the type of the initialized variable
     // as 'gsl::owner<OriginalType>'
-
-    // If the type of the variable was deduced, the wrapping owner typedef is
-    // eliminated, therefore the check emits a special note for that case.
-    if (Nodes.getNodeAs<AutoType>("deduced_type")) {
-      diag(BadOwnerInitialization->getBeginLoc(),
-           "type deduction did not result in an owner", DiagnosticIDs::Note);
-    }
     return true;
   }
 
   // Function call, where one arguments is a newly created owner, but the
   // parameter type is not.
   if (BadOwnerArgument) {
     assert(BadOwnerParameter &&
            "parameter for the problematic argument not found");

clang-tools-extra/clang-tidy/cppcoreguidelines/ProBoundsPointerArithmeticCheck.cpp

 namespace clang {
 namespace tidy {
 namespace cppcoreguidelines {
 
 void ProBoundsPointerArithmeticCheck::registerMatchers(MatchFinder *Finder) {
   if (!getLangOpts().CPlusPlus)
     return;
 
-  const auto AllPointerTypes = anyOf(
-      hasType(pointerType()), hasType(autoType(hasDeducedType(pointerType()))),
+  const auto AllPointerTypes =
+      anyOf(hasType(pointerType()),
+            hasType(autoType(
+                hasDeducedType(hasUnqualifiedDesugaredType(pointerType())))),
             hasType(decltypeType(hasUnderlyingType(pointerType()))));
 
   // Flag all operators +, -, +=, -=, ++, -- that result in a pointer
   Finder->addMatcher(
       binaryOperator(
           hasAnyOperatorName("+", "-", "+=", "-="), AllPointerTypes,
           unless(hasLHS(ignoringImpCasts(declRefExpr(to(isImplicit()))))))
           .bind("expr"),
       this);

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

auto ExplicitSingleVarDeclInTemplate =
          llvm::StringRef ID) {
         return declStmt(
             isInTemplateInstantiation(),
             hasSingleDecl(
                 varDecl(unless(isImplicit()), InnerMatcher).bind(ID)));
       };
 
   auto IsBoundToType = refersToType(equalsBoundNode("type"));
+  auto UnlessFunctionType = unless(hasUnqualifiedDesugaredType(functionType()));
+  auto IsAutoDeducedToPointer = [](const auto &...InnerMatchers) {
+    return autoType(hasDeducedType(
+        hasUnqualifiedDesugaredType(pointerType(pointee(InnerMatchers...)))));
+  };
 
   Finder->addMatcher(
-      ExplicitSingleVarDecl(hasType(autoType(hasDeducedType(
-                                pointerType(pointee(unless(functionType())))))),
+      ExplicitSingleVarDecl(hasType(IsAutoDeducedToPointer(UnlessFunctionType)),
                             "auto"),
       this);
 
   Finder->addMatcher(
       ExplicitSingleVarDeclInTemplate(
-          allOf(hasType(autoType(hasDeducedType(pointerType(
-                    pointee(hasUnqualifiedType(qualType().bind("type")),
-                            unless(functionType())))))),
+          allOf(hasType(IsAutoDeducedToPointer(
+                    hasUnqualifiedType(qualType().bind("type")),
+                    UnlessFunctionType)),
                 anyOf(hasAncestor(
                           functionDecl(hasAnyTemplateArgument(IsBoundToType))),
                       hasAncestor(classTemplateSpecializationDecl(
                           hasAnyTemplateArgument(IsBoundToType))))),
           "auto"),
       this);
   if (!AddConstToQualified)
     return;

clang-tools-extra/clangd/FindTarget.cpp

struct Visitor : public TypeVisitor<Visitor> {
       }
 
       void VisitDecltypeType(const DecltypeType *DTT) {
         Outer.add(DTT->getUnderlyingType(), Flags | Rel::Underlying);
       }
       void VisitDeducedType(const DeducedType *DT) {
         // FIXME: In practice this doesn't work: the AutoType you find inside
         // TypeLoc never has a deduced type. https://llvm.org/PR42914
-        Outer.add(DT->getDeducedType(), Flags | Rel::Underlying);
+        Outer.add(DT->getDeducedType(), Flags);
       }
       void VisitDeducedTemplateSpecializationType(
           const DeducedTemplateSpecializationType *DTST) {
         // FIXME: This is a workaround for https://llvm.org/PR42914,
         // which is causing DTST->getDeducedType() to be empty. We
         // fall back to the template pattern and miss the instantiation
         // even when it's known in principle. Once that bug is fixed,
         // this method can be removed (the existing handling in

clang-tools-extra/clangd/InlayHints.cpp

InlayHintVisitor(std::vector<InlayHint> &Results, ParsedAST &AST)
 
     TypeHintPolicy.SuppressScope = true; // keep type names short
     TypeHintPolicy.AnonymousTagLocations =
         false; // do not print lambda locations
 
     // For structured bindings, print canonical types. This is important because
     // for bindings that use the tuple_element protocol, the non-canonical types
     // would be "tuple_element<I, A>::type".
-    // For "auto", we often prefer sugared types, but the AST doesn't currently
-    // retain them in DeducedType. However, not setting PrintCanonicalTypes for
-    // "auto" at least allows SuppressDefaultTemplateArgs (set by default) to
-    // have an effect.
+    // For "auto", we often prefer sugared types.
+    // Not setting PrintCanonicalTypes for "auto" allows
+    // SuppressDefaultTemplateArgs (set by default) to have an effect.
     StructuredBindingPolicy = TypeHintPolicy;
     StructuredBindingPolicy.PrintCanonicalTypes = true;
   }
 
   bool VisitCXXConstructExpr(CXXConstructExpr *E) {
     // Weed out constructor calls that don't look like a function call with
     // an argument list, by checking the validity of getParenOrBraceRange().
     // Also weed out std::initializer_list constructors as there are no names

clang-tools-extra/clangd/unittests/ASTTests.cpp

TEST(GetDeducedType, KwAutoKwDecltypeExpansion) {
   } Tests[] = {
       {"^auto i = 0;", "int"},
       {"^auto f(){ return 1;};", "int"},
       {
           R"cpp( // auto on struct in a namespace
               namespace ns1 { struct S {}; }
               ^auto v = ns1::S{};
           )cpp",
-          "struct ns1::S",
+          "ns1::S",
       },
       {
           R"cpp( // decltype on struct
               namespace ns1 { struct S {}; }
               ns1::S i;
               ^decltype(i) j;
           )cpp",
           "ns1::S",
       },
       {
           R"cpp(// decltype(auto) on struct&
             namespace ns1 {
             struct S {};
             } // namespace ns1
 
             ns1::S i;
             ns1::S& j = i;
             ^decltype(auto) k = j;
           )cpp",
-          "struct ns1::S &",
+          "ns1::S &",
       },
       {
           R"cpp( // auto on template class
               class X;
               template<typename T> class Foo {};
               ^auto v = Foo<X>();
           )cpp",
-          "class Foo<class X>",
+          "Foo<class X>",
       },
       {
           R"cpp( // auto on initializer list.
               namespace std
               {
                 template<class _E>
                 class [[initializer_list]] {};
               }
const char *DeducedType;
           "const struct Foo &",
       },
       {
           R"cpp( // auto on alias
             struct Foo {};
             using Bar = Foo;
             ^auto x = Bar();
           )cpp",
-          // FIXME: it'd be nice if this resolved to the alias instead
-          "struct Foo",
+          "Bar",
       },
   };
   for (Test T : Tests) {
     Annotations File(T.AnnotatedCode);
     auto AST = TestTU::withCode(File.code()).build();
     SourceManagerForFile SM("foo.cpp", File.code());
 
     SCOPED_TRACE(File.code());

clang-tools-extra/clangd/unittests/HoverTests.cpp

class Foo {})cpp";
         template<typename T> class Foo{};
         void foo() {
           [[au^to]] x = Foo<int>();
         }
         )cpp",
        [](HoverInfo &HI) {
          HI.Name = "auto";
          HI.Kind = index::SymbolKind::TypeAlias;
-         HI.Definition = "class Foo<int>";
+         HI.Definition = "Foo<int>";
        }},
       // auto on specialized template
       {R"cpp(
         template<typename T> class Foo{};
         template<> class Foo<int>{};
         void foo() {
           [[au^to]] x = Foo<int>();
         }
         )cpp",
        [](HoverInfo &HI) {
          HI.Name = "auto";
          HI.Kind = index::SymbolKind::TypeAlias;
-         HI.Definition = "class Foo<int>";
+         HI.Definition = "Foo<int>";
        }},
 
       // macro
       {R"cpp(
         // Best MACRO ever.
         #define MACRO(x,y,z) void foo(x, y, z);
         [[MAC^RO]](int, double d, bool z = false);
         )cpp",
class Foo {})cpp";
           class X;
           void foo() {
             [[^auto]] x = Foo<X>();
           }
           )cpp",
           [](HoverInfo &HI) {
             HI.Name = "auto";
             HI.Kind = index::SymbolKind::TypeAlias;
-            HI.Definition = "class Foo<X>";
+            HI.Definition = "Foo<X>";
           }},
       {// Falls back to primary template, when the type is not instantiated.
        R"cpp(
           // comment from primary
           template <typename T> class Foo {};
           // comment from specialization
           template <typename T> class Foo<T*> {};
           void foo() {
const std::function<void(HoverInfo &)> ExpectedBuilder;
       {
           R"cpp(// auto on alias
           typedef int int_type;
           ^[[auto]] x = int_type();
           )cpp",
           [](HoverInfo &HI) {
             HI.Name = "auto";
             HI.Kind = index::SymbolKind::TypeAlias;
-            HI.Definition = "int";
+            HI.Definition = "int_type";
           }},
       {
           R"cpp(// auto on alias
           struct cls {};
           typedef cls cls_type;
           ^[[auto]] y = cls_type();
           )cpp",
           [](HoverInfo &HI) {
             HI.Name = "auto";
             HI.Kind = index::SymbolKind::TypeAlias;
-            HI.Definition = "struct cls";
+            HI.Definition = "cls_type";
             HI.Documentation = "auto on alias";
           }},
       {
           R"cpp(// auto on alias
           template <class>
           struct templ {};
           ^[[auto]] z = templ<int>();
           )cpp",
           [](HoverInfo &HI) {
             HI.Name = "auto";
             HI.Kind = index::SymbolKind::TypeAlias;
-            HI.Definition = "struct templ<int>";
+            HI.Definition = "templ<int>";
             HI.Documentation = "auto on alias";
           }},
       {
           R"cpp(// Undeduced auto declaration
             template<typename T>
             void foo() {
               ^[[auto]] x = T();
             }

clang-tools-extra/clangd/unittests/InlayHintTests.cpp

 }
 
 TEST(TypeHints, DecltypeAuto) {
   assertTypeHints(R"cpp(
     int x = 42;
     int& y = x;
     decltype(auto) $z[[z]] = y;
   )cpp",
                   ExpectedHint{": int &", "z"});
 }
 
 TEST(TypeHints, NoQualifiers) {
   assertTypeHints(R"cpp(
     namespace A {
       namespace B {
         struct S1 {};
         S1 foo();
         auto $x[[x]] = foo();
 
         struct S2 {
           template <typename T>
           struct Inner {};
         };
         S2::Inner<int> bar();
         auto $y[[y]] = bar();
       }
     }
   )cpp",
-                  ExpectedHint{": S1", "x"}, ExpectedHint{": Inner<int>", "y"});
+                  ExpectedHint{": S1", "x"},
+                  // FIXME: We want to suppress scope specifiers
+                  //        here because we are into the whole
+                  //        brevity thing, but the ElaboratedType
+                  //        printer does not honor the SuppressScope
+                  //        flag by design, so we need to extend the
+                  //        PrintingPolicy to support this use case.
+                  ExpectedHint{": S2::Inner<int>", "y"});
 }
 
 TEST(TypeHints, Lambda) {
   // Do not print something overly verbose like the lambda's location.
   // Show hints for init-captures (but not regular captures).
   assertTypeHints(R"cpp(
     void f() {
       int cap = 42;

clang-tools-extra/clangd/unittests/tweaks/ExpandAutoTypeTests.cpp

EXPECT_THAT(apply("au^to x = doesnt_exist(); // error-ok"),
               StartsWith("fail: Could not deduce type for 'auto' type"));
   // function pointers should not be replaced
   EXPECT_THAT(apply("au^to x = &ns::Func;"),
               StartsWith("fail: Could not expand type of function pointer"));
   // lambda types are not replaced
   EXPECT_UNAVAILABLE("au^to x = []{};");
   // inline namespaces
   EXPECT_EQ(apply("au^to x = inl_ns::Visible();"),
-            "Visible x = inl_ns::Visible();");
+            "inl_ns::Visible x = inl_ns::Visible();");
   // local class
   EXPECT_EQ(apply("namespace x { void y() { struct S{}; ^auto z = S(); } }"),
             "namespace x { void y() { struct S{}; S z = S(); } }");
   // replace array types
   EXPECT_EQ(apply(R"cpp(au^to x = "test";)cpp"),
             R"cpp(const char * x = "test";)cpp");
 
   EXPECT_EQ(apply("ns::Class * foo() { au^to c = foo(); }"),
             "ns::Class * foo() { ns::Class * c = foo(); }");
-  EXPECT_EQ(apply("void ns::Func() { au^to x = new ns::Class::Nested{}; }"),
-            "void ns::Func() { Class::Nested * x = new ns::Class::Nested{}; }");
+  EXPECT_EQ(
+      apply("void ns::Func() { au^to x = new ns::Class::Nested{}; }"),
+      "void ns::Func() { ns::Class::Nested * x = new ns::Class::Nested{}; }");
 
   EXPECT_UNAVAILABLE("dec^ltype(au^to) x = 10;");
   // expanding types in structured bindings is syntactically invalid.
   EXPECT_UNAVAILABLE("const ^auto &[x,y] = (int[]){1,2};");
 
   // unknown types in a template should not be replaced
   EXPECT_THAT(apply("template <typename T> void x() { ^auto y = T::z(); }"),
               StartsWith("fail: Could not deduce type for 'auto' type"));
 
   ExtraArgs.push_back("-std=c++17");
   EXPECT_UNAVAILABLE("template <au^to X> class Y;");
 }
 
 } // namespace
 } // namespace clangd
 } // namespace clang

clang-tools-extra/test/clang-tidy/checkers/cppcoreguidelines-owning-memory.cpp

void test_assignment_and_initialization() {
   gsl::owner<int *> owned_int5 = owned_int3; // Good
 
   gsl::owner<int *> owned_int6{nullptr}; // Ok
   owned_int6 = owned_int4;               // Good
 
   // FIXME:, flow analysis for the case of reassignment. Value must be released before
   owned_int6 = owned_int3; // BAD, because reassignment without resource release
 
-  auto owned_int7 = returns_owner1(); // Bad, since type deduction eliminates the owner wrapper
-  // CHECK-NOTES: [[@LINE-1]]:3: warning: initializing non-owner 'int *' with a newly created 'gsl::owner<>'
-  // CHECK-NOTES: [[@LINE-2]]:3: note: type deduction did not result in an owner
+  auto owned_int7 = returns_owner1(); // Ok, since type deduction does not eliminate the owner wrapper
 
-  const auto owned_int8 = returns_owner2(); // Bad, since type deduction eliminates the owner wrapper
-  // CHECK-NOTES: [[@LINE-1]]:3: warning: initializing non-owner 'int *const' with a newly created 'gsl::owner<>'
-  // CHECK-NOTES: [[@LINE-2]]:3: note: type deduction did not result in an owner
+  const auto owned_int8 = returns_owner2(); // Ok, since type deduction does not eliminate the owner wrapper
 
   gsl::owner<int *> owned_int9 = returns_owner1(); // Ok
   int *unowned_int3 = returns_owner1();            // Bad
   // CHECK-NOTES: [[@LINE-1]]:3: warning: initializing non-owner 'int *' with a newly created 'gsl::owner<>'
 
   gsl::owner<int *> owned_int10;
   owned_int10 = returns_owner1(); // Ok
 

 };
 
 void test_class_with_owner() {
   ArbitraryClass A;
   ClassWithOwner C1;                                                   // Ok
   ClassWithOwner C2{A};                                                // Bad, since the owner would be initialized with an non-owner, but catched in the class
   ClassWithOwner C3{gsl::owner<ArbitraryClass *>(new ArbitraryClass)}; // Ok
 
-  const auto Owner1 = C3.buggy_but_returns_owner(); // BAD, deduces Owner1 to ArbitraryClass *const
-  // CHECK-NOTES: [[@LINE-1]]:3: warning: initializing non-owner 'ArbitraryClass *const' with a newly created 'gsl::owner<>'
-  // CHECK-NOTES: [[@LINE-2]]:3: note: type deduction did not result in an owner
-
-  auto Owner2 = C2.buggy_but_returns_owner(); // BAD, deduces Owner2 to ArbitraryClass *
-  // CHECK-NOTES: [[@LINE-1]]:3: warning: initializing non-owner 'ArbitraryClass *' with a newly created 'gsl::owner<>'
-  // CHECK-NOTES: [[@LINE-2]]:3: note: type deduction did not result in an owner
+  const auto Owner1 = C3.buggy_but_returns_owner(); // Ok, deduces Owner1 to owner<ArbitraryClass *> const
+
+  auto Owner2 = C2.buggy_but_returns_owner(); // Ok, deduces Owner2 to owner<ArbitraryClass *>
 
-  Owner2 = &A; // Ok, since type deduction did NOT result in owner<int*>
+  Owner2 = &A; // BAD, since type deduction resulted in owner<ArbitraryClass *>
+  // CHECK-NOTES: [[@LINE-1]]:3: warning: expected assignment source to be of type 'gsl::owner<>'; got 'ArbitraryClass *'
 
   gsl::owner<ArbitraryClass *> Owner3 = C1.buggy_but_returns_owner(); // Ok, still an owner
   Owner3 = &A;                                                        // Bad, since assignment of non-owner to owner
   // CHECK-NOTES: [[@LINE-1]]:3: warning: expected assignment source to be of type 'gsl::owner<>'; got 'ArbitraryClass *'
 }
 
 template <typename T>
 struct HeapArray {                                          // Ok, since destructor with owner

clang/include/clang/AST/ASTContext.h

public:
 
   QualType adjustStringLiteralBaseType(QualType StrLTy) const;
 
 private:
   /// Return a normal function type with a typed argument list.
   QualType getFunctionTypeInternal(QualType ResultTy, ArrayRef<QualType> Args,
                                    const FunctionProtoType::ExtProtoInfo &EPI,
                                    bool OnlyWantCanonical) const;
+  QualType
+  getAutoTypeInternal(QualType DeducedType, AutoTypeKeyword Keyword,
+                      bool IsDependent, bool IsPack = false,
+                      ConceptDecl *TypeConstraintConcept = nullptr,
+                      ArrayRef<TemplateArgument> TypeConstraintArgs = {},
+                      bool IsCanon = false) const;
 
 public:
   /// Return the unique reference to the type for the specified type
   /// declaration.
   QualType getTypeDeclType(const TypeDecl *Decl,
                            const TypeDecl *PrevDecl = nullptr) const {
     assert(Decl && "Passed null for Decl param");
     if (Decl->TypeForDecl) return QualType(Decl->TypeForDecl, 0);

clang/include/clang/AST/Type.h

 /// placeholder type deduction: C++11 auto, C++14 decltype(auto), C++17 deduced
 /// class template types, and constrained type names.
 ///
 /// These types are usually a placeholder for a deduced type. However, before
 /// the initializer is attached, or (usually) if the initializer is
 /// type-dependent, there is no deduced type and the type is canonical. In
 /// the latter case, it is also a dependent type.
 class DeducedType : public Type {
+  QualType DeducedAsType;
+
 protected:
   DeducedType(TypeClass TC, QualType DeducedAsType,
-              TypeDependence ExtraDependence)
-      : Type(TC,
-             // FIXME: Retain the sugared deduced type?
-             DeducedAsType.isNull() ? QualType(this, 0)
-                                    : DeducedAsType.getCanonicalType(),
+              TypeDependence ExtraDependence, QualType Canon)
+      : Type(TC, Canon,
              ExtraDependence | (DeducedAsType.isNull()
                                     ? TypeDependence::None
                                     : DeducedAsType->getDependence() &
-                                          ~TypeDependence::VariablyModified)) {}
+                                          ~TypeDependence::VariablyModified)),
+        DeducedAsType(DeducedAsType) {}
 
 public:
-  bool isSugared() const { return !isCanonicalUnqualified(); }
-  QualType desugar() const { return getCanonicalTypeInternal(); }
-
-  /// Get the type deduced for this placeholder type, or null if it's
-  /// either not been deduced or was deduced to a dependent type.
-  QualType getDeducedType() const {
-    return !isCanonicalUnqualified() ? getCanonicalTypeInternal() : QualType();
+  bool isSugared() const { return !DeducedAsType.isNull(); }
+  QualType desugar() const {
+    return isSugared() ? DeducedAsType : QualType(this, 0);
   }
+
+  /// Get the type deduced for this placeholder type, or null if it
+  /// has not been deduced.
+  QualType getDeducedType() const { return DeducedAsType; }
   bool isDeduced() const {
-    return !isCanonicalUnqualified() || isDependentType();
+    return !DeducedAsType.isNull() || isDependentType();
   }
 
   static bool classof(const Type *T) {
     return T->getTypeClass() == Auto ||
            T->getTypeClass() == DeducedTemplateSpecialization;
   }
 };
 
 /// Represents a C++11 auto or C++14 decltype(auto) type, possibly constrained
 /// by a type-constraint.
 class alignas(8) AutoType : public DeducedType, public llvm::FoldingSetNode {
   friend class ASTContext; // ASTContext creates these
 
   ConceptDecl *TypeConstraintConcept;
 
   AutoType(QualType DeducedAsType, AutoTypeKeyword Keyword,
-           TypeDependence ExtraDependence, ConceptDecl *CD,
+           TypeDependence ExtraDependence, QualType Canon, ConceptDecl *CD,
            ArrayRef<TemplateArgument> TypeConstraintArgs);
 
   const TemplateArgument *getArgBuffer() const {
     return reinterpret_cast<const TemplateArgument*>(this+1);
   }
 
   TemplateArgument *getArgBuffer() {
     return reinterpret_cast<TemplateArgument*>(this+1);
class DeducedTemplateSpecializationType : public DeducedType,
 
   DeducedTemplateSpecializationType(TemplateName Template,
                                     QualType DeducedAsType,
                                     bool IsDeducedAsDependent)
       : DeducedType(DeducedTemplateSpecialization, DeducedAsType,
                     toTypeDependence(Template.getDependence()) |
                         (IsDeducedAsDependent
                              ? TypeDependence::DependentInstantiation
-                             : TypeDependence::None)),
+                             : TypeDependence::None),
+                    DeducedAsType.isNull() ? QualType(this, 0)
+                                           : DeducedAsType.getCanonicalType()),
         Template(Template) {}
 
 public:
   /// Retrieve the name of the template that we are deducing.
   TemplateName getTemplateName() const { return Template;}
 
   void Profile(llvm::FoldingSetNodeID &ID) {
     Profile(ID, getTemplateName(), getDeducedType(), isDependentType());

clang/include/clang/ASTMatchers/ASTMatchersInternal.h

private:
   }
 
   /// Finds the best declaration for a type and returns whether the inner
   /// matcher matches on it.
   bool matchesSpecialized(const Type &Node, ASTMatchFinder *Finder,
                           BoundNodesTreeBuilder *Builder) const {
     // DeducedType does not have declarations of its own, so
     // match the deduced type instead.
-    const Type *EffectiveType = &Node;
     if (const auto *S = dyn_cast<DeducedType>(&Node)) {
-      EffectiveType = S->getDeducedType().getTypePtrOrNull();
-      if (!EffectiveType)
-        return false;
+      QualType DT = S->getDeducedType();
+      return !DT.isNull() ? matchesSpecialized(*DT, Finder, Builder) : false;
     }
 
     // First, for any types that have a declaration, extract the declaration and
     // match on it.
-    if (const auto *S = dyn_cast<TagType>(EffectiveType)) {
+    if (const auto *S = dyn_cast<TagType>(&Node)) {
       return matchesDecl(S->getDecl(), Finder, Builder);
     }
-    if (const auto *S = dyn_cast<InjectedClassNameType>(EffectiveType)) {
+    if (const auto *S = dyn_cast<InjectedClassNameType>(&Node)) {
       return matchesDecl(S->getDecl(), Finder, Builder);
     }
-    if (const auto *S = dyn_cast<TemplateTypeParmType>(EffectiveType)) {
+    if (const auto *S = dyn_cast<TemplateTypeParmType>(&Node)) {
       return matchesDecl(S->getDecl(), Finder, Builder);
     }
-    if (const auto *S = dyn_cast<TypedefType>(EffectiveType)) {
+    if (const auto *S = dyn_cast<TypedefType>(&Node)) {
       return matchesDecl(S->getDecl(), Finder, Builder);
     }
-    if (const auto *S = dyn_cast<UnresolvedUsingType>(EffectiveType)) {
+    if (const auto *S = dyn_cast<UnresolvedUsingType>(&Node)) {
       return matchesDecl(S->getDecl(), Finder, Builder);
     }
-    if (const auto *S = dyn_cast<ObjCObjectType>(EffectiveType)) {
+    if (const auto *S = dyn_cast<ObjCObjectType>(&Node)) {
       return matchesDecl(S->getInterface(), Finder, Builder);
     }
 
     // A SubstTemplateTypeParmType exists solely to mark a type substitution
     // on the instantiated template. As users usually want to match the
     // template parameter on the uninitialized template, we can always desugar
     // one level without loss of expressivness.
     // For example, given:
     //   template<typename T> struct X { T t; } class A {}; X<A> a;
     // The following matcher will match, which otherwise would not:
     //   fieldDecl(hasType(pointerType())).
-    if (const auto *S = dyn_cast<SubstTemplateTypeParmType>(EffectiveType)) {
+    if (const auto *S = dyn_cast<SubstTemplateTypeParmType>(&Node)) {
       return matchesSpecialized(S->getReplacementType(), Finder, Builder);
     }
 
     // For template specialization types, we want to match the template
     // declaration, as long as the type is still dependent, and otherwise the
     // declaration of the instantiated tag type.
-    if (const auto *S = dyn_cast<TemplateSpecializationType>(EffectiveType)) {
+    if (const auto *S = dyn_cast<TemplateSpecializationType>(&Node)) {
       if (!S->isTypeAlias() && S->isSugared()) {
         // If the template is non-dependent, we want to match the instantiated
         // tag type.
         // For example, given:
         //   template<typename T> struct X {}; X<int> a;
         // The following matcher will match, which otherwise would not:
         //   templateSpecializationType(hasDeclaration(cxxRecordDecl())).
         return matchesSpecialized(*S->desugar(), Finder, Builder);
       }
       // If the template is dependent or an alias, match the template
       // declaration.
       return matchesDecl(S->getTemplateName().getAsTemplateDecl(), Finder,
                          Builder);
     }
 
     // FIXME: We desugar elaborated types. This makes the assumption that users
     // do never want to match on whether a type is elaborated - there are
     // arguments for both sides; for now, continue desugaring.
-    if (const auto *S = dyn_cast<ElaboratedType>(EffectiveType)) {
+    if (const auto *S = dyn_cast<ElaboratedType>(&Node)) {
       return matchesSpecialized(S->desugar(), Finder, Builder);
     }
     return false;
   }
 
   /// Extracts the Decl the DeclRefExpr references and returns whether
   /// the inner matcher matches on it.
   bool matchesSpecialized(const DeclRefExpr &Node, ASTMatchFinder *Finder,

clang/include/clang/Sema/Sema.h

bool RequireLiteralType(SourceLocation Loc, QualType T, unsigned DiagID,
     BoundTypeDiagnoser<Ts...> Diagnoser(DiagID, Args...);
     return RequireLiteralType(Loc, T, Diagnoser);
   }
 
   QualType getElaboratedType(ElaboratedTypeKeyword Keyword,
                              const CXXScopeSpec &SS, QualType T,
                              TagDecl *OwnedTagDecl = nullptr);
 
-  QualType BuildTypeofExprType(Expr *E, SourceLocation Loc);
+  // 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, SourceLocation Loc,
-                             bool AsUnevaluated = true);
+  QualType BuildDecltypeType(Expr *E, bool AsUnevaluated = true);
   QualType BuildUnaryTransformType(QualType BaseType,
                                    UnaryTransformType::UTTKind UKind,
                                    SourceLocation Loc);
 
   //===--------------------------------------------------------------------===//
   // Symbol table / Decl tracking callbacks: SemaDecl.cpp.
   //
 
bool CheckMemberPointerConversion(Expr *From, QualType ToType,
                                     CastKind &Kind,
                                     CXXCastPath &BasePath,
                                     bool IgnoreBaseAccess);
   bool IsQualificationConversion(QualType FromType, QualType ToType,
                                  bool CStyle, bool &ObjCLifetimeConversion);
   bool IsFunctionConversion(QualType FromType, QualType ToType,
                             QualType &ResultTy);
   bool DiagnoseMultipleUserDefinedConversion(Expr *From, QualType ToType);
-  bool isSameOrCompatibleFunctionType(CanQualType Param, CanQualType Arg);
+  bool isSameOrCompatibleFunctionType(QualType Param, QualType Arg);
 
   bool CanPerformAggregateInitializationForOverloadResolution(
       const InitializedEntity &Entity, InitListExpr *From);
 
   bool IsStringInit(Expr *Init, const ArrayType *AT);
 
   bool CanPerformCopyInitialization(const InitializedEntity &Entity,
                                     ExprResult Init);
DeduceTemplateArguments(FunctionTemplateDecl *FunctionTemplate,
                           sema::TemplateDeductionInfo &Info,
                           bool IsAddressOfFunction = false);
 
   /// Substitute Replacement for \p auto in \p TypeWithAuto
   QualType SubstAutoType(QualType TypeWithAuto, QualType Replacement);
   /// Substitute Replacement for auto in TypeWithAuto
   TypeSourceInfo* SubstAutoTypeSourceInfo(TypeSourceInfo *TypeWithAuto,
                                           QualType Replacement);
+
+  // Substitute auto in TypeWithAuto for a Dependent auto type
+  QualType SubstAutoTypeDependent(QualType TypeWithAuto);
+
+  // Substitute auto in TypeWithAuto for a Dependent auto type
+  TypeSourceInfo *
+  SubstAutoTypeSourceInfoDependent(TypeSourceInfo *TypeWithAuto);
+
   /// Completely replace the \c auto in \p TypeWithAuto by
   /// \p Replacement. This does not retain any \c auto type sugar.
   QualType ReplaceAutoType(QualType TypeWithAuto, QualType Replacement);
   TypeSourceInfo *ReplaceAutoTypeSourceInfo(TypeSourceInfo *TypeWithAuto,
                                             QualType Replacement);
 
   /// Result type of DeduceAutoType.
   enum DeduceAutoResult {

clang/lib/AST/ASTContext.cpp

ASTContext::getTemplateSpecializationType(TemplateName Template,
   auto *Spec
     = new (Mem) TemplateSpecializationType(Template, Args, CanonType,
                                          IsTypeAlias ? Underlying : QualType());
 
   Types.push_back(Spec);
   return QualType(Spec, 0);
 }
 
+static bool
+getCanonicalTemplateArguments(const ASTContext &C,
+                              ArrayRef<TemplateArgument> OrigArgs,
+                              SmallVectorImpl<TemplateArgument> &CanonArgs) {
+  bool AnyNonCanonArgs = false;
+  unsigned NumArgs = OrigArgs.size();
+  CanonArgs.resize(NumArgs);
+  for (unsigned I = 0; I != NumArgs; ++I) {
+    const TemplateArgument &OrigArg = OrigArgs[I];
+    TemplateArgument &CanonArg = CanonArgs[I];
+    CanonArg = C.getCanonicalTemplateArgument(OrigArg);
+    if (!CanonArg.structurallyEquals(OrigArg))
+      AnyNonCanonArgs = true;
+  }
+  return AnyNonCanonArgs;
+}
+
 QualType ASTContext::getCanonicalTemplateSpecializationType(
     TemplateName Template, ArrayRef<TemplateArgument> Args) const {
   assert(!Template.getAsDependentTemplateName() &&
          "No dependent template names here!");
 
   // Look through qualified template names.
   if (QualifiedTemplateName *QTN = Template.getAsQualifiedTemplateName())
     Template = TemplateName(QTN->getTemplateDecl());
 
   // Build the canonical template specialization type.
   TemplateName CanonTemplate = getCanonicalTemplateName(Template);
   SmallVector<TemplateArgument, 4> CanonArgs;
-  unsigned NumArgs = Args.size();
-  CanonArgs.reserve(NumArgs);
-  for (const TemplateArgument &Arg : Args)
-    CanonArgs.push_back(getCanonicalTemplateArgument(Arg));
+  ::getCanonicalTemplateArguments(*this, Args, CanonArgs);
 
   // Determine whether this canonical template specialization type already
   // exists.
   llvm::FoldingSetNodeID ID;
   TemplateSpecializationType::Profile(ID, CanonTemplate,
                                       CanonArgs, *this);
 
   void *InsertPos = nullptr;
   TemplateSpecializationType *Spec
     = TemplateSpecializationTypes.FindNodeOrInsertPos(ID, InsertPos);
 
   if (!Spec) {
     // Allocate a new canonical template specialization type.
     void *Mem = Allocate((sizeof(TemplateSpecializationType) +
-                          sizeof(TemplateArgument) * NumArgs),
+                          sizeof(TemplateArgument) * CanonArgs.size()),
                          TypeAlignment);
     Spec = new (Mem) TemplateSpecializationType(CanonTemplate,
                                                 CanonArgs,
                                                 QualType(), QualType());
     Types.push_back(Spec);
     TemplateSpecializationTypes.InsertNode(Spec, InsertPos);
   }
 
ASTContext::getDependentTemplateSpecializationType(
   if (T)
     return QualType(T, 0);
 
   NestedNameSpecifier *CanonNNS = getCanonicalNestedNameSpecifier(NNS);
 
   ElaboratedTypeKeyword CanonKeyword = Keyword;
   if (Keyword == ETK_None) CanonKeyword = ETK_Typename;
 
-  bool AnyNonCanonArgs = false;
-  unsigned NumArgs = Args.size();
-  SmallVector<TemplateArgument, 16> CanonArgs(NumArgs);
-  for (unsigned I = 0; I != NumArgs; ++I) {
-    CanonArgs[I] = getCanonicalTemplateArgument(Args[I]);
-    if (!CanonArgs[I].structurallyEquals(Args[I]))
-      AnyNonCanonArgs = true;
-  }
+  SmallVector<TemplateArgument, 16> CanonArgs;
+  bool AnyNonCanonArgs =
+      ::getCanonicalTemplateArguments(*this, Args, CanonArgs);
 
   QualType Canon;
   if (AnyNonCanonArgs || CanonNNS != NNS || CanonKeyword != Keyword) {
     Canon = getDependentTemplateSpecializationType(CanonKeyword, CanonNNS,
                                                    Name,
                                                    CanonArgs);
 
     // Find the insert position again.
     DependentTemplateSpecializationTypes.FindNodeOrInsertPos(ID, InsertPos);
   }
 
   void *Mem = Allocate((sizeof(DependentTemplateSpecializationType) +
-                        sizeof(TemplateArgument) * NumArgs),
+                        sizeof(TemplateArgument) * Args.size()),
                        TypeAlignment);
   T = new (Mem) DependentTemplateSpecializationType(Keyword, NNS,
                                                     Name, Args, Canon);
   Types.push_back(T);
   DependentTemplateSpecializationTypes.InsertNode(T, InsertPos);
   return QualType(T, 0);
 }
 
if (BaseType->isDependentType()) {
     ut = new (*this, TypeAlignment) UnaryTransformType (BaseType,
                                                         UnderlyingType, Kind,
                                                         CanonType);
   }
   Types.push_back(ut);
   return QualType(ut, 0);
 }
 
-/// getAutoType - Return the uniqued reference to the 'auto' type which has been
-/// deduced to the given type, or to the canonical undeduced 'auto' type, or the
-/// canonical deduced-but-dependent 'auto' type.
-QualType
-ASTContext::getAutoType(QualType DeducedType, AutoTypeKeyword Keyword,
-                        bool IsDependent, bool IsPack,
-                        ConceptDecl *TypeConstraintConcept,
-                        ArrayRef<TemplateArgument> TypeConstraintArgs) const {
-  assert((!IsPack || IsDependent) && "only use IsPack for a dependent pack");
+QualType ASTContext::getAutoTypeInternal(
+    QualType DeducedType, AutoTypeKeyword Keyword, bool IsDependent,
+    bool IsPack, ConceptDecl *TypeConstraintConcept,
+    ArrayRef<TemplateArgument> TypeConstraintArgs, bool IsCanon) const {
   if (DeducedType.isNull() && Keyword == AutoTypeKeyword::Auto &&
       !TypeConstraintConcept && !IsDependent)
     return getAutoDeductType();
 
   // Look in the folding set for an existing type.
   void *InsertPos = nullptr;
   llvm::FoldingSetNodeID ID;
   AutoType::Profile(ID, *this, DeducedType, Keyword, IsDependent,
                     TypeConstraintConcept, TypeConstraintArgs);
   if (AutoType *AT = AutoTypes.FindNodeOrInsertPos(ID, InsertPos))
     return QualType(AT, 0);
 
+  QualType Canon;
+  if (!IsCanon) {
+    if (DeducedType.isNull()) {
+      SmallVector<TemplateArgument, 4> CanonArgs;
+      bool AnyNonCanonArgs =
+          ::getCanonicalTemplateArguments(*this, TypeConstraintArgs, CanonArgs);
+      if (AnyNonCanonArgs) {
+        Canon = getAutoTypeInternal(QualType(), Keyword, IsDependent, IsPack,
+                                    TypeConstraintConcept, CanonArgs, true);
+        // Find the insert position again.
+        AutoTypes.FindNodeOrInsertPos(ID, InsertPos);
+      }
+    } else {
+      Canon = DeducedType.getCanonicalType();
+    }
+  }
+
   void *Mem = Allocate(sizeof(AutoType) +
                            sizeof(TemplateArgument) * TypeConstraintArgs.size(),
                        TypeAlignment);
   auto *AT = new (Mem) AutoType(
       DeducedType, Keyword,
       (IsDependent ? TypeDependence::DependentInstantiation
                    : TypeDependence::None) |
           (IsPack ? TypeDependence::UnexpandedPack : TypeDependence::None),
-      TypeConstraintConcept, TypeConstraintArgs);
+      Canon, TypeConstraintConcept, TypeConstraintArgs);
   Types.push_back(AT);
-  if (InsertPos)
-    AutoTypes.InsertNode(AT, InsertPos);
   return QualType(AT, 0);
 }
 
+/// getAutoType - Return the uniqued reference to the 'auto' type which has been
+/// deduced to the given type, or to the canonical undeduced 'auto' type, or the
+/// canonical deduced-but-dependent 'auto' type.
+QualType
+ASTContext::getAutoType(QualType DeducedType, AutoTypeKeyword Keyword,
+                        bool IsDependent, bool IsPack,
+                        ConceptDecl *TypeConstraintConcept,
+                        ArrayRef<TemplateArgument> TypeConstraintArgs) const {
+  assert((!IsPack || IsDependent) && "only use IsPack for a dependent pack");
+  assert((!IsDependent || DeducedType.isNull()) &&
+         "A dependent auto should be undeduced");
+  return getAutoTypeInternal(DeducedType, Keyword, IsDependent, IsPack,
+                             TypeConstraintConcept, TypeConstraintArgs);
+}
+
 /// Return the uniqued reference to the deduced template specialization type
 /// which has been deduced to the given type, or to the canonical undeduced
 /// such type, or the canonical deduced-but-dependent such type.
 QualType ASTContext::getDeducedTemplateSpecializationType(
     TemplateName Template, QualType DeducedType, bool IsDependent) const {
   // Look in the folding set for an existing type.
   void *InsertPos = nullptr;
   llvm::FoldingSetNodeID ID;
   DeducedTemplateSpecializationType::Profile(ID, Template, DeducedType,
                                              IsDependent);
   if (DeducedTemplateSpecializationType *DTST =
           DeducedTemplateSpecializationTypes.FindNodeOrInsertPos(ID, InsertPos))
     return QualType(DTST, 0);
 
   auto *DTST = new (*this, TypeAlignment)
       DeducedTemplateSpecializationType(Template, DeducedType, IsDependent);
   Types.push_back(DTST);
-  if (InsertPos)
-    DeducedTemplateSpecializationTypes.InsertNode(DTST, InsertPos);
   return QualType(DTST, 0);
 }
 
 /// getAtomicType - Return the uniqued reference to the atomic type for
 /// the given value type.
 QualType ASTContext::getAtomicType(QualType T) const {
   // Unique pointers, to guarantee there is only one pointer of a particular
   // structure.
QualType ASTContext::getAtomicType(QualType T) const {
   return QualType(New, 0);
 }
 
 /// getAutoDeductType - Get type pattern for deducing against 'auto'.
 QualType ASTContext::getAutoDeductType() const {
   if (AutoDeductTy.isNull())
     AutoDeductTy = QualType(new (*this, TypeAlignment)
                                 AutoType(QualType(), AutoTypeKeyword::Auto,
-                                         TypeDependence::None,
+                                         TypeDependence::None, QualType(),
                                          /*concept*/ nullptr, /*args*/ {}),
                             0);
   return AutoDeductTy;
 }
 
 /// getAutoRRefDeductType - Get type pattern for deducing against 'auto &&'.
 QualType ASTContext::getAutoRRefDeductType() const {
   if (AutoRRefDeductTy.isNull())

clang/lib/AST/ASTImporter.cpp

if (DCi == DC)
       return true;
     DCi = DCi->getParent();
   }
   return false;
 }
 
 bool ASTNodeImporter::hasAutoReturnTypeDeclaredInside(FunctionDecl *D) {
   QualType FromTy = D->getType();
-  const FunctionProtoType *FromFPT = FromTy->getAs<FunctionProtoType>();
+  const auto *FromFPT = FromTy->getAs<FunctionProtoType>();
   assert(FromFPT && "Must be called on FunctionProtoType");
-  if (AutoType *AutoT = FromFPT->getReturnType()->getContainedAutoType()) {
+  if (const AutoType *AutoT =
+          FromFPT->getReturnType()->getContainedAutoType()) {
     QualType DeducedT = AutoT->getDeducedType();
-    if (const RecordType *RecordT =
-            DeducedT.isNull() ? nullptr : dyn_cast<RecordType>(DeducedT)) {
-      RecordDecl *RD = RecordT->getDecl();
+    if (const auto *RecordT =
+            !DeducedT.isNull() ? DeducedT->getAs<RecordType>() : nullptr) {
+      const RecordDecl *RD = RecordT->getDecl();
       assert(RD);
       if (isAncestorDeclContextOf(D, RD)) {
         assert(RD->getLexicalDeclContext() == RD->getDeclContext());
         return true;
       }
     }
   }
-  if (const TypedefType *TypedefT =
-          dyn_cast<TypedefType>(FromFPT->getReturnType())) {
-    TypedefNameDecl *TD = TypedefT->getDecl();
+  if (const auto *TypedefT = FromFPT->getReturnType()->getAs<TypedefType>()) {
+    const TypedefNameDecl *TD = TypedefT->getDecl();
     assert(TD);
     if (isAncestorDeclContextOf(D, TD)) {
       assert(TD->getLexicalDeclContext() == TD->getDeclContext());
       return true;
     }
   }
   return false;
 }

clang/lib/AST/Type.cpp

void clang::FixedPointValueToString(SmallVectorImpl<char> &Str,
                                     llvm::APSInt Val, unsigned Scale) {
   llvm::FixedPointSemantics FXSema(Val.getBitWidth(), Scale, Val.isSigned(),
                                    /*IsSaturated=*/false,
                                    /*HasUnsignedPadding=*/false);
   llvm::APFixedPoint(Val, FXSema).toString(Str);
 }
 
 AutoType::AutoType(QualType DeducedAsType, AutoTypeKeyword Keyword,
-                   TypeDependence ExtraDependence,
+                   TypeDependence ExtraDependence, QualType Canon,
                    ConceptDecl *TypeConstraintConcept,
                    ArrayRef<TemplateArgument> TypeConstraintArgs)
-    : DeducedType(Auto, DeducedAsType, ExtraDependence) {
+    : DeducedType(Auto, DeducedAsType, ExtraDependence, Canon) {
   AutoTypeBits.Keyword = (unsigned)Keyword;
   AutoTypeBits.NumArgs = TypeConstraintArgs.size();
   this->TypeConstraintConcept = TypeConstraintConcept;
   if (TypeConstraintConcept) {
     TemplateArgument *ArgBuffer = getArgBuffer();
     for (const TemplateArgument &Arg : TypeConstraintArgs) {
       addDependence(
           toSyntacticDependence(toTypeDependence(Arg.getDependence())));

clang/lib/Sema/SemaCXXScopeSpec.cpp

 bool Sema::ActOnCXXNestedNameSpecifierDecltype(CXXScopeSpec &SS,
                                                const DeclSpec &DS,
                                                SourceLocation ColonColonLoc) {
   if (SS.isInvalid() || DS.getTypeSpecType() == DeclSpec::TST_error)
     return true;
 
   assert(DS.getTypeSpecType() == DeclSpec::TST_decltype);
 
-  QualType T = BuildDecltypeType(DS.getRepAsExpr(), DS.getTypeSpecTypeLoc());
+  QualType T = BuildDecltypeType(DS.getRepAsExpr());
   if (T.isNull())
     return true;
 
   if (!T->isDependentType() && !T->getAs<TagType>()) {
     Diag(DS.getTypeSpecTypeLoc(), diag::err_expected_class_or_namespace)
       << T << getLangOpts().CPlusPlus;
     return true;
   }

clang/lib/Sema/SemaDecl.cpp

if (getLangOpts().CPlusPlus) {
 
     QualType OldReturnType = OldType->getReturnType();
     QualType NewReturnType = cast<FunctionType>(NewQType)->getReturnType();
     if (OldReturnType != NewReturnType) {
       // If this function has a deduced return type and has already been
       // defined, copy the deduced value from the old declaration.
       AutoType *OldAT = Old->getReturnType()->getContainedAutoType();
       if (OldAT && OldAT->isDeduced()) {
-        New->setType(
-            SubstAutoType(New->getType(),
-                          OldAT->isDependentType() ? Context.DependentTy
-                                                   : OldAT->getDeducedType()));
-        NewQType = Context.getCanonicalType(
-            SubstAutoType(NewQType,
-                          OldAT->isDependentType() ? Context.DependentTy
-                                                   : OldAT->getDeducedType()));
+        QualType DT = OldAT->getDeducedType();
+        if (DT.isNull()) {
+          New->setType(SubstAutoTypeDependent(New->getType()));
+          NewQType = Context.getCanonicalType(SubstAutoTypeDependent(NewQType));
+        } else {
+          New->setType(SubstAutoType(New->getType(), DT));
+          NewQType = Context.getCanonicalType(SubstAutoType(NewQType, DT));
+        }
       }
     }
 
     const CXXMethodDecl *OldMethod = dyn_cast<CXXMethodDecl>(Old);
     CXXMethodDecl *NewMethod = dyn_cast<CXXMethodDecl>(New);
     if (OldMethod && NewMethod) {
       // Preserve triviality.
       NewMethod->setTrivial(OldMethod->isTrivial());
if (getLangOpts().CPlusPlus14 &&
       // If the function template is referenced directly (for instance, as a
       // member of the current instantiation), pretend it has a dependent type.
       // This is not really justified by the standard, but is the only sane
       // thing to do.
       // FIXME: For a friend function, we have not marked the function as being
       // a friend yet, so 'isDependentContext' on the FD doesn't work.
       const FunctionProtoType *FPT =
           NewFD->getType()->castAs<FunctionProtoType>();
-      QualType Result =
-          SubstAutoType(FPT->getReturnType(), Context.DependentTy);
+      QualType Result = SubstAutoTypeDependent(FPT->getReturnType());
       NewFD->setType(Context.getFunctionType(Result, FPT->getParamTypes(),
                                              FPT->getExtProtoInfo()));
     }
 
     // C++ [dcl.fct.spec]p3:
     //  The inline specifier shall not appear on a block scope function
     //  declaration.
     if (isInline && !NewFD->isInvalidDecl()) {
if (!VDecl->isInvalidDecl()) {
     if (VDecl->isInvalidDecl())
       return;
 
     InitializationSequence InitSeq(*this, Entity, Kind, Args,
                                    /*TopLevelOfInitList=*/false,
                                    /*TreatUnavailableAsInvalid=*/false);
     ExprResult Result = InitSeq.Perform(*this, Entity, Kind, Args, &DclT);
     if (Result.isInvalid()) {
-      // If the provied initializer fails to initialize the var decl,
+      // If the provided initializer fails to initialize the var decl,
       // we attach a recovery expr for better recovery.
       auto RecoveryExpr =
           CreateRecoveryExpr(Init->getBeginLoc(), Init->getEndLoc(), Args);
       if (RecoveryExpr.get())
         VDecl->setInit(RecoveryExpr.get());
       return;
     }
 

clang/lib/Sema/SemaDeclCXX.cpp

Sema::BuildMemInitializer(Decl *ConstructorD,
   QualType BaseType;
   TypeSourceInfo *TInfo = nullptr;
 
   if (TemplateTypeTy) {
     BaseType = GetTypeFromParser(TemplateTypeTy, &TInfo);
     if (BaseType.isNull())
       return true;
   } else if (DS.getTypeSpecType() == TST_decltype) {
-    BaseType = BuildDecltypeType(DS.getRepAsExpr(), DS.getTypeSpecTypeLoc());
+    BaseType = BuildDecltypeType(DS.getRepAsExpr());
   } else if (DS.getTypeSpecType() == TST_decltype_auto) {
     Diag(DS.getTypeSpecTypeLoc(), diag::err_decltype_auto_invalid);
     return true;
   } else {
     LookupResult R(*this, MemberOrBase, IdLoc, LookupOrdinaryName);
     LookupParsedName(R, S, &SS);
 
     TypeDecl *TyD = R.getAsSingle<TypeDecl>();

clang/lib/Sema/SemaExprCXX.cpp

ParsedType Sema::getDestructorTypeForDecltype(const DeclSpec &DS,
 
   if (DS.getTypeSpecType() == DeclSpec::TST_decltype_auto) {
     Diag(DS.getTypeSpecTypeLoc(), diag::err_decltype_auto_invalid);
     return nullptr;
   }
 
   assert(DS.getTypeSpecType() == DeclSpec::TST_decltype &&
          "unexpected type in getDestructorType");
-  QualType T = BuildDecltypeType(DS.getRepAsExpr(), DS.getTypeSpecTypeLoc());
+  QualType T = BuildDecltypeType(DS.getRepAsExpr());
 
   // If we know the type of the object, check that the correct destructor
   // type was named now; we can give better diagnostics this way.
   QualType SearchType = GetTypeFromParser(ObjectType);
   if (!SearchType.isNull() && !SearchType->isDependentType() &&
       !Context.hasSameUnqualifiedType(T, SearchType)) {
     Diag(DS.getTypeSpecTypeLoc(), diag::err_destructor_expr_type_mismatch)
       << T << SearchType;
ExprResult Sema::ActOnPseudoDestructorExpr(Scope *S, Expr *Base,
   if (CheckArrow(*this, ObjectType, Base, OpKind, OpLoc))
     return ExprError();
 
   if (DS.getTypeSpecType() == DeclSpec::TST_decltype_auto) {
     Diag(DS.getTypeSpecTypeLoc(), diag::err_decltype_auto_invalid);
     return true;
   }
 
-  QualType T = BuildDecltypeType(DS.getRepAsExpr(), DS.getTypeSpecTypeLoc(),
-                                 false);
+  QualType T = BuildDecltypeType(DS.getRepAsExpr(), /*AsUnevaluated=*/false);
 
   TypeLocBuilder TLB;
   DecltypeTypeLoc DecltypeTL = TLB.push<DecltypeTypeLoc>(T);
   DecltypeTL.setNameLoc(DS.getTypeSpecTypeLoc());
   TypeSourceInfo *DestructedTypeInfo = TLB.getTypeSourceInfo(Context, T);
   PseudoDestructorTypeStorage Destructed(DestructedTypeInfo);
 
   return BuildPseudoDestructorExpr(Base, OpLoc, OpKind, CXXScopeSpec(),

clang/lib/Sema/SemaInit.cpp

QualType Sema::DeduceTemplateSpecializationFromInitializer(
     TypeSourceInfo *TSInfo, const InitializedEntity &Entity,
     const InitializationKind &Kind, MultiExprArg Inits) {
   auto *DeducedTST = dyn_cast<DeducedTemplateSpecializationType>(
       TSInfo->getType()->getContainedDeducedType());
   assert(DeducedTST && "not a deduced template specialization type");
 
   auto TemplateName = DeducedTST->getTemplateName();
   if (TemplateName.isDependent())
-    return SubstAutoType(TSInfo->getType(), Context.DependentTy);
+    return SubstAutoTypeDependent(TSInfo->getType());
 
   // We can only perform deduction for class templates.
   auto *Template =
       dyn_cast_or_null<ClassTemplateDecl>(TemplateName.getAsTemplateDecl());
   if (!Template) {
     Diag(Kind.getLocation(),
          diag::err_deduced_non_class_template_specialization_type)
       << (int)getTemplateNameKindForDiagnostics(TemplateName) << TemplateName;
     if (auto *TD = TemplateName.getAsTemplateDecl())
       Diag(TD->getLocation(), diag::note_template_decl_here);
     return QualType();
   }
 
   // Can't deduce from dependent arguments.
   if (Expr::hasAnyTypeDependentArguments(Inits)) {
     Diag(TSInfo->getTypeLoc().getBeginLoc(),
          diag::warn_cxx14_compat_class_template_argument_deduction)
         << TSInfo->getTypeLoc().getSourceRange() << 0;
-    return SubstAutoType(TSInfo->getType(), Context.DependentTy);
+    return SubstAutoTypeDependent(TSInfo->getType());
   }
 
   // FIXME: Perform "exact type" matching first, per CWG discussion?
   //        Or implement this via an implied 'T(T) -> T' deduction guide?
 
   // FIXME: Do we need/want a std::initializer_list<T> special case?
 
   // Look up deduction guides, including those synthesized from constructors.

clang/lib/Sema/SemaLambda.cpp

TemplateParameterList *TemplateParams =
       getGenericLambdaTemplateParameterList(getCurLambda(), *this);
   // If a lambda appears in a dependent context or is a generic lambda (has
   // template parameters) and has an 'auto' return type, deduce it to a
   // dependent type.
   if (Class->isDependentContext() || TemplateParams) {
     const FunctionProtoType *FPT = MethodType->castAs<FunctionProtoType>();
     QualType Result = FPT->getReturnType();
     if (Result->isUndeducedType()) {
-      Result = SubstAutoType(Result, Context.DependentTy);
+      Result = SubstAutoTypeDependent(Result);
       MethodType = Context.getFunctionType(Result, FPT->getParamTypes(),
                                            FPT->getExtProtoInfo());
     }
   }
 
   // C++11 [expr.prim.lambda]p5:
   //   The closure type for a lambda-expression has a public inline function
   //   call operator (13.5.4) whose parameters and return type are described by

clang/lib/Sema/SemaStmt.cpp

if (RangeVarType->isDependentType()) {
     RangeVar->markUsed(Context);
 
     // Deduce any 'auto's in the loop variable as 'DependentTy'. We'll fill
     // them in properly when we instantiate the loop.
     if (!LoopVar->isInvalidDecl() && Kind != BFRK_Check) {
       if (auto *DD = dyn_cast<DecompositionDecl>(LoopVar))
         for (auto *Binding : DD->bindings())
           Binding->setType(Context.DependentTy);
-      LoopVar->setType(SubstAutoType(LoopVar->getType(), Context.DependentTy));
+      LoopVar->setType(SubstAutoTypeDependent(LoopVar->getType()));
     }
   } else if (!BeginDeclStmt.get()) {
     SourceLocation RangeLoc = RangeVar->getLocation();
 
     const QualType RangeVarNonRefType = RangeVarType.getNonReferenceType();
 
     ExprResult BeginRangeRef = BuildDeclRefExpr(RangeVar, RangeVarNonRefType,
                                                 VK_LValue, ColonLoc);

clang/lib/Sema/SemaTemplate.cpp

if (NTTP->getType() != TL.getType() ||
     return true;
   }
   // FIXME: Concepts: This should be the type of the placeholder, but this is
   // unclear in the wording right now.
   DeclRefExpr *Ref =
       BuildDeclRefExpr(NTTP, NTTP->getType(), VK_PRValue, NTTP->getLocation());
   if (!Ref)
     return true;
-  ExprResult ImmediatelyDeclaredConstraint =
-      formImmediatelyDeclaredConstraint(
-          *this, TL.getNestedNameSpecifierLoc(), TL.getConceptNameInfo(),
-          TL.getNamedConcept(), TL.getLAngleLoc(), TL.getRAngleLoc(),
-          BuildDecltypeType(Ref, NTTP->getLocation()), NTTP->getLocation(),
-          [&] (TemplateArgumentListInfo &ConstraintArgs) {
-            for (unsigned I = 0, C = TL.getNumArgs(); I != C; ++I)
-              ConstraintArgs.addArgument(TL.getArgLoc(I));
-          }, EllipsisLoc);
+  ExprResult ImmediatelyDeclaredConstraint = formImmediatelyDeclaredConstraint(
+      BuildDecltypeType(Ref), NTTP->getLocation(),
+      [&](TemplateArgumentListInfo &ConstraintArgs) {
+      },
+      EllipsisLoc);
   if (ImmediatelyDeclaredConstraint.isInvalid() ||
      !ImmediatelyDeclaredConstraint.isUsable())
     return true;
 
   NTTP->setPlaceholderTypeConstraint(ImmediatelyDeclaredConstraint.get());
   return false;
 }
 
 /// Check that the type of a non-type template parameter is
 /// well-formed.
 ///
 /// \returns the (possibly-promoted) parameter type if valid;
 /// otherwise, produces a diagnostic and returns a NULL type.
 QualType Sema::CheckNonTypeTemplateParameterType(TypeSourceInfo *&TSI,
                                                  SourceLocation Loc) {
   if (TSI->getType()->isUndeducedType()) {
     // C++17 [temp.dep.expr]p3:
     //   An id-expression is type-dependent if it contains
     //    - an identifier associated by name lookup with a non-type
     //      template-parameter declared with a type that contains a
     //      placeholder type (7.1.7.4),
-    TSI = SubstAutoTypeSourceInfo(TSI, Context.DependentTy);
+    TSI = SubstAutoTypeSourceInfoDependent(TSI);
   }
 
   return CheckNonTypeTemplateParameterType(TSI->getType(), Loc);
 }
 
 /// Require the given type to be a structural type, and diagnose if it is not.
 ///
 /// \return \c true if an error was produced.
if (!NewTSI)
       return true;
 
     if (NewTSI->getType()->isUndeducedType()) {
       // C++17 [temp.dep.expr]p3:
       //   An id-expression is type-dependent if it contains
       //    - an identifier associated by name lookup with a non-type
       //      template-parameter declared with a type that contains a
       //      placeholder type (7.1.7.4),
-      NewTSI = SubstAutoTypeSourceInfo(NewTSI, Context.DependentTy);
+      NewTSI = SubstAutoTypeSourceInfoDependent(NewTSI);
     }
 
     if (NewTSI != NTTP->getTypeSourceInfo()) {
       NTTP->setTypeSourceInfo(NewTSI);
       NTTP->setType(NewTSI->getType());
     }
   }
 

clang/lib/Sema/SemaTemplateDeduction.cpp

if (X.isSigned() != Y.isSigned()) {
 
     Y.setIsSigned(true);
     X.setIsSigned(true);
   }
 
   return X == Y;
 }
 
-static Sema::TemplateDeductionResult
-DeduceTemplateArguments(Sema &S,
-                        TemplateParameterList *TemplateParams,
-                        const TemplateArgument &Param,
-                        TemplateArgument Arg,
-                        TemplateDeductionInfo &Info,
-                        SmallVectorImpl<DeducedTemplateArgument> &Deduced);
-
-static Sema::TemplateDeductionResult
-DeduceTemplateArgumentsByTypeMatch(Sema &S,
-                                   TemplateParameterList *TemplateParams,
-                                   QualType Param,
-                                   QualType Arg,
-                                   TemplateDeductionInfo &Info,
-                                   SmallVectorImpl<DeducedTemplateArgument> &
-                                                      Deduced,
-                                   unsigned TDF,
-                                   bool PartialOrdering = false,
-                                   bool DeducedFromArrayBound = false);
+static Sema::TemplateDeductionResult DeduceTemplateArgumentsByTypeMatch(
+    Sema &S, TemplateParameterList *TemplateParams, QualType Param,
+    QualType Arg, TemplateDeductionInfo &Info,
+    SmallVectorImpl<DeducedTemplateArgument> &Deduced, unsigned TDF,
+    bool PartialOrdering = false, bool DeducedFromArrayBound = false);
 
 static Sema::TemplateDeductionResult
 DeduceTemplateArguments(Sema &S, TemplateParameterList *TemplateParams,
-                        ArrayRef<TemplateArgument> Params,
-                        ArrayRef<TemplateArgument> Args,
+                        ArrayRef<TemplateArgument> Ps,
+                        ArrayRef<TemplateArgument> As,
                         TemplateDeductionInfo &Info,
                         SmallVectorImpl<DeducedTemplateArgument> &Deduced,
                         bool NumberOfArgumentsMustMatch);
 
 static void MarkUsedTemplateParameters(ASTContext &Ctx,
                                        const TemplateArgument &TemplateArg,
                                        bool OnlyDeduced, unsigned Depth,
                                        llvm::SmallBitVector &Used);
checkDeducedTemplateArguments(ASTContext &Context,
   switch (X.getKind()) {
   case TemplateArgument::Null:
     llvm_unreachable("Non-deduced template arguments handled above");
 
   case TemplateArgument::Type:
     // If two template type arguments have the same type, they're compatible.
     if (Y.getKind() == TemplateArgument::Type &&
         Context.hasSameType(X.getAsType(), Y.getAsType()))
       return X;
 
     // If one of the two arguments was deduced from an array bound, the other
     // supersedes it.
     if (X.wasDeducedFromArrayBound() != Y.wasDeducedFromArrayBound())
       return X.wasDeducedFromArrayBound() ? Y : X;
 
     // The arguments are not compatible.
     return DeducedTemplateArgument();

 /// \param Info information about the template argument deduction itself
 ///
 /// \param Deduced the deduced template arguments
 ///
 /// \returns the result of template argument deduction so far. Note that a
 /// "success" result means that template argument deduction has not yet failed,
 /// but it may still fail, later, for other reasons.
 static Sema::TemplateDeductionResult
-DeduceTemplateArguments(Sema &S,
-                        TemplateParameterList *TemplateParams,
-                        const TemplateSpecializationType *Param,
-                        QualType Arg,
+DeduceTemplateSpecArguments(Sema &S, TemplateParameterList *TemplateParams,
+                            const QualType P, QualType A,
                             TemplateDeductionInfo &Info,
                             SmallVectorImpl<DeducedTemplateArgument> &Deduced) {
-  assert(Arg.isCanonical() && "Argument type must be canonical");
+  QualType UP = P;
+  if (const auto *IP = P->getAs<InjectedClassNameType>())
+    UP = IP->getInjectedSpecializationType();
+  // FIXME: Try to preserve type sugar here, which is hard
+  // because of the unresolved template arguments.
+  const auto *TP = UP.getCanonicalType()->castAs<TemplateSpecializationType>();
+  ArrayRef<TemplateArgument> PResolved = TP->template_arguments();
 
+  QualType UA = A;
   // Treat an injected-class-name as its underlying template-id.
-  if (auto *Injected = dyn_cast<InjectedClassNameType>(Arg))
-    Arg = Injected->getInjectedSpecializationType();
+  if (const auto *Injected = A->getAs<InjectedClassNameType>())
+    UA = Injected->getInjectedSpecializationType();
 
   // Check whether the template argument is a dependent template-id.
-  if (const TemplateSpecializationType *SpecArg
-        = dyn_cast<TemplateSpecializationType>(Arg)) {
+  // FIXME: Should not lose sugar here.
+  if (const auto *SA =
+          dyn_cast<TemplateSpecializationType>(UA.getCanonicalType())) {
     // Perform template argument deduction for the template name.
-    if (Sema::TemplateDeductionResult Result
-          = DeduceTemplateArguments(S, TemplateParams,
-                                    Param->getTemplateName(),
-                                    SpecArg->getTemplateName(),
-                                    Info, Deduced))
+    if (auto Result =
+            DeduceTemplateArguments(S, TemplateParams, TP->getTemplateName(),
+                                    SA->getTemplateName(), Info, Deduced))
       return Result;
-
-
     // Perform template argument deduction on each template
     // argument. Ignore any missing/extra arguments, since they could be
     // filled in by default arguments.
-    return DeduceTemplateArguments(S, TemplateParams,
-                                   Param->template_arguments(),
-                                   SpecArg->template_arguments(), Info, Deduced,
+    return DeduceTemplateArguments(S, TemplateParams, PResolved,
+                                   SA->template_arguments(), Info, Deduced,
                                    /*NumberOfArgumentsMustMatch=*/false);
   }
 
   // If the argument type is a class template specialization, we
   // perform template argument deduction using its template
   // arguments.
-  const RecordType *RecordArg = dyn_cast<RecordType>(Arg);
-  if (!RecordArg) {
-    Info.FirstArg = TemplateArgument(QualType(Param, 0));
-    Info.SecondArg = TemplateArgument(Arg);
-    return Sema::TDK_NonDeducedMismatch;
-  }
-
-  ClassTemplateSpecializationDecl *SpecArg
-    = dyn_cast<ClassTemplateSpecializationDecl>(RecordArg->getDecl());
-  if (!SpecArg) {
-    Info.FirstArg = TemplateArgument(QualType(Param, 0));
-    Info.SecondArg = TemplateArgument(Arg);
+  const auto *RA = UA->getAs<RecordType>();
+  const auto *SA =
+      RA ? dyn_cast<ClassTemplateSpecializationDecl>(RA->getDecl()) : nullptr;
+  if (!SA) {
+    Info.FirstArg = TemplateArgument(P);
+    Info.SecondArg = TemplateArgument(A);
     return Sema::TDK_NonDeducedMismatch;
   }
 
   // Perform template argument deduction for the template name.
-  if (Sema::TemplateDeductionResult Result
-        = DeduceTemplateArguments(S,
-                                  TemplateParams,
-                                  Param->getTemplateName(),
-                               TemplateName(SpecArg->getSpecializedTemplate()),
-                                  Info, Deduced))
+  if (auto Result = DeduceTemplateArguments(
+          S, TemplateParams, TP->getTemplateName(),
+          TemplateName(SA->getSpecializedTemplate()), Info, Deduced))
     return Result;
 
   // Perform template argument deduction for the template arguments.
-  return DeduceTemplateArguments(S, TemplateParams, Param->template_arguments(),
-                                 SpecArg->getTemplateArgs().asArray(), Info,
-                                 Deduced, /*NumberOfArgumentsMustMatch=*/true);
+  return DeduceTemplateArguments(S, TemplateParams, PResolved,
+                                 SA->getTemplateArgs().asArray(), Info, Deduced,
+                                 /*NumberOfArgumentsMustMatch=*/true);
 }
 
-/// Determines whether the given type is an opaque type that
-/// might be more qualified when instantiated.
-static bool IsPossiblyOpaquelyQualifiedType(QualType T) {
+static bool IsPossiblyOpaquelyQualifiedType(const Type *T) {
+  assert(T->isCanonicalUnqualified());
+
   switch (T->getTypeClass()) {
   case Type::TypeOfExpr:
   case Type::TypeOf:
   case Type::DependentName:
   case Type::Decltype:
   case Type::UnresolvedUsing:
   case Type::TemplateTypeParm:
     return true;
 
   case Type::ConstantArray:
   case Type::IncompleteArray:
   case Type::VariableArray:
   case Type::DependentSizedArray:
     return IsPossiblyOpaquelyQualifiedType(
-                                      cast<ArrayType>(T)->getElementType());
+        cast<ArrayType>(T)->getElementType().getTypePtr());
 
   default:
     return false;
   }
 }
 
+/// Determines whether the given type is an opaque type that
+/// might be more qualified when instantiated.
+static bool IsPossiblyOpaquelyQualifiedType(QualType T) {
+  return IsPossiblyOpaquelyQualifiedType(
+      T->getCanonicalTypeInternal().getTypePtr());
+}
+
 /// Helper function to build a TemplateParameter when we don't
 /// know its type statically.
 static TemplateParameter makeTemplateParameter(Decl *D) {
   if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(D))
     return TemplateParameter(TTP);
   if (NonTypeTemplateParmDecl *NTTP = dyn_cast<NonTypeTemplateParmDecl>(D))
     return TemplateParameter(NTTP);
 
if (!Expansion) {
       if (isa<PackExpansionType>(Args[ArgIdx])) {
         // C++0x [temp.deduct.type]p22:
         //   If the original function parameter associated with A is a function
         //   parameter pack and the function parameter associated with P is not
         //   a function parameter pack, then template argument deduction fails.
         return Sema::TDK_MiscellaneousDeductionFailure;
       }
 
-      if (Sema::TemplateDeductionResult Result
-            = DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
-                                                 Params[ParamIdx], Args[ArgIdx],
-                                                 Info, Deduced, TDF,
-                                                 PartialOrdering))
+      if (Sema::TemplateDeductionResult Result =
+              DeduceTemplateArgumentsByTypeMatch(
+                  S, TemplateParams, Params[ParamIdx].getUnqualifiedType(),
+                  Args[ArgIdx].getUnqualifiedType(), Info, Deduced, TDF,
+                  PartialOrdering,
+                  /*DeducedFromArrayBound=*/false))
         return Result;
 
       ++ArgIdx;
       continue;
     }
 
     // C++0x [temp.deduct.type]p10:
     //   If the parameter-declaration corresponding to Pi is a function
     //   parameter pack, then the type of its declarator- id is compared with
     //   each remaining parameter type in the parameter-type-list of A. Each
     //   comparison deduces template arguments for subsequent positions in the
     //   template parameter packs expanded by the function parameter pack.
 
     QualType Pattern = Expansion->getPattern();
     PackDeductionScope PackScope(S, TemplateParams, Deduced, Info, Pattern);
 
     // A pack scope with fixed arity is not really a pack any more, so is not
     // a non-deduced context.
     if (ParamIdx + 1 == NumParams || PackScope.hasFixedArity()) {
       for (; ArgIdx < NumArgs && PackScope.hasNextElement(); ++ArgIdx) {
         // Deduce template arguments from the pattern.
-        if (Sema::TemplateDeductionResult Result
-              = DeduceTemplateArgumentsByTypeMatch(S, TemplateParams, Pattern,
-                                                   Args[ArgIdx], Info, Deduced,
-                                                   TDF, PartialOrdering))
+        if (Sema::TemplateDeductionResult Result =
+                DeduceTemplateArgumentsByTypeMatch(
+                    S, TemplateParams, Pattern.getUnqualifiedType(),
+                    Args[ArgIdx].getUnqualifiedType(), Info, Deduced, TDF,
+                    PartialOrdering, /*DeducedFromArrayBound=*/false))
           return Result;
 
         PackScope.nextPackElement();
       }
     } else {
       // C++0x [temp.deduct.type]p5:
       //   The non-deduced contexts are:
       //     - A function parameter pack that does not occur at the end of the
static bool hasInconsistentOrSupersetQualifiersOf(QualType ParamType,
   // CVR qualifiers inconsistent or a superset.
   return (ParamQs.getCVRQualifiers() & ~ArgQs.getCVRQualifiers()) != 0;
 }
 
 /// Compare types for equality with respect to possibly compatible
 /// function types (noreturn adjustment, implicit calling conventions). If any
 /// of parameter and argument is not a function, just perform type comparison.
 ///
-/// \param Param the template parameter type.
+/// \param P the template parameter type.
 ///
-/// \param Arg the argument type.
-bool Sema::isSameOrCompatibleFunctionType(CanQualType Param,
-                                          CanQualType Arg) {
-  const FunctionType *ParamFunction = Param->getAs<FunctionType>(),
-                     *ArgFunction   = Arg->getAs<FunctionType>();
+/// \param A the argument type.
+bool Sema::isSameOrCompatibleFunctionType(QualType P, QualType A) {
+  const FunctionType *PF = P->getAs<FunctionType>(),
+                     *AF = A->getAs<FunctionType>();
 
   // Just compare if not functions.
-  if (!ParamFunction || !ArgFunction)
-    return Param == Arg;
+  if (!PF || !AF)
+    return Context.hasSameType(P, A);
 
   // Noreturn and noexcept adjustment.
   QualType AdjustedParam;
-  if (IsFunctionConversion(Param, Arg, AdjustedParam))
-    return Arg == Context.getCanonicalType(AdjustedParam);
+  if (IsFunctionConversion(P, A, AdjustedParam))
+    return Context.hasSameType(AdjustedParam, A);
 
   // FIXME: Compatible calling conventions.
 
-  return Param == Arg;
+  return Context.hasSameType(P, A);
 }
 
 /// Get the index of the first template parameter that was originally from the
 /// innermost template-parameter-list. This is 0 except when we concatenate
 /// the template parameter lists of a class template and a constructor template
 /// when forming an implicit deduction guide.
 static unsigned getFirstInnerIndex(FunctionTemplateDecl *FTD) {
   auto *Guide = dyn_cast<CXXDeductionGuideDecl>(FTD->getTemplatedDecl());
if (auto *ParamRef = Param->getAs<RValueReferenceType>()) {
     if (ParamRef->getPointeeType().getQualifiers())
       return false;
     auto *TypeParm = ParamRef->getPointeeType()->getAs<TemplateTypeParmType>();
     return TypeParm && TypeParm->getIndex() >= FirstInnerIndex;
   }
   return false;
 }
 
+static CXXRecordDecl *getCanonicalRD(QualType T) {
+  return cast<CXXRecordDecl>(
+      T->castAs<RecordType>()->getDecl()->getCanonicalDecl());
+}
+
 ///  Attempt to deduce the template arguments by checking the base types
 ///  according to (C++20 [temp.deduct.call] p4b3.
 ///
 /// \param S the semantic analysis object within which we are deducing.
 ///
 /// \param RecordT the top level record object we are deducing against.
 ///
 /// \param TemplateParams the template parameters that we are deducing.
 ///
 /// \param SpecParam the template specialization parameter type.
 ///
 /// \param Info information about the template argument deduction itself.
 ///
 /// \param Deduced the deduced template arguments.
 ///
 /// \returns the result of template argument deduction with the bases. "invalid"
 /// means no matches, "success" found a single item, and the
 /// "MiscellaneousDeductionFailure" result happens when the match is ambiguous.
-static Sema::TemplateDeductionResult DeduceTemplateBases(
-    Sema &S, const RecordType *RecordT, TemplateParameterList *TemplateParams,
-    const TemplateSpecializationType *SpecParam, TemplateDeductionInfo &Info,
+static Sema::TemplateDeductionResult
+DeduceTemplateBases(Sema &S, const CXXRecordDecl *RD,
+                    TemplateParameterList *TemplateParams, QualType P,
+                    TemplateDeductionInfo &Info,
                     SmallVectorImpl<DeducedTemplateArgument> &Deduced) {
   // C++14 [temp.deduct.call] p4b3:
   //   If P is a class and P has the form simple-template-id, then the
   //   transformed A can be a derived class of the deduced A. Likewise if
   //   P is a pointer to a class of the form simple-template-id, the
   //   transformed A can be a pointer to a derived class pointed to by the
   //   deduced A. However, if there is a class C that is a (direct or
   //   indirect) base class of D and derived (directly or indirectly) from a
   //   class B and that would be a valid deduced A, the deduced A cannot be
   //   B or pointer to B, respectively.
   //
   //   These alternatives are considered only if type deduction would
   //   otherwise fail. If they yield more than one possible deduced A, the
   //   type deduction fails.
 
   // Use a breadth-first search through the bases to collect the set of
   // successful matches. Visited contains the set of nodes we have already
   // visited, while ToVisit is our stack of records that we still need to
   // visit.  Matches contains a list of matches that have yet to be
   // disqualified.
-  llvm::SmallPtrSet<const RecordType *, 8> Visited;
-  SmallVector<const RecordType *, 8> ToVisit;
+  llvm::SmallPtrSet<const CXXRecordDecl *, 8> Visited;
+  SmallVector<QualType, 8> ToVisit;
   // We iterate over this later, so we have to use MapVector to ensure
   // determinism.
-  llvm::MapVector<const RecordType *, SmallVector<DeducedTemplateArgument, 8>>
+  llvm::MapVector<const CXXRecordDecl *,
+                  SmallVector<DeducedTemplateArgument, 8>>
       Matches;
 
-  auto AddBases = [&Visited, &ToVisit](const RecordType *RT) {
-    CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl());
+  auto AddBases = [&Visited, &ToVisit](const CXXRecordDecl *RD) {
     for (const auto &Base : RD->bases()) {
-      assert(Base.getType()->isRecordType() &&
-             "Base class that isn't a record?");
-      const RecordType *RT = Base.getType()->getAs<RecordType>();
-      if (Visited.insert(RT).second)
-        ToVisit.push_back(Base.getType()->getAs<RecordType>());
+      QualType T = Base.getType();
+      assert(T->isRecordType() && "Base class that isn't a record?");
+      if (Visited.insert(::getCanonicalRD(T)).second)
+        ToVisit.push_back(T);
     }
   };
 
   // Set up the loop by adding all the bases.
-  AddBases(RecordT);
+  AddBases(RD);
 
   // Search each path of bases until we either run into a successful match
   // (where all bases of it are invalid), or we run out of bases.
   while (!ToVisit.empty()) {
-    const RecordType *NextT = ToVisit.pop_back_val();
+    QualType NextT = ToVisit.pop_back_val();
 
     SmallVector<DeducedTemplateArgument, 8> DeducedCopy(Deduced.begin(),
                                                         Deduced.end());
     TemplateDeductionInfo BaseInfo(TemplateDeductionInfo::ForBase, Info);
-    Sema::TemplateDeductionResult BaseResult =
-        DeduceTemplateArguments(S, TemplateParams, SpecParam,
-                                QualType(NextT, 0), BaseInfo, DeducedCopy);
+    Sema::TemplateDeductionResult BaseResult = DeduceTemplateSpecArguments(
+        S, TemplateParams, P, NextT, BaseInfo, DeducedCopy);
 
     // If this was a successful deduction, add it to the list of matches,
     // otherwise we need to continue searching its bases.
+    const CXXRecordDecl *RD = ::getCanonicalRD(NextT);
     if (BaseResult == Sema::TDK_Success)
-      Matches.insert({NextT, DeducedCopy});
+      Matches.insert({RD, DeducedCopy});
     else
-      AddBases(NextT);
+      AddBases(RD);
   }
 
   // At this point, 'Matches' contains a list of seemingly valid bases, however
   // in the event that we have more than 1 match, it is possible that the base
   // of one of the matches might be disqualified for being a base of another
   // valid match. We can count on cyclical instantiations being invalid to
   // simplify the disqualifications.  That is, if A & B are both matches, and B
   // inherits from A (disqualifying A), we know that A cannot inherit from B.
   if (Matches.size() > 1) {
     Visited.clear();
     for (const auto &Match : Matches)
       AddBases(Match.first);
 
     // We can give up once we have a single item (or have run out of things to
     // search) since cyclical inheritance isn't valid.
     while (Matches.size() > 1 && !ToVisit.empty()) {
-      const RecordType *NextT = ToVisit.pop_back_val();
-      Matches.erase(NextT);
+      const CXXRecordDecl *RD = ::getCanonicalRD(ToVisit.pop_back_val());
+      Matches.erase(RD);
 
       // Always add all bases, since the inheritance tree can contain
       // disqualifications for multiple matches.
-      AddBases(NextT);
+      AddBases(RD);
     }
   }
 
   if (Matches.empty())
     return Sema::TDK_Invalid;
   if (Matches.size() > 1)
     return Sema::TDK_MiscellaneousDeductionFailure;
 

 /// how template argument deduction is performed.
 ///
 /// \param PartialOrdering Whether we're performing template argument deduction
 /// in the context of partial ordering (C++0x [temp.deduct.partial]).
 ///
 /// \returns the result of template argument deduction so far. Note that a
 /// "success" result means that template argument deduction has not yet failed,
 /// but it may still fail, later, for other reasons.
-static Sema::TemplateDeductionResult
-DeduceTemplateArgumentsByTypeMatch(Sema &S,
-                                   TemplateParameterList *TemplateParams,
-                                   QualType ParamIn, QualType ArgIn,
-                                   TemplateDeductionInfo &Info,
-                            SmallVectorImpl<DeducedTemplateArgument> &Deduced,
-                                   unsigned TDF,
-                                   bool PartialOrdering,
-                                   bool DeducedFromArrayBound) {
-  // We only want to look at the canonical types, since typedefs and
-  // sugar are not part of template argument deduction.
-  QualType Param = S.Context.getCanonicalType(ParamIn);
-  QualType Arg = S.Context.getCanonicalType(ArgIn);
-
-  // If the argument type is a pack expansion, look at its pattern.
-  // This isn't explicitly called out
-  if (const PackExpansionType *ArgExpansion
-                                            = dyn_cast<PackExpansionType>(Arg))
-    Arg = ArgExpansion->getPattern();
-
+static Sema::TemplateDeductionResult DeduceTemplateArgumentsByTypeMatch(
+    Sema &S, TemplateParameterList *TemplateParams, QualType P, QualType A,
+    SmallVectorImpl<DeducedTemplateArgument> &Deduced, unsigned TDF,
+    bool PartialOrdering, bool DeducedFromArrayBound) {
   if (PartialOrdering) {
     // C++11 [temp.deduct.partial]p5:
     //   Before the partial ordering is done, certain transformations are
     //   performed on the types used for partial ordering:
     //     - If P is a reference type, P is replaced by the type referred to.
-    const ReferenceType *ParamRef = Param->getAs<ReferenceType>();
-    if (ParamRef)
-      Param = ParamRef->getPointeeType();
+    const ReferenceType *PRef = P->getAs<ReferenceType>();
+    if (PRef)
+      P = PRef->getPointeeType();
 
     //     - If A is a reference type, A is replaced by the type referred to.
-    const ReferenceType *ArgRef = Arg->getAs<ReferenceType>();
-    if (ArgRef)
-      Arg = ArgRef->getPointeeType();
+    const ReferenceType *ARef = A->getAs<ReferenceType>();
+    if (ARef)
+      A = A->getPointeeType();
 
-    if (ParamRef && ArgRef && S.Context.hasSameUnqualifiedType(Param, Arg)) {
+    if (PRef && ARef && S.Context.hasSameUnqualifiedType(P, A)) {
       // C++11 [temp.deduct.partial]p9:
       //   If, for a given type, deduction succeeds in both directions (i.e.,
       //   the types are identical after the transformations above) and both
       //   P and A were reference types [...]:
       //     - if [one type] was an lvalue reference and [the other type] was
       //       not, [the other type] is not considered to be at least as
       //       specialized as [the first type]
       //     - if [one type] is more cv-qualified than [the other type],
       //       [the other type] is not considered to be at least as specialized
       //       as [the first type]
       // Objective-C ARC adds:
       //     - [one type] has non-trivial lifetime, [the other type] has
       //       __unsafe_unretained lifetime, and the types are otherwise
       //       identical
       //
       // A is "considered to be at least as specialized" as P iff deduction
       // succeeds, so we model this as a deduction failure. Note that
       // [the first type] is P and [the other type] is A here; the standard
       // gets this backwards.
-      Qualifiers ParamQuals = Param.getQualifiers();
-      Qualifiers ArgQuals = Arg.getQualifiers();
-      if ((ParamRef->isLValueReferenceType() &&
-           !ArgRef->isLValueReferenceType()) ||
-          ParamQuals.isStrictSupersetOf(ArgQuals) ||
-          (ParamQuals.hasNonTrivialObjCLifetime() &&
-           ArgQuals.getObjCLifetime() == Qualifiers::OCL_ExplicitNone &&
-           ParamQuals.withoutObjCLifetime() ==
-               ArgQuals.withoutObjCLifetime())) {
-        Info.FirstArg = TemplateArgument(ParamIn);
-        Info.SecondArg = TemplateArgument(ArgIn);
+      Qualifiers PQuals = P.getQualifiers(), AQuals = A.getQualifiers();
+      if ((PRef->isLValueReferenceType() && !ARef->isLValueReferenceType()) ||
+          PQuals.isStrictSupersetOf(AQuals) ||
+          (PQuals.hasNonTrivialObjCLifetime() &&
+           AQuals.getObjCLifetime() == Qualifiers::OCL_ExplicitNone &&
+           PQuals.withoutObjCLifetime() == AQuals.withoutObjCLifetime())) {
+        Info.FirstArg = TemplateArgument(P);
+        Info.SecondArg = TemplateArgument(A);
         return Sema::TDK_NonDeducedMismatch;
       }
     }
-
+    Qualifiers DiscardedQuals;
     // C++11 [temp.deduct.partial]p7:
     //   Remove any top-level cv-qualifiers:
     //     - If P is a cv-qualified type, P is replaced by the cv-unqualified
     //       version of P.
-    Param = Param.getUnqualifiedType();
+    P = S.Context.getUnqualifiedArrayType(P, DiscardedQuals);
     //     - If A is a cv-qualified type, A is replaced by the cv-unqualified
     //       version of A.
-    Arg = Arg.getUnqualifiedType();
+    A = S.Context.getUnqualifiedArrayType(A, DiscardedQuals);
   } else {
     // C++0x [temp.deduct.call]p4 bullet 1:
     //   - If the original P is a reference type, the deduced A (i.e., the type
     //     referred to by the reference) can be more cv-qualified than the
     //     transformed A.
     if (TDF & TDF_ParamWithReferenceType) {
       Qualifiers Quals;
-      QualType UnqualParam = S.Context.getUnqualifiedArrayType(Param, Quals);
-      Quals.setCVRQualifiers(Quals.getCVRQualifiers() &
-                             Arg.getCVRQualifiers());
-      Param = S.Context.getQualifiedType(UnqualParam, Quals);
+      QualType UnqualP = S.Context.getUnqualifiedArrayType(P, Quals);
+      Quals.setCVRQualifiers(Quals.getCVRQualifiers() & A.getCVRQualifiers());
+      P = S.Context.getQualifiedType(UnqualP, Quals);
     }
 
-    if ((TDF & TDF_TopLevelParameterTypeList) && !Param->isFunctionType()) {
+    if ((TDF & TDF_TopLevelParameterTypeList) && !P->isFunctionType()) {
       // C++0x [temp.deduct.type]p10:
       //   If P and A are function types that originated from deduction when
       //   taking the address of a function template (14.8.2.2) or when deducing
       //   template arguments from a function declaration (14.8.2.6) and Pi and
       //   Ai are parameters of the top-level parameter-type-list of P and A,
       //   respectively, Pi is adjusted if it is a forwarding reference and Ai
       //   is an lvalue reference, in
       //   which case the type of Pi is changed to be the template parameter
       //   type (i.e., T&& is changed to simply T). [ Note: As a result, when
       //   Pi is T&& and Ai is X&, the adjusted Pi will be T, causing T to be
       //   deduced as X&. - end note ]
       TDF &= ~TDF_TopLevelParameterTypeList;
-      if (isForwardingReference(Param, 0) && Arg->isLValueReferenceType())
-        Param = Param->getPointeeType();
+      if (isForwardingReference(P, /*FirstInnerIndex=*/0) &&
+          A->isLValueReferenceType())
+        P = P->getPointeeType();
     }
   }
 
   // C++ [temp.deduct.type]p9:
   //   A template type argument T, a template template argument TT or a
   //   template non-type argument i can be deduced if P and A have one of
   //   the following forms:
   //
   //     T
   //     cv-list T
-  if (const TemplateTypeParmType *TemplateTypeParm
-        = Param->getAs<TemplateTypeParmType>()) {
+  if (const auto *TTP = P->getAs<TemplateTypeParmType>()) {
     // Just skip any attempts to deduce from a placeholder type or a parameter
     // at a different depth.
-    if (Arg->isPlaceholderType() ||
-        Info.getDeducedDepth() != TemplateTypeParm->getDepth())
+    if (A->isPlaceholderType() || Info.getDeducedDepth() != TTP->getDepth())
       return Sema::TDK_Success;
 
-    unsigned Index = TemplateTypeParm->getIndex();
-    bool RecanonicalizeArg = false;
+    unsigned Index = TTP->getIndex();
 
     // If the argument type is an array type, move the qualifiers up to the
     // top level, so they can be matched with the qualifiers on the parameter.
-    if (isa<ArrayType>(Arg)) {
+    if (A->isArrayType()) {
       Qualifiers Quals;
-      Arg = S.Context.getUnqualifiedArrayType(Arg, Quals);
-      if (Quals) {
-        Arg = S.Context.getQualifiedType(Arg, Quals);
-        RecanonicalizeArg = true;
-      }
+      A = S.Context.getUnqualifiedArrayType(A, Quals);
+      if (Quals)
+        A = S.Context.getQualifiedType(A, Quals);
     }
 
     // The argument type can not be less qualified than the parameter
     // type.
     if (!(TDF & TDF_IgnoreQualifiers) &&
-        hasInconsistentOrSupersetQualifiersOf(Param, Arg)) {
+        hasInconsistentOrSupersetQualifiersOf(P, A)) {
       Info.Param = cast<TemplateTypeParmDecl>(TemplateParams->getParam(Index));
-      Info.FirstArg = TemplateArgument(Param);
-      Info.SecondArg = TemplateArgument(Arg);
+      Info.FirstArg = TemplateArgument(P);
+      Info.SecondArg = TemplateArgument(A);
       return Sema::TDK_Underqualified;
     }
 
     // Do not match a function type with a cv-qualified type.
     // http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#1584
-    if (Arg->isFunctionType() && Param.hasQualifiers()) {
+    if (A->isFunctionType() && P.hasQualifiers())
       return Sema::TDK_NonDeducedMismatch;
-    }
 
-    assert(TemplateTypeParm->getDepth() == Info.getDeducedDepth() &&
+    assert(TTP->getDepth() == Info.getDeducedDepth() &&
            "saw template type parameter with wrong depth");
-    assert(Arg != S.Context.OverloadTy && "Unresolved overloaded function");
-    QualType DeducedType = Arg;
+    assert(A->getCanonicalTypeInternal() != S.Context.OverloadTy &&
+           "Unresolved overloaded function");
+    QualType DeducedType = A;
 
     // Remove any qualifiers on the parameter from the deduced type.
     // We checked the qualifiers for consistency above.
     Qualifiers DeducedQs = DeducedType.getQualifiers();
-    Qualifiers ParamQs = Param.getQualifiers();
+    Qualifiers ParamQs = P.getQualifiers();
     DeducedQs.removeCVRQualifiers(ParamQs.getCVRQualifiers());
     if (ParamQs.hasObjCGCAttr())
       DeducedQs.removeObjCGCAttr();
     if (ParamQs.hasAddressSpace())
       DeducedQs.removeAddressSpace();
     if (ParamQs.hasObjCLifetime())
       DeducedQs.removeObjCLifetime();
 
     // Objective-C ARC:
     //   If template deduction would produce a lifetime qualifier on a type
     //   that is not a lifetime type, template argument deduction fails.
     if (ParamQs.hasObjCLifetime() && !DeducedType->isObjCLifetimeType() &&
         !DeducedType->isDependentType()) {
       Info.Param = cast<TemplateTypeParmDecl>(TemplateParams->getParam(Index));
-      Info.FirstArg = TemplateArgument(Param);
-      Info.SecondArg = TemplateArgument(Arg);
+      Info.FirstArg = TemplateArgument(P);
+      Info.SecondArg = TemplateArgument(A);
       return Sema::TDK_Underqualified;
     }
 
     // Objective-C ARC:
     //   If template deduction would produce an argument type with lifetime type
     //   but no lifetime qualifier, the __strong lifetime qualifier is inferred.
-    if (S.getLangOpts().ObjCAutoRefCount &&
-        DeducedType->isObjCLifetimeType() &&
+    if (S.getLangOpts().ObjCAutoRefCount && DeducedType->isObjCLifetimeType() &&
         !DeducedQs.hasObjCLifetime())
       DeducedQs.setObjCLifetime(Qualifiers::OCL_Strong);
 
-    DeducedType = S.Context.getQualifiedType(DeducedType.getUnqualifiedType(),
-                                             DeducedQs);
-
-    if (RecanonicalizeArg)
-      DeducedType = S.Context.getCanonicalType(DeducedType);
+    DeducedType =
+        S.Context.getQualifiedType(DeducedType.getUnqualifiedType(), DeducedQs);
 
     DeducedTemplateArgument NewDeduced(DeducedType, DeducedFromArrayBound);
-    DeducedTemplateArgument Result = checkDeducedTemplateArguments(S.Context,
-                                                                 Deduced[Index],
-                                                                   NewDeduced);
+    DeducedTemplateArgument Result =
+        checkDeducedTemplateArguments(S.Context, Deduced[Index], NewDeduced);
     if (Result.isNull()) {
       Info.Param = cast<TemplateTypeParmDecl>(TemplateParams->getParam(Index));
       Info.FirstArg = Deduced[Index];
       Info.SecondArg = NewDeduced;
       return Sema::TDK_Inconsistent;
     }
 
     Deduced[Index] = Result;
     return Sema::TDK_Success;
   }
 
   // Set up the template argument deduction information for a failure.
-  Info.FirstArg = TemplateArgument(ParamIn);
-  Info.SecondArg = TemplateArgument(ArgIn);
+  Info.FirstArg = TemplateArgument(P);
+  Info.SecondArg = TemplateArgument(A);
 
   // If the parameter is an already-substituted template parameter
   // pack, do nothing: we don't know which of its arguments to look
   // at, so we have to wait until all of the parameter packs in this
   // expansion have arguments.
-  if (isa<SubstTemplateTypeParmPackType>(Param))
+  if (P->getAs<SubstTemplateTypeParmPackType>())
     return Sema::TDK_Success;
 
   // Check the cv-qualifiers on the parameter and argument types.
-  CanQualType CanParam = S.Context.getCanonicalType(Param);
-  CanQualType CanArg = S.Context.getCanonicalType(Arg);
   if (!(TDF & TDF_IgnoreQualifiers)) {
     if (TDF & TDF_ParamWithReferenceType) {
-      if (hasInconsistentOrSupersetQualifiersOf(Param, Arg))
+      if (hasInconsistentOrSupersetQualifiersOf(P, A))
         return Sema::TDK_NonDeducedMismatch;
     } else if (TDF & TDF_ArgWithReferenceType) {
       // C++ [temp.deduct.conv]p4:
       //   If the original A is a reference type, A can be more cv-qualified
       //   than the deduced A
-      if (!Arg.getQualifiers().compatiblyIncludes(Param.getQualifiers()))
+      if (!A.getQualifiers().compatiblyIncludes(P.getQualifiers()))
         return Sema::TDK_NonDeducedMismatch;
 
       // Strip out all extra qualifiers from the argument to figure out the
       // type we're converting to, prior to the qualification conversion.
       Qualifiers Quals;
-      Arg = S.Context.getUnqualifiedArrayType(Arg, Quals);
-      Arg = S.Context.getQualifiedType(Arg, Param.getQualifiers());
-    } else if (!IsPossiblyOpaquelyQualifiedType(Param)) {
-      if (Param.getCVRQualifiers() != Arg.getCVRQualifiers())
+      A = S.Context.getUnqualifiedArrayType(A, Quals);
+      A = S.Context.getQualifiedType(A, P.getQualifiers());
+    } else if (!IsPossiblyOpaquelyQualifiedType(P)) {
+      if (P.getCVRQualifiers() != A.getCVRQualifiers())
         return Sema::TDK_NonDeducedMismatch;
     }
+  }
 
-    // If the parameter type is not dependent, there is nothing to deduce.
-    if (!Param->isDependentType()) {
-      if (!(TDF & TDF_SkipNonDependent)) {
-        bool NonDeduced =
-            (TDF & TDF_AllowCompatibleFunctionType)
-                ? !S.isSameOrCompatibleFunctionType(CanParam, CanArg)
-                : Param != Arg;
-        if (NonDeduced) {
-          return Sema::TDK_NonDeducedMismatch;
-        }
-      }
+  if (!P->isDependentType()) {
+    if (TDF & TDF_SkipNonDependent)
       return Sema::TDK_Success;
-    }
-  } else if (!Param->isDependentType()) {
-    if (!(TDF & TDF_SkipNonDependent)) {
-      CanQualType ParamUnqualType = CanParam.getUnqualifiedType(),
-                  ArgUnqualType = CanArg.getUnqualifiedType();
-      bool Success =
-          (TDF & TDF_AllowCompatibleFunctionType)
-              ? S.isSameOrCompatibleFunctionType(ParamUnqualType, ArgUnqualType)
-              : ParamUnqualType == ArgUnqualType;
-      if (Success)
-        return Sema::TDK_Success;
-    } else {
+    if ((TDF & TDF_IgnoreQualifiers) ? S.Context.hasSameUnqualifiedType(P, A)
+                                     : S.Context.hasSameType(P, A))
+    if (TDF & TDF_AllowCompatibleFunctionType &&
+        S.isSameOrCompatibleFunctionType(P, A))
       return Sema::TDK_Success;
-    }
+    if (!(TDF & TDF_IgnoreQualifiers))
+      return Sema::TDK_NonDeducedMismatch;
+    // Otherwise, when ignoring qualifiers, the types not having the same
+    // unqualified type does not mean they do not match, so in this case we
+    // must keep going and analyze with a non-dependent parameter type.
   }
 
-  switch (Param->getTypeClass()) {
+  switch (P.getCanonicalType()->getTypeClass()) {
     // Non-canonical types cannot appear here.
 #define NON_CANONICAL_TYPE(Class, Base) \
   case Type::Class: llvm_unreachable("deducing non-canonical type: " #Class);
 #define TYPE(Class, Base)
 #include "clang/AST/TypeNodes.inc"
 
     case Type::TemplateTypeParm:
     case Type::SubstTemplateTypeParmPack:
       llvm_unreachable("Type nodes handled above");
 
-    // These types cannot be dependent, so simply check whether the types are
-    // the same.
+    case Type::Auto:
+      // FIXME: Implement deduction in dependent case.
+      if (P->isDependentType())
+        return Sema::TDK_Success;
+      LLVM_FALLTHROUGH;
     case Type::Builtin:
     case Type::VariableArray:
     case Type::Vector:
     case Type::FunctionNoProto:
     case Type::Record:
     case Type::Enum:
     case Type::ObjCObject:
     case Type::ObjCInterface:
     case Type::ObjCObjectPointer:
     case Type::ExtInt:
-      if (TDF & TDF_SkipNonDependent)
-        return Sema::TDK_Success;
-
-      if (TDF & TDF_IgnoreQualifiers) {
-        Param = Param.getUnqualifiedType();
-        Arg = Arg.getUnqualifiedType();
-      }
-
-      return Param == Arg? Sema::TDK_Success : Sema::TDK_NonDeducedMismatch;
+      return (TDF & TDF_SkipNonDependent) ||
+                     ((TDF & TDF_IgnoreQualifiers)
+                          ? S.Context.hasSameUnqualifiedType(P, A)
+                          : S.Context.hasSameType(P, A))
+                 ? Sema::TDK_Success
+                 : Sema::TDK_NonDeducedMismatch;
 
     //     _Complex T   [placeholder extension]
-    case Type::Complex:
-      if (const ComplexType *ComplexArg = Arg->getAs<ComplexType>())
-        return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
-                                    cast<ComplexType>(Param)->getElementType(),
-                                    ComplexArg->getElementType(),
-                                    Info, Deduced, TDF);
-
+    case Type::Complex: {
+      const auto *CP = P->castAs<ComplexType>(), *CA = A->getAs<ComplexType>();
+      if (!CA)
         return Sema::TDK_NonDeducedMismatch;
+      return DeduceTemplateArgumentsByTypeMatch(
+          S, TemplateParams, CP->getElementType(), CA->getElementType(), Info,
+          Deduced, TDF);
+    }
 
     //     _Atomic T   [extension]
-    case Type::Atomic:
-      if (const AtomicType *AtomicArg = Arg->getAs<AtomicType>())
-        return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
-                                       cast<AtomicType>(Param)->getValueType(),
-                                       AtomicArg->getValueType(),
-                                       Info, Deduced, TDF);
-
+    case Type::Atomic: {
+      const auto *PA = P->castAs<AtomicType>(), *AA = A->getAs<AtomicType>();
+      if (!AA)
         return Sema::TDK_NonDeducedMismatch;
+      return DeduceTemplateArgumentsByTypeMatch(
+          S, TemplateParams, PA->getValueType(), AA->getValueType(), Info,
+          Deduced, TDF);
+    }
 
     //     T *
     case Type::Pointer: {
       QualType PointeeType;
-      if (const PointerType *PointerArg = Arg->getAs<PointerType>()) {
-        PointeeType = PointerArg->getPointeeType();
-      } else if (const ObjCObjectPointerType *PointerArg
-                   = Arg->getAs<ObjCObjectPointerType>()) {
-        PointeeType = PointerArg->getPointeeType();
+      if (const auto *PA = A->getAs<PointerType>()) {
+        PointeeType = PA->getPointeeType();
+      } else if (const auto *PA = A->getAs<ObjCObjectPointerType>()) {
+        PointeeType = PA->getPointeeType();
       } else {
         return Sema::TDK_NonDeducedMismatch;
       }
-
-      unsigned SubTDF = TDF & (TDF_IgnoreQualifiers | TDF_DerivedClass);
-      return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
-                                     cast<PointerType>(Param)->getPointeeType(),
-                                     PointeeType,
-                                     Info, Deduced, SubTDF);
+      return DeduceTemplateArgumentsByTypeMatch(
+          S, TemplateParams, P->castAs<PointerType>()->getPointeeType(),
+          PointeeType, Info, Deduced,
+          TDF & (TDF_IgnoreQualifiers | TDF_DerivedClass));
     }
 
     //     T &
     case Type::LValueReference: {
-      const LValueReferenceType *ReferenceArg =
-          Arg->getAs<LValueReferenceType>();
-      if (!ReferenceArg)
+      const auto *RP = P->castAs<LValueReferenceType>(),
+                 *RA = A->getAs<LValueReferenceType>();
+      if (!RA)
         return Sema::TDK_NonDeducedMismatch;
 
-      return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
-                           cast<LValueReferenceType>(Param)->getPointeeType(),
-                           ReferenceArg->getPointeeType(), Info, Deduced, 0);
+      return DeduceTemplateArgumentsByTypeMatch(
+          S, TemplateParams, RP->getPointeeType(), RA->getPointeeType(), Info,
+          Deduced, 0);
     }
 
     //     T && [C++0x]
     case Type::RValueReference: {
-      const RValueReferenceType *ReferenceArg =
-          Arg->getAs<RValueReferenceType>();
-      if (!ReferenceArg)
+      const auto *RP = P->castAs<RValueReferenceType>(),
+                 *RA = A->getAs<RValueReferenceType>();
+      if (!RA)
         return Sema::TDK_NonDeducedMismatch;
 
-      return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
-                             cast<RValueReferenceType>(Param)->getPointeeType(),
-                             ReferenceArg->getPointeeType(),
-                             Info, Deduced, 0);
+      return DeduceTemplateArgumentsByTypeMatch(
+          S, TemplateParams, RP->getPointeeType(), RA->getPointeeType(), Info,
+          Deduced, 0);
     }
 
     //     T [] (implied, but not stated explicitly)
     case Type::IncompleteArray: {
-      const IncompleteArrayType *IncompleteArrayArg =
-        S.Context.getAsIncompleteArrayType(Arg);
-      if (!IncompleteArrayArg)
+      const auto *IAA = S.Context.getAsIncompleteArrayType(A);
+      if (!IAA)
         return Sema::TDK_NonDeducedMismatch;
 
-      unsigned SubTDF = TDF & TDF_IgnoreQualifiers;
-      return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
-                    S.Context.getAsIncompleteArrayType(Param)->getElementType(),
-                    IncompleteArrayArg->getElementType(),
-                    Info, Deduced, SubTDF);
+      return DeduceTemplateArgumentsByTypeMatch(
+          S, TemplateParams,
+          S.Context.getAsIncompleteArrayType(P)->getElementType(),
+          IAA->getElementType(), Info, Deduced, TDF & TDF_IgnoreQualifiers);
     }
 
     //     T [integer-constant]
     case Type::ConstantArray: {
-      const ConstantArrayType *ConstantArrayArg =
-        S.Context.getAsConstantArrayType(Arg);
-      if (!ConstantArrayArg)
+      const auto *CAA = S.Context.getAsConstantArrayType(A),
+                 *CAP = S.Context.getAsConstantArrayType(P);
+      assert(CAP);
+      if (!CAA || CAA->getSize() != CAP->getSize())
         return Sema::TDK_NonDeducedMismatch;
 
-      const ConstantArrayType *ConstantArrayParm =
-        S.Context.getAsConstantArrayType(Param);
-      if (ConstantArrayArg->getSize() != ConstantArrayParm->getSize())
-        return Sema::TDK_NonDeducedMismatch;
-
-      unsigned SubTDF = TDF & TDF_IgnoreQualifiers;
-      return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
-                                           ConstantArrayParm->getElementType(),
-                                           ConstantArrayArg->getElementType(),
-                                           Info, Deduced, SubTDF);
+      return DeduceTemplateArgumentsByTypeMatch(
+          S, TemplateParams, CAP->getElementType(), CAA->getElementType(), Info,
+          Deduced, TDF & TDF_IgnoreQualifiers);
     }
 
     //     type [i]
     case Type::DependentSizedArray: {
-      const ArrayType *ArrayArg = S.Context.getAsArrayType(Arg);
-      if (!ArrayArg)
+      const auto *AA = S.Context.getAsArrayType(A);
+      if (!AA)
         return Sema::TDK_NonDeducedMismatch;
 
-      unsigned SubTDF = TDF & TDF_IgnoreQualifiers;
-
       // Check the element type of the arrays
-      const DependentSizedArrayType *DependentArrayParm
-        = S.Context.getAsDependentSizedArrayType(Param);
-      if (Sema::TemplateDeductionResult Result
-            = DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
-                                          DependentArrayParm->getElementType(),
-                                          ArrayArg->getElementType(),
-                                          Info, Deduced, SubTDF))
+      const auto *DAP = S.Context.getAsDependentSizedArrayType(P);
+      assert(DAP);
+      if (auto Result = DeduceTemplateArgumentsByTypeMatch(
+              S, TemplateParams, DAP->getElementType(), AA->getElementType(),
+              Info, Deduced, TDF & TDF_IgnoreQualifiers))
         return Result;
 
       // Determine the array bound is something we can deduce.
-      const NonTypeTemplateParmDecl *NTTP
-        = getDeducedParameterFromExpr(Info, DependentArrayParm->getSizeExpr());
+      const NonTypeTemplateParmDecl *NTTP =
+          getDeducedParameterFromExpr(Info, DAP->getSizeExpr());
       if (!NTTP)
         return Sema::TDK_Success;
 
       // We can perform template argument deduction for the given non-type
       // template parameter.
       assert(NTTP->getDepth() == Info.getDeducedDepth() &&
              "saw non-type template parameter with wrong depth");
-      if (const ConstantArrayType *ConstantArrayArg
-            = dyn_cast<ConstantArrayType>(ArrayArg)) {
-        llvm::APSInt Size(ConstantArrayArg->getSize());
-        return DeduceNonTypeTemplateArgument(S, TemplateParams, NTTP, Size,
-                                             S.Context.getSizeType(),
-                                             /*ArrayBound=*/true,
-                                             Info, Deduced);
+      if (const auto *CAA = dyn_cast<ConstantArrayType>(AA)) {
+        llvm::APSInt Size(CAA->getSize());
+        return DeduceNonTypeTemplateArgument(
+            S, TemplateParams, NTTP, Size, S.Context.getSizeType(),
+            /*ArrayBound=*/true, Info, Deduced);
       }
-      if (const DependentSizedArrayType *DependentArrayArg
-            = dyn_cast<DependentSizedArrayType>(ArrayArg))
-        if (DependentArrayArg->getSizeExpr())
-          return DeduceNonTypeTemplateArgument(S, TemplateParams, NTTP,
-                                               DependentArrayArg->getSizeExpr(),
-                                               Info, Deduced);
+      if (const auto *DAA = dyn_cast<DependentSizedArrayType>(AA))
+        if (DAA->getSizeExpr())
+          return DeduceNonTypeTemplateArgument(
+              S, TemplateParams, NTTP, DAA->getSizeExpr(), Info, Deduced);
 
       // Incomplete type does not match a dependently-sized array type
       return Sema::TDK_NonDeducedMismatch;
     }
 
     //     type(*)(T)
     //     T(*)()
     //     T(*)(T)
     case Type::FunctionProto: {
-      unsigned SubTDF = TDF & TDF_TopLevelParameterTypeList;
-      const FunctionProtoType *FunctionProtoArg =
-        dyn_cast<FunctionProtoType>(Arg);
-      if (!FunctionProtoArg)
+      const auto *FPP = P->castAs<FunctionProtoType>(),
+                 *FPA = A->getAs<FunctionProtoType>();
+      if (!FPA)
         return Sema::TDK_NonDeducedMismatch;
 
-      const FunctionProtoType *FunctionProtoParam =
-        cast<FunctionProtoType>(Param);
-
-      if (FunctionProtoParam->getMethodQuals()
-            != FunctionProtoArg->getMethodQuals() ||
-          FunctionProtoParam->getRefQualifier()
-            != FunctionProtoArg->getRefQualifier() ||
-          FunctionProtoParam->isVariadic() != FunctionProtoArg->isVariadic())
+      if (FPP->getMethodQuals() != FPA->getMethodQuals() ||
+          FPP->getRefQualifier() != FPA->getRefQualifier() ||
+          FPP->isVariadic() != FPA->isVariadic())
         return Sema::TDK_NonDeducedMismatch;
 
       // Check return types.
       if (auto Result = DeduceTemplateArgumentsByTypeMatch(
-              S, TemplateParams, FunctionProtoParam->getReturnType(),
-              FunctionProtoArg->getReturnType(), Info, Deduced, 0))
+              S, TemplateParams, FPP->getReturnType(), FPA->getReturnType(),
+              Info, Deduced, 0,
+              /*PartialOrdering=*/false,
+              /*DeducedFromArrayBound=*/false))
         return Result;
 
       // Check parameter types.
       if (auto Result = DeduceTemplateArguments(
-              S, TemplateParams, FunctionProtoParam->param_type_begin(),
-              FunctionProtoParam->getNumParams(),
-              FunctionProtoArg->param_type_begin(),
-              FunctionProtoArg->getNumParams(), Info, Deduced, SubTDF))
+              S, TemplateParams, FPP->param_type_begin(), FPP->getNumParams(),
+              FPA->param_type_begin(), FPA->getNumParams(), Info, Deduced,
+              TDF & TDF_TopLevelParameterTypeList))
         return Result;
 
       if (TDF & TDF_AllowCompatibleFunctionType)
         return Sema::TDK_Success;
 
       // FIXME: Per core-2016/10/1019 (no corresponding core issue yet), permit
       // deducing through the noexcept-specifier if it's part of the canonical
       // type. libstdc++ relies on this.
-      Expr *NoexceptExpr = FunctionProtoParam->getNoexceptExpr();
+      Expr *NoexceptExpr = FPP->getNoexceptExpr();
       if (const NonTypeTemplateParmDecl *NTTP =
               NoexceptExpr ? getDeducedParameterFromExpr(Info, NoexceptExpr)
                            : nullptr) {
         assert(NTTP->getDepth() == Info.getDeducedDepth() &&
                "saw non-type template parameter with wrong depth");
 
         llvm::APSInt Noexcept(1);
-        switch (FunctionProtoArg->canThrow()) {
+        switch (FPA->canThrow()) {
         case CT_Cannot:
           Noexcept = 1;
           LLVM_FALLTHROUGH;
 
         case CT_Can:
           // We give E in noexcept(E) the "deduced from array bound" treatment.
           // FIXME: Should we?
           return DeduceNonTypeTemplateArgument(
               S, TemplateParams, NTTP, Noexcept, S.Context.BoolTy,
-              /*ArrayBound*/true, Info, Deduced);
+              /*DeducedFromArrayBound=*/true, Info, Deduced);
 
         case CT_Dependent:
-          if (Expr *ArgNoexceptExpr = FunctionProtoArg->getNoexceptExpr())
+          if (Expr *ArgNoexceptExpr = FPA->getNoexceptExpr())
             return DeduceNonTypeTemplateArgument(
                 S, TemplateParams, NTTP, ArgNoexceptExpr, Info, Deduced);
           // Can't deduce anything from throw(T...).
           break;
         }
       }
       // FIXME: Detect non-deduced exception specification mismatches?
       //
       // Careful about [temp.deduct.call] and [temp.deduct.conv], which allow
       // top-level differences in noexcept-specifications.
 
       return Sema::TDK_Success;
     }
 
     case Type::InjectedClassName:
       // Treat a template's injected-class-name as if the template
       // specialization type had been used.
-      Param = cast<InjectedClassNameType>(Param)
-        ->getInjectedSpecializationType();
-      assert(isa<TemplateSpecializationType>(Param) &&
-             "injected class name is not a template specialization type");
-      LLVM_FALLTHROUGH;
 
     //     template-name<T> (where template-name refers to a class template)
     //     template-name<i>
     //     TT<T>
     //     TT<i>
     //     TT<>
     case Type::TemplateSpecialization: {
-      const TemplateSpecializationType *SpecParam =
-          cast<TemplateSpecializationType>(Param);
-
       // When Arg cannot be a derived class, we can just try to deduce template
       // arguments from the template-id.
-      const RecordType *RecordT = Arg->getAs<RecordType>();
-      if (!(TDF & TDF_DerivedClass) || !RecordT)
-        return DeduceTemplateArguments(S, TemplateParams, SpecParam, Arg, Info,
+      if (!(TDF & TDF_DerivedClass) || !A->isRecordType())
+        return DeduceTemplateSpecArguments(S, TemplateParams, P, A, Info,
                                            Deduced);
 
       SmallVector<DeducedTemplateArgument, 8> DeducedOrig(Deduced.begin(),
                                                           Deduced.end());
 
-      Sema::TemplateDeductionResult Result = DeduceTemplateArguments(
-          S, TemplateParams, SpecParam, Arg, Info, Deduced);
-
+      auto Result =
+          DeduceTemplateSpecArguments(S, TemplateParams, P, A, Info, Deduced);
       if (Result == Sema::TDK_Success)
         return Result;
 
       // We cannot inspect base classes as part of deduction when the type
       // is incomplete, so either instantiate any templates necessary to
       // complete the type, or skip over it if it cannot be completed.
-      if (!S.isCompleteType(Info.getLocation(), Arg))
+      if (!S.isCompleteType(Info.getLocation(), A))
         return Result;
 
       // Reset the incorrectly deduced argument from above.
       Deduced = DeducedOrig;
 
       // Check bases according to C++14 [temp.deduct.call] p4b3:
-      Sema::TemplateDeductionResult BaseResult = DeduceTemplateBases(
-          S, RecordT, TemplateParams, SpecParam, Info, Deduced);
-
-      if (BaseResult != Sema::TDK_Invalid)
-        return BaseResult;
-      return Result;
+      auto BaseResult = DeduceTemplateBases(S, getCanonicalRD(A),
+                                            TemplateParams, P, Info, Deduced);
+      return BaseResult != Sema::TDK_Invalid ? BaseResult : Result;
     }
 
     //     T type::*
     //     T T::*
     //     T (type::*)()
     //     type (T::*)()
     //     type (type::*)(T)
     //     type (T::*)(T)
     //     T (type::*)(T)
     //     T (T::*)()
     //     T (T::*)(T)
     case Type::MemberPointer: {
-      const MemberPointerType *MemPtrParam = cast<MemberPointerType>(Param);
-      const MemberPointerType *MemPtrArg = dyn_cast<MemberPointerType>(Arg);
-      if (!MemPtrArg)
+      const auto *MPP = P->castAs<MemberPointerType>(),
+                 *MPA = A->getAs<MemberPointerType>();
+      if (!MPA)
         return Sema::TDK_NonDeducedMismatch;
 
-      QualType ParamPointeeType = MemPtrParam->getPointeeType();
-      if (ParamPointeeType->isFunctionType())
-        S.adjustMemberFunctionCC(ParamPointeeType, /*IsStatic=*/true,
+      QualType PPT = MPP->getPointeeType();
+      if (PPT->isFunctionType())
+        S.adjustMemberFunctionCC(PPT, /*IsStatic=*/true,
                                  /*IsCtorOrDtor=*/false, Info.getLocation());
-      QualType ArgPointeeType = MemPtrArg->getPointeeType();
-      if (ArgPointeeType->isFunctionType())
-        S.adjustMemberFunctionCC(ArgPointeeType, /*IsStatic=*/true,
+      QualType APT = MPA->getPointeeType();
+      if (APT->isFunctionType())
+        S.adjustMemberFunctionCC(APT, /*IsStatic=*/true,
                                  /*IsCtorOrDtor=*/false, Info.getLocation());
 
-      if (Sema::TemplateDeductionResult Result
-            = DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
-                                                 ParamPointeeType,
-                                                 ArgPointeeType,
-                                                 Info, Deduced,
-                                                 TDF & TDF_IgnoreQualifiers))
+      unsigned SubTDF = TDF & TDF_IgnoreQualifiers;
+      if (auto Result = DeduceTemplateArgumentsByTypeMatch(
+              S, TemplateParams, PPT, APT, Info, Deduced, SubTDF))
         return Result;
-
-      return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
-                                           QualType(MemPtrParam->getClass(), 0),
-                                           QualType(MemPtrArg->getClass(), 0),
-                                           Info, Deduced,
-                                           TDF & TDF_IgnoreQualifiers);
+      return DeduceTemplateArgumentsByTypeMatch(
+          S, TemplateParams, QualType(MPP->getClass(), 0),
+          QualType(MPA->getClass(), 0), Info, Deduced, SubTDF);
     }
 
     //     (clang extension)
     //
     //     type(^)(T)
     //     T(^)()
     //     T(^)(T)
     case Type::BlockPointer: {
-      const BlockPointerType *BlockPtrParam = cast<BlockPointerType>(Param);
-      const BlockPointerType *BlockPtrArg = dyn_cast<BlockPointerType>(Arg);
-
-      if (!BlockPtrArg)
+      const auto *BPP = P->castAs<BlockPointerType>(),
+                 *BPA = A->getAs<BlockPointerType>();
+      if (!BPA)
         return Sema::TDK_NonDeducedMismatch;
-
-      return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
-                                                BlockPtrParam->getPointeeType(),
-                                                BlockPtrArg->getPointeeType(),
-                                                Info, Deduced, 0);
+      return DeduceTemplateArgumentsByTypeMatch(
+          S, TemplateParams, BPP->getPointeeType(), BPA->getPointeeType(), Info,
+          Deduced, 0);
     }
 
     //     (clang extension)
     //
     //     T __attribute__(((ext_vector_type(<integral constant>))))
     case Type::ExtVector: {
-      const ExtVectorType *VectorParam = cast<ExtVectorType>(Param);
-      if (const ExtVectorType *VectorArg = dyn_cast<ExtVectorType>(Arg)) {
+      const auto *VP = P->castAs<ExtVectorType>();
+      QualType ElementType;
+      if (const auto *VA = A->getAs<ExtVectorType>()) {
         // Make sure that the vectors have the same number of elements.
-        if (VectorParam->getNumElements() != VectorArg->getNumElements())
+        if (VP->getNumElements() != VA->getNumElements())
           return Sema::TDK_NonDeducedMismatch;
-
-        // Perform deduction on the element types.
-        return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
-                                                  VectorParam->getElementType(),
-                                                  VectorArg->getElementType(),
-                                                  Info, Deduced, TDF);
-      }
-
-      if (const DependentSizedExtVectorType *VectorArg
-                                = dyn_cast<DependentSizedExtVectorType>(Arg)) {
+        ElementType = VA->getElementType();
+      } else if (const auto *VA = A->getAs<DependentSizedExtVectorType>()) {
         // We can't check the number of elements, since the argument has a
         // dependent number of elements. This can only occur during partial
         // ordering.
-
-        // Perform deduction on the element types.
-        return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
-                                                  VectorParam->getElementType(),
-                                                  VectorArg->getElementType(),
-                                                  Info, Deduced, TDF);
-      }
-
+        ElementType = VA->getElementType();
+      } else {
         return Sema::TDK_NonDeducedMismatch;
       }
+      // Perform deduction on the element types.
+      return DeduceTemplateArgumentsByTypeMatch(
+          S, TemplateParams, VP->getElementType(), ElementType, Info, Deduced,
+          TDF);
+    }
 
     case Type::DependentVector: {
-      const auto *VectorParam = cast<DependentVectorType>(Param);
+      const auto *VP = P->castAs<DependentVectorType>();
 
-      if (const auto *VectorArg = dyn_cast<VectorType>(Arg)) {
+      if (const auto *VA = A->getAs<VectorType>()) {
         // Perform deduction on the element types.
-        if (Sema::TemplateDeductionResult Result =
-                DeduceTemplateArgumentsByTypeMatch(
-                    S, TemplateParams, VectorParam->getElementType(),
-                    VectorArg->getElementType(), Info, Deduced, TDF))
+        if (auto Result = DeduceTemplateArgumentsByTypeMatch(
+                S, TemplateParams, VP->getElementType(), VA->getElementType(),
+                Info, Deduced, TDF))
           return Result;
 
         // Perform deduction on the vector size, if we can.
         const NonTypeTemplateParmDecl *NTTP =
-            getDeducedParameterFromExpr(Info, VectorParam->getSizeExpr());
+            getDeducedParameterFromExpr(Info, VP->getSizeExpr());
         if (!NTTP)
           return Sema::TDK_Success;
 
         llvm::APSInt ArgSize(S.Context.getTypeSize(S.Context.IntTy), false);
-        ArgSize = VectorArg->getNumElements();
+        ArgSize = VA->getNumElements();
         // Note that we use the "array bound" rules here; just like in that
         // case, we don't have any particular type for the vector size, but
         // we can provide one if necessary.
         return DeduceNonTypeTemplateArgument(S, TemplateParams, NTTP, ArgSize,
                                              S.Context.UnsignedIntTy, true,
                                              Info, Deduced);
       }
 
-      if (const auto *VectorArg = dyn_cast<DependentVectorType>(Arg)) {
+      if (const auto *VA = A->getAs<DependentVectorType>()) {
         // Perform deduction on the element types.
-        if (Sema::TemplateDeductionResult Result =
-                DeduceTemplateArgumentsByTypeMatch(
-                    S, TemplateParams, VectorParam->getElementType(),
-                    VectorArg->getElementType(), Info, Deduced, TDF))
+        if (auto Result = DeduceTemplateArgumentsByTypeMatch(
+                S, TemplateParams, VP->getElementType(), VA->getElementType(),
+                Info, Deduced, TDF))
           return Result;
 
         // Perform deduction on the vector size, if we can.
-        const NonTypeTemplateParmDecl *NTTP = getDeducedParameterFromExpr(
-            Info, VectorParam->getSizeExpr());
+        const NonTypeTemplateParmDecl *NTTP =
+            getDeducedParameterFromExpr(Info, VP->getSizeExpr());
         if (!NTTP)
           return Sema::TDK_Success;
 
-        return DeduceNonTypeTemplateArgument(
-            S, TemplateParams, NTTP, VectorArg->getSizeExpr(), Info, Deduced);
+        return DeduceNonTypeTemplateArgument(S, TemplateParams, NTTP,
+                                             VA->getSizeExpr(), Info, Deduced);
       }
 
       return Sema::TDK_NonDeducedMismatch;
     }
 
     //     (clang extension)
     //
     //     T __attribute__(((ext_vector_type(N))))
     case Type::DependentSizedExtVector: {
-      const DependentSizedExtVectorType *VectorParam
-        = cast<DependentSizedExtVectorType>(Param);
+      const auto *VP = P->castAs<DependentSizedExtVectorType>();
 
-      if (const ExtVectorType *VectorArg = dyn_cast<ExtVectorType>(Arg)) {
+      if (const auto *VA = A->getAs<ExtVectorType>()) {
         // Perform deduction on the element types.
-        if (Sema::TemplateDeductionResult Result
-              = DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
-                                                  VectorParam->getElementType(),
-                                                   VectorArg->getElementType(),
-                                                   Info, Deduced, TDF))
+        if (auto Result = DeduceTemplateArgumentsByTypeMatch(
+                S, TemplateParams, VP->getElementType(), VA->getElementType(),
           return Result;
 
         // Perform deduction on the vector size, if we can.
         const NonTypeTemplateParmDecl *NTTP =
-            getDeducedParameterFromExpr(Info, VectorParam->getSizeExpr());
+            getDeducedParameterFromExpr(Info, VP->getSizeExpr());
         if (!NTTP)
           return Sema::TDK_Success;
 
         llvm::APSInt ArgSize(S.Context.getTypeSize(S.Context.IntTy), false);
-        ArgSize = VectorArg->getNumElements();
+        ArgSize = VA->getNumElements();
         // Note that we use the "array bound" rules here; just like in that
         // case, we don't have any particular type for the vector size, but
         // we can provide one if necessary.
         return DeduceNonTypeTemplateArgument(S, TemplateParams, NTTP, ArgSize,
                                              S.Context.IntTy, true, Info,
                                              Deduced);
       }
 
-      if (const DependentSizedExtVectorType *VectorArg
-                                = dyn_cast<DependentSizedExtVectorType>(Arg)) {
+      if (const auto *VA = A->getAs<DependentSizedExtVectorType>()) {
         // Perform deduction on the element types.
-        if (Sema::TemplateDeductionResult Result
-            = DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
-                                                 VectorParam->getElementType(),
-                                                 VectorArg->getElementType(),
-                                                 Info, Deduced, TDF))
+        if (auto Result = DeduceTemplateArgumentsByTypeMatch(
+                S, TemplateParams, VP->getElementType(), VA->getElementType(),
           return Result;
 
         // Perform deduction on the vector size, if we can.
         const NonTypeTemplateParmDecl *NTTP =
-            getDeducedParameterFromExpr(Info, VectorParam->getSizeExpr());
+            getDeducedParameterFromExpr(Info, VP->getSizeExpr());
         if (!NTTP)
           return Sema::TDK_Success;
 
         return DeduceNonTypeTemplateArgument(S, TemplateParams, NTTP,
-                                             VectorArg->getSizeExpr(),
-                                             Info, Deduced);
+                                             VA->getSizeExpr(), Info, Deduced);
       }
 
       return Sema::TDK_NonDeducedMismatch;
     }
 
     //     (clang extension)
     //
     //     T __attribute__((matrix_type(<integral constant>,
     //                                  <integral constant>)))
     case Type::ConstantMatrix: {
-      const ConstantMatrixType *MatrixArg = dyn_cast<ConstantMatrixType>(Arg);
-      if (!MatrixArg)
+      const auto *MP = P->castAs<ConstantMatrixType>(),
+                 *MA = A->getAs<ConstantMatrixType>();
+      if (!MA)
         return Sema::TDK_NonDeducedMismatch;
 
-      const ConstantMatrixType *MatrixParam = cast<ConstantMatrixType>(Param);
       // Check that the dimensions are the same
-      if (MatrixParam->getNumRows() != MatrixArg->getNumRows() ||
-          MatrixParam->getNumColumns() != MatrixArg->getNumColumns()) {
+      if (MP->getNumRows() != MA->getNumRows() ||
+          MP->getNumColumns() != MA->getNumColumns()) {
         return Sema::TDK_NonDeducedMismatch;
       }
       // Perform deduction on element types.
       return DeduceTemplateArgumentsByTypeMatch(
-          S, TemplateParams, MatrixParam->getElementType(),
-          MatrixArg->getElementType(), Info, Deduced, TDF);
+          S, TemplateParams, MP->getElementType(), MA->getElementType(), Info,
+          Deduced, TDF);
     }
 
     case Type::DependentSizedMatrix: {
-      const MatrixType *MatrixArg = dyn_cast<MatrixType>(Arg);
-      if (!MatrixArg)
+      const auto *MP = P->castAs<DependentSizedMatrixType>();
+      const auto *MA = A->getAs<MatrixType>();
+      if (!MA)
         return Sema::TDK_NonDeducedMismatch;
 
       // Check the element type of the matrixes.
-      const DependentSizedMatrixType *MatrixParam =
-          cast<DependentSizedMatrixType>(Param);
-      if (Sema::TemplateDeductionResult Result =
-              DeduceTemplateArgumentsByTypeMatch(
-                  S, TemplateParams, MatrixParam->getElementType(),
-                  MatrixArg->getElementType(), Info, Deduced, TDF))
+      if (auto Result = DeduceTemplateArgumentsByTypeMatch(
+              S, TemplateParams, MP->getElementType(), MA->getElementType(),
+              Info, Deduced, TDF))
         return Result;
 
       // Try to deduce a matrix dimension.
       auto DeduceMatrixArg =
           [&S, &Info, &Deduced, &TemplateParams](
-              Expr *ParamExpr, const MatrixType *Arg,
+              Expr *ParamExpr, const MatrixType *A,
               unsigned (ConstantMatrixType::*GetArgDimension)() const,
               Expr *(DependentSizedMatrixType::*GetArgDimensionExpr)() const) {
-            const auto *ArgConstMatrix = dyn_cast<ConstantMatrixType>(Arg);
-            const auto *ArgDepMatrix = dyn_cast<DependentSizedMatrixType>(Arg);
+            const auto *ACM = dyn_cast<ConstantMatrixType>(A);
+            const auto *ADM = dyn_cast<DependentSizedMatrixType>(A);
             if (!ParamExpr->isValueDependent()) {
               Optional<llvm::APSInt> ParamConst =
                   ParamExpr->getIntegerConstantExpr(S.Context);
               if (!ParamConst)
                 return Sema::TDK_NonDeducedMismatch;
 
-              if (ArgConstMatrix) {
-                if ((ArgConstMatrix->*GetArgDimension)() == *ParamConst)
+              if (ACM) {
+                if ((ACM->*GetArgDimension)() == *ParamConst)
                   return Sema::TDK_Success;
                 return Sema::TDK_NonDeducedMismatch;
               }
 
-              Expr *ArgExpr = (ArgDepMatrix->*GetArgDimensionExpr)();
+              Expr *ArgExpr = (ADM->*GetArgDimensionExpr)();
               if (Optional<llvm::APSInt> ArgConst =
                       ArgExpr->getIntegerConstantExpr(S.Context))
                 if (*ArgConst == *ParamConst)
                   return Sema::TDK_Success;
               return Sema::TDK_NonDeducedMismatch;
             }
 
             const NonTypeTemplateParmDecl *NTTP =
                 getDeducedParameterFromExpr(Info, ParamExpr);
             if (!NTTP)
               return Sema::TDK_Success;
 
-            if (ArgConstMatrix) {
+            if (ACM) {
               llvm::APSInt ArgConst(
                   S.Context.getTypeSize(S.Context.getSizeType()));
-              ArgConst = (ArgConstMatrix->*GetArgDimension)();
+              ArgConst = (ACM->*GetArgDimension)();
               return DeduceNonTypeTemplateArgument(
                   S, TemplateParams, NTTP, ArgConst, S.Context.getSizeType(),
                   /*ArrayBound=*/true, Info, Deduced);
             }
 
-            return DeduceNonTypeTemplateArgument(
-                S, TemplateParams, NTTP, (ArgDepMatrix->*GetArgDimensionExpr)(),
+            return DeduceNonTypeTemplateArgument(S, TemplateParams, NTTP,
+                                                 (ADM->*GetArgDimensionExpr)(),
                                                  Info, Deduced);
           };
 
-      auto Result = DeduceMatrixArg(MatrixParam->getRowExpr(), MatrixArg,
+      if (auto Result = DeduceMatrixArg(MP->getRowExpr(), MA,
                                         &ConstantMatrixType::getNumRows,
-                                    &DependentSizedMatrixType::getRowExpr);
-      if (Result)
+                                        &DependentSizedMatrixType::getRowExpr))
         return Result;
 
-      return DeduceMatrixArg(MatrixParam->getColumnExpr(), MatrixArg,
+      return DeduceMatrixArg(MP->getColumnExpr(), MA,
                              &ConstantMatrixType::getNumColumns,
                              &DependentSizedMatrixType::getColumnExpr);
     }
 
     //     (clang extension)
     //
     //     T __attribute__(((address_space(N))))
     case Type::DependentAddressSpace: {
-      const DependentAddressSpaceType *AddressSpaceParam =
-          cast<DependentAddressSpaceType>(Param);
+      const auto *ASP = P->castAs<DependentAddressSpaceType>();
 
-      if (const DependentAddressSpaceType *AddressSpaceArg =
-              dyn_cast<DependentAddressSpaceType>(Arg)) {
+      if (const auto *ASA = A->getAs<DependentAddressSpaceType>()) {
         // Perform deduction on the pointer type.
-        if (Sema::TemplateDeductionResult Result =
-                DeduceTemplateArgumentsByTypeMatch(
-                    S, TemplateParams, AddressSpaceParam->getPointeeType(),
-                    AddressSpaceArg->getPointeeType(), Info, Deduced, TDF))
+        if (auto Result = DeduceTemplateArgumentsByTypeMatch(
+                S, TemplateParams, ASP->getPointeeType(), ASA->getPointeeType(),
+                Info, Deduced, TDF))
           return Result;
 
         // Perform deduction on the address space, if we can.
-        const NonTypeTemplateParmDecl *NTTP = getDeducedParameterFromExpr(
-            Info, AddressSpaceParam->getAddrSpaceExpr());
+        const NonTypeTemplateParmDecl *NTTP =
+            getDeducedParameterFromExpr(Info, ASP->getAddrSpaceExpr());
         if (!NTTP)
           return Sema::TDK_Success;
 
         return DeduceNonTypeTemplateArgument(
-            S, TemplateParams, NTTP, AddressSpaceArg->getAddrSpaceExpr(), Info,
-            Deduced);
+            S, TemplateParams, NTTP, ASA->getAddrSpaceExpr(), Info, Deduced);
       }
 
-      if (isTargetAddressSpace(Arg.getAddressSpace())) {
+      if (isTargetAddressSpace(A.getAddressSpace())) {
         llvm::APSInt ArgAddressSpace(S.Context.getTypeSize(S.Context.IntTy),
                                      false);
-        ArgAddressSpace = toTargetAddressSpace(Arg.getAddressSpace());
+        ArgAddressSpace = toTargetAddressSpace(A.getAddressSpace());
 
         // Perform deduction on the pointer types.
-        if (Sema::TemplateDeductionResult Result =
-                DeduceTemplateArgumentsByTypeMatch(
-                    S, TemplateParams, AddressSpaceParam->getPointeeType(),
-                    S.Context.removeAddrSpaceQualType(Arg), Info, Deduced, TDF))
+        if (auto Result = DeduceTemplateArgumentsByTypeMatch(
+                S, TemplateParams, ASP->getPointeeType(),
+                S.Context.removeAddrSpaceQualType(A), Info, Deduced, TDF))
           return Result;
 
         // Perform deduction on the address space, if we can.
-        const NonTypeTemplateParmDecl *NTTP = getDeducedParameterFromExpr(
-            Info, AddressSpaceParam->getAddrSpaceExpr());
+        const NonTypeTemplateParmDecl *NTTP =
+            getDeducedParameterFromExpr(Info, ASP->getAddrSpaceExpr());
         if (!NTTP)
           return Sema::TDK_Success;
 
         return DeduceNonTypeTemplateArgument(S, TemplateParams, NTTP,
                                              ArgAddressSpace, S.Context.IntTy,
                                              true, Info, Deduced);
       }
 
       return Sema::TDK_NonDeducedMismatch;
     }
     case Type::DependentExtInt: {
-      const auto *IntParam = cast<DependentExtIntType>(Param);
+      const auto *IP = P->castAs<DependentExtIntType>();
 
-      if (const auto *IntArg = dyn_cast<ExtIntType>(Arg)){
-        if (IntParam->isUnsigned() != IntArg->isUnsigned())
+      if (const auto *IA = A->getAs<ExtIntType>()) {
+        if (IP->isUnsigned() != IA->isUnsigned())
           return Sema::TDK_NonDeducedMismatch;
 
         const NonTypeTemplateParmDecl *NTTP =
-            getDeducedParameterFromExpr(Info, IntParam->getNumBitsExpr());
+            getDeducedParameterFromExpr(Info, IP->getNumBitsExpr());
         if (!NTTP)
           return Sema::TDK_Success;
 
         llvm::APSInt ArgSize(S.Context.getTypeSize(S.Context.IntTy), false);
-        ArgSize = IntArg->getNumBits();
+        ArgSize = IA->getNumBits();
 
         return DeduceNonTypeTemplateArgument(S, TemplateParams, NTTP, ArgSize,
                                              S.Context.IntTy, true, Info,
                                              Deduced);
       }
 
-      if (const auto *IntArg = dyn_cast<DependentExtIntType>(Arg)) {
-        if (IntParam->isUnsigned() != IntArg->isUnsigned())
+      if (const auto *IA = A->getAs<DependentExtIntType>()) {
+        if (IP->isUnsigned() != IA->isUnsigned())
           return Sema::TDK_NonDeducedMismatch;
         return Sema::TDK_Success;
       }
+
       return Sema::TDK_NonDeducedMismatch;
     }
 
     case Type::TypeOfExpr:
     case Type::TypeOf:
     case Type::DependentName:
     case Type::UnresolvedUsing:
     case Type::Decltype:
     case Type::UnaryTransform:
-    case Type::Auto:
     case Type::DeducedTemplateSpecialization:
     case Type::DependentTemplateSpecialization:
     case Type::PackExpansion:
     case Type::Pipe:
       // No template argument deduction for these types
       return Sema::TDK_Success;
     }
 
   llvm_unreachable("Invalid Type Class!");
 }
 
 static Sema::TemplateDeductionResult
-DeduceTemplateArguments(Sema &S,
-                        TemplateParameterList *TemplateParams,
-                        const TemplateArgument &Param,
-                        TemplateArgument Arg,
+DeduceTemplateArguments(Sema &S, TemplateParameterList *TemplateParams,
+                        const TemplateArgument &P, TemplateArgument A,
                         TemplateDeductionInfo &Info,
                         SmallVectorImpl<DeducedTemplateArgument> &Deduced) {
   // If the template argument is a pack expansion, perform template argument
   // deduction against the pattern of that expansion. This only occurs during
   // partial ordering.
-  if (Arg.isPackExpansion())
-    Arg = Arg.getPackExpansionPattern();
+  if (A.isPackExpansion())
+    A = A.getPackExpansionPattern();
 
-  switch (Param.getKind()) {
+  switch (P.getKind()) {
   case TemplateArgument::Null:
     llvm_unreachable("Null template argument in parameter list");
 
   case TemplateArgument::Type:
-    if (Arg.getKind() == TemplateArgument::Type)
-      return DeduceTemplateArgumentsByTypeMatch(S, TemplateParams,
-                                                Param.getAsType(),
-                                                Arg.getAsType(),
-                                                Info, Deduced, 0);
-    Info.FirstArg = Param;
-    Info.SecondArg = Arg;
+    if (A.getKind() == TemplateArgument::Type)
+      return DeduceTemplateArgumentsByTypeMatch(
+          S, TemplateParams, P.getAsType(), A.getAsType(), Info, Deduced, 0);
+    Info.FirstArg = P;
+    Info.SecondArg = A;
     return Sema::TDK_NonDeducedMismatch;
 
   case TemplateArgument::Template:
-    if (Arg.getKind() == TemplateArgument::Template)
-      return DeduceTemplateArguments(S, TemplateParams,
-                                     Param.getAsTemplate(),
-                                     Arg.getAsTemplate(), Info, Deduced);
-    Info.FirstArg = Param;
-    Info.SecondArg = Arg;
+    if (A.getKind() == TemplateArgument::Template)
+      return DeduceTemplateArguments(S, TemplateParams, P.getAsTemplate(),
+                                     A.getAsTemplate(), Info, Deduced);
+    Info.FirstArg = P;
+    Info.SecondArg = A;
     return Sema::TDK_NonDeducedMismatch;
 
   case TemplateArgument::TemplateExpansion:
     llvm_unreachable("caller should handle pack expansions");
 
   case TemplateArgument::Declaration:
-    if (Arg.getKind() == TemplateArgument::Declaration &&
-        isSameDeclaration(Param.getAsDecl(), Arg.getAsDecl()))
+    if (A.getKind() == TemplateArgument::Declaration &&
+        isSameDeclaration(P.getAsDecl(), A.getAsDecl()))
       return Sema::TDK_Success;
 
-    Info.FirstArg = Param;
-    Info.SecondArg = Arg;
+    Info.FirstArg = P;
+    Info.SecondArg = A;
     return Sema::TDK_NonDeducedMismatch;
 
   case TemplateArgument::NullPtr:
-    if (Arg.getKind() == TemplateArgument::NullPtr &&
-        S.Context.hasSameType(Param.getNullPtrType(), Arg.getNullPtrType()))
+    if (A.getKind() == TemplateArgument::NullPtr &&
+        S.Context.hasSameType(P.getNullPtrType(), A.getNullPtrType()))
       return Sema::TDK_Success;
 
-    Info.FirstArg = Param;
-    Info.SecondArg = Arg;
+    Info.FirstArg = P;
+    Info.SecondArg = A;
     return Sema::TDK_NonDeducedMismatch;
 
   case TemplateArgument::Integral:
-    if (Arg.getKind() == TemplateArgument::Integral) {
-      if (hasSameExtendedValue(Param.getAsIntegral(), Arg.getAsIntegral()))
+    if (A.getKind() == TemplateArgument::Integral) {
+      if (hasSameExtendedValue(P.getAsIntegral(), A.getAsIntegral()))
         return Sema::TDK_Success;
-
-      Info.FirstArg = Param;
-      Info.SecondArg = Arg;
-      return Sema::TDK_NonDeducedMismatch;
     }
-
-    if (Arg.getKind() == TemplateArgument::Expression) {
-      Info.FirstArg = Param;
-      Info.SecondArg = Arg;
-      return Sema::TDK_NonDeducedMismatch;
-    }
-
-    Info.FirstArg = Param;
-    Info.SecondArg = Arg;
+    Info.FirstArg = P;
+    Info.SecondArg = A;
     return Sema::TDK_NonDeducedMismatch;
 
   case TemplateArgument::Expression:
     if (const NonTypeTemplateParmDecl *NTTP =
-            getDeducedParameterFromExpr(Info, Param.getAsExpr())) {
-      if (Arg.getKind() == TemplateArgument::Integral)
-        return DeduceNonTypeTemplateArgument(S, TemplateParams, NTTP,
-                                             Arg.getAsIntegral(),
-                                             Arg.getIntegralType(),
-                                             /*ArrayBound=*/false,
-                                             Info, Deduced);
-      if (Arg.getKind() == TemplateArgument::NullPtr)
+            getDeducedParameterFromExpr(Info, P.getAsExpr())) {
+      if (A.getKind() == TemplateArgument::Integral)
+        return DeduceNonTypeTemplateArgument(
+            S, TemplateParams, NTTP, A.getAsIntegral(), A.getIntegralType(),
+            /*ArrayBound=*/false, Info, Deduced);
+      if (A.getKind() == TemplateArgument::NullPtr)
         return DeduceNullPtrTemplateArgument(S, TemplateParams, NTTP,
-                                             Arg.getNullPtrType(),
-                                             Info, Deduced);
-      if (Arg.getKind() == TemplateArgument::Expression)
+                                             A.getNullPtrType(), Info, Deduced);
+      if (A.getKind() == TemplateArgument::Expression)
         return DeduceNonTypeTemplateArgument(S, TemplateParams, NTTP,
-                                             Arg.getAsExpr(), Info, Deduced);
-      if (Arg.getKind() == TemplateArgument::Declaration)
-        return DeduceNonTypeTemplateArgument(S, TemplateParams, NTTP,
-                                             Arg.getAsDecl(),
-                                             Arg.getParamTypeForDecl(),
-                                             Info, Deduced);
+                                             A.getAsExpr(), Info, Deduced);
+      if (A.getKind() == TemplateArgument::Declaration)
+        return DeduceNonTypeTemplateArgument(
+            S, TemplateParams, NTTP, A.getAsDecl(), A.getParamTypeForDecl(),
 
-      Info.FirstArg = Param;
-      Info.SecondArg = Arg;
+      Info.FirstArg = P;
+      Info.SecondArg = A;
       return Sema::TDK_NonDeducedMismatch;
     }
 
     // Can't deduce anything, but that's okay.
     return Sema::TDK_Success;
-
   case TemplateArgument::Pack:
     llvm_unreachable("Argument packs should be expanded by the caller!");
   }
 
   llvm_unreachable("Invalid TemplateArgument Kind!");
 }
 
 /// Determine whether there is a template argument to be used for
if (A.isPackExpansion())
       FoundPackExpansion = true;
   }
 
   return false;
 }
 
 static Sema::TemplateDeductionResult
 DeduceTemplateArguments(Sema &S, TemplateParameterList *TemplateParams,
-                        ArrayRef<TemplateArgument> Params,
-                        ArrayRef<TemplateArgument> Args,
+                        ArrayRef<TemplateArgument> Ps,
+                        ArrayRef<TemplateArgument> As,
                         TemplateDeductionInfo &Info,
                         SmallVectorImpl<DeducedTemplateArgument> &Deduced,
                         bool NumberOfArgumentsMustMatch) {
   // C++0x [temp.deduct.type]p9:
   //   If the template argument list of P contains a pack expansion that is not
   //   the last template argument, the entire template argument list is a
   //   non-deduced context.
-  if (hasPackExpansionBeforeEnd(Params))
+  if (hasPackExpansionBeforeEnd(Ps))
     return Sema::TDK_Success;
 
   // C++0x [temp.deduct.type]p9:
   //   If P has a form that contains <T> or <i>, then each argument Pi of the
   //   respective template argument list P is compared with the corresponding
   //   argument Ai of the corresponding template argument list of A.
   unsigned ArgIdx = 0, ParamIdx = 0;
-  for (; hasTemplateArgumentForDeduction(Params, ParamIdx); ++ParamIdx) {
-    if (!Params[ParamIdx].isPackExpansion()) {
+  for (; hasTemplateArgumentForDeduction(Ps, ParamIdx); ++ParamIdx) {
+    const TemplateArgument &P = Ps[ParamIdx];
+    if (!P.isPackExpansion()) {
       // The simple case: deduce template arguments by matching Pi and Ai.
 
       // Check whether we have enough arguments.
-      if (!hasTemplateArgumentForDeduction(Args, ArgIdx))
+      if (!hasTemplateArgumentForDeduction(As, ArgIdx))
         return NumberOfArgumentsMustMatch
                    ? Sema::TDK_MiscellaneousDeductionFailure
                    : Sema::TDK_Success;
 
       // C++1z [temp.deduct.type]p9:
       //   During partial ordering, if Ai was originally a pack expansion [and]
       //   Pi is not a pack expansion, template argument deduction fails.
-      if (Args[ArgIdx].isPackExpansion())
+      if (As[ArgIdx].isPackExpansion())
         return Sema::TDK_MiscellaneousDeductionFailure;
 
       // Perform deduction for this Pi/Ai pair.
-      if (Sema::TemplateDeductionResult Result
-            = DeduceTemplateArguments(S, TemplateParams,
-                                      Params[ParamIdx], Args[ArgIdx],
-                                      Info, Deduced))
+      if (auto Result = DeduceTemplateArguments(S, TemplateParams, P,
+                                                As[ArgIdx], Info, Deduced))
         return Result;
 
       // Move to the next argument.
       ++ArgIdx;
       continue;
     }
 
     // The parameter is a pack expansion.
 
     // C++0x [temp.deduct.type]p9:
     //   If Pi is a pack expansion, then the pattern of Pi is compared with
     //   each remaining argument in the template argument list of A. Each
     //   comparison deduces template arguments for subsequent positions in the
     //   template parameter packs expanded by Pi.
-    TemplateArgument Pattern = Params[ParamIdx].getPackExpansionPattern();
+    TemplateArgument Pattern = P.getPackExpansionPattern();
 
     // Prepare to deduce the packs within the pattern.
     PackDeductionScope PackScope(S, TemplateParams, Deduced, Info, Pattern);
 
     // Keep track of the deduced template arguments for each parameter pack
     // expanded by this pack expansion (the outer index) and for each
     // template argument (the inner SmallVectors).
-    for (; hasTemplateArgumentForDeduction(Args, ArgIdx) &&
+    for (; hasTemplateArgumentForDeduction(As, ArgIdx) &&
            PackScope.hasNextElement();
          ++ArgIdx) {
       // Deduce template arguments from the pattern.
-      if (Sema::TemplateDeductionResult Result
-            = DeduceTemplateArguments(S, TemplateParams, Pattern, Args[ArgIdx],
-                                      Info, Deduced))
+      if (auto Result = DeduceTemplateArguments(S, TemplateParams, Pattern,
+                                                As[ArgIdx], Info, Deduced))
         return Result;
 
       PackScope.nextPackElement();
     }
 
     // Build argument packs for each of the parameter packs expanded by this
     // pack expansion.
     if (auto Result = PackScope.finish())
       return Result;
   }
 
   return Sema::TDK_Success;
 }
 
 static Sema::TemplateDeductionResult
-DeduceTemplateArguments(Sema &S,
-                        TemplateParameterList *TemplateParams,
+DeduceTemplateArguments(Sema &S, TemplateParameterList *TemplateParams,
                         const TemplateArgumentList &ParamList,
                         const TemplateArgumentList &ArgList,
                         TemplateDeductionInfo &Info,
                         SmallVectorImpl<DeducedTemplateArgument> &Deduced) {
   return DeduceTemplateArguments(S, TemplateParams, ParamList.asArray(),
                                  ArgList.asArray(), Info, Deduced,
-                                 /*NumberOfArgumentsMustMatch*/false);
+                                 /*NumberOfArgumentsMustMatch=*/false);
 }
 
 /// Determine whether two template arguments are the same.
 static bool isSameTemplateArg(ASTContext &Context,
                               TemplateArgument X,
                               const TemplateArgument &Y,
                               bool PackExpansionMatchesPack = false) {
   // If we're checking deduced arguments (X) against original arguments (Y),
Sema::TemplateDeductionResult Sema::DeduceTemplateArguments(
 
   // If the function has a deduced return type, substitute it for a dependent
   // type so that we treat it as a non-deduced context in what follows. If we
   // are looking up by signature, the signature type should also have a deduced
   // return type, which we instead expect to exactly match.
   bool HasDeducedReturnType = false;
   if (getLangOpts().CPlusPlus14 && IsAddressOfFunction &&
       Function->getReturnType()->getContainedAutoType()) {
-    FunctionType = SubstAutoType(FunctionType, Context.DependentTy);
+    FunctionType = SubstAutoTypeDependent(FunctionType);
     HasDeducedReturnType = true;
   }
 
   if (!ArgFunctionType.isNull() && !FunctionType.isNull()) {
     unsigned TDF =
         TDF_TopLevelParameterTypeList | TDF_AllowCompatibleFunctionType;
     // Deduce template arguments from the function type.
     if (TemplateDeductionResult Result
if (AT->isDecltypeAuto()) {
       if (isa<InitListExpr>(Init)) {
         Diag(Init->getBeginLoc(), diag::err_decltype_auto_initializer_list);
         return DAR_FailedAlreadyDiagnosed;
       }
 
       ExprResult ER = CheckPlaceholderExpr(Init);
       if (ER.isInvalid())
         return DAR_FailedAlreadyDiagnosed;
-      Init = ER.get();
-      QualType Deduced = BuildDecltypeType(Init, Init->getBeginLoc(), false);
-      if (Deduced.isNull())
-        return DAR_FailedAlreadyDiagnosed;
-      // FIXME: Support a non-canonical deduced type for 'auto'.
-      Deduced = Context.getCanonicalType(Deduced);
+      QualType Deduced = getDecltypeForExpr(ER.get());
+      assert(!Deduced.isNull());
       if (AT->isConstrained() && !IgnoreConstraints) {
         auto ConstraintsResult =
             CheckDeducedPlaceholderConstraints(*this, *AT,
                                                Type.getContainedAutoTypeLoc(),
                                                Deduced);
         if (ConstraintsResult != DAR_Succeeded)
           return ConstraintsResult;
       }
TemplateTypeParmDecl *TemplParam = TemplateTypeParmDecl::Create(
       Context, nullptr, SourceLocation(), Loc, Depth, 0, nullptr, false, false,
       false);
   QualType TemplArg = QualType(TemplParam->getTypeForDecl(), 0);
   NamedDecl *TemplParamPtr = TemplParam;
   FixedSizeTemplateParameterListStorage<1, false> TemplateParamsSt(
       Context, Loc, Loc, TemplParamPtr, Loc, nullptr);
 
   QualType FuncParam =
-      SubstituteDeducedTypeTransform(*this, TemplArg, /*UseTypeSugar*/false)
+      SubstituteDeducedTypeTransform(*this, TemplArg, /*UseTypeSugar*/ true)
           .Apply(Type);
   assert(!FuncParam.isNull() &&
          "substituting template parameter for 'auto' failed");
 
   // Deduce type of TemplParam in Func(Init)
   SmallVector<DeducedTemplateArgument, 1> Deduced;
   Deduced.resize(1);
 
for (const OriginalCallArg &OriginalArg : OriginalCallArgs) {
     }
   }
 
   return DAR_Succeeded;
 }
 
 QualType Sema::SubstAutoType(QualType TypeWithAuto,
                              QualType TypeToReplaceAuto) {
-  if (TypeToReplaceAuto->isDependentType())
-    return SubstituteDeducedTypeTransform(
-               *this, DependentAuto{
-                          TypeToReplaceAuto->containsUnexpandedParameterPack()})
-        .TransformType(TypeWithAuto);
+  assert(TypeToReplaceAuto != Context.DependentTy);
   return SubstituteDeducedTypeTransform(*this, TypeToReplaceAuto)
       .TransformType(TypeWithAuto);
 }
 
 TypeSourceInfo *Sema::SubstAutoTypeSourceInfo(TypeSourceInfo *TypeWithAuto,
                                               QualType TypeToReplaceAuto) {
-  if (TypeToReplaceAuto->isDependentType())
-    return SubstituteDeducedTypeTransform(
-               *this,
-               DependentAuto{
-                   TypeToReplaceAuto->containsUnexpandedParameterPack()})
-        .TransformType(TypeWithAuto);
+  assert(TypeToReplaceAuto != Context.DependentTy);
   return SubstituteDeducedTypeTransform(*this, TypeToReplaceAuto)
       .TransformType(TypeWithAuto);
 }
 
+QualType Sema::SubstAutoTypeDependent(QualType TypeWithAuto) {
+  return SubstituteDeducedTypeTransform(*this, DependentAuto{false})
+      .TransformType(TypeWithAuto);
+}
+
+TypeSourceInfo *
+Sema::SubstAutoTypeSourceInfoDependent(TypeSourceInfo *TypeWithAuto) {
+  return SubstituteDeducedTypeTransform(*this, DependentAuto{false})
+      .TransformType(TypeWithAuto);
+}
+
 QualType Sema::ReplaceAutoType(QualType TypeWithAuto,
                                QualType TypeToReplaceAuto) {
   return SubstituteDeducedTypeTransform(*this, TypeToReplaceAuto,
                                         /*UseTypeSugar*/ false)
       .TransformType(TypeWithAuto);
 }
 
 TypeSourceInfo *Sema::ReplaceAutoTypeSourceInfo(TypeSourceInfo *TypeWithAuto,
case TPOC_Call: {
     //   The presence of unused ellipsis and default arguments has no effect on
     //   the partial ordering of function templates.
     if (Args1.size() > NumComparedArguments)
       Args1.resize(NumComparedArguments);
     if (Args2.size() > NumComparedArguments)
       Args2.resize(NumComparedArguments);
     if (Reversed)
       std::reverse(Args2.begin(), Args2.end());
+
     if (DeduceTemplateArguments(S, TemplateParams, Args2.data(), Args2.size(),
                                 Args1.data(), Args1.size(), Info, Deduced,
                                 TDF_None, /*PartialOrdering=*/true))
       return false;
 
     break;
   }
 

clang/lib/Sema/SemaType.cpp

if (!Result->isDependentType())
         S.DiagnoseUseOfDecl(TT->getDecl(), DS.getTypeSpecTypeLoc());
     // TypeQuals handled by caller.
     Result = Context.getTypeOfType(Result);
     break;
   case DeclSpec::TST_typeofExpr: {
     Expr *E = DS.getRepAsExpr();
     assert(E && "Didn't get an expression for typeof?");
     // TypeQuals handled by caller.
-    Result = S.BuildTypeofExprType(E, DS.getTypeSpecTypeLoc());
+    Result = S.BuildTypeofExprType(E);
     if (Result.isNull()) {
       Result = Context.IntTy;
       declarator.setInvalidType(true);
     }
     break;
   }
   case DeclSpec::TST_decltype: {
     Expr *E = DS.getRepAsExpr();
     assert(E && "Didn't get an expression for decltype?");
     // TypeQuals handled by caller.
-    Result = S.BuildDecltypeType(E, DS.getTypeSpecTypeLoc());
+    Result = S.BuildDecltypeType(E);
     if (Result.isNull()) {
       Result = Context.IntTy;
       declarator.setInvalidType(true);
     }
     break;
   }
   case DeclSpec::TST_underlyingType:
     Result = S.GetTypeFromParser(DS.getRepAsType());
QualType Sema::getElaboratedType(ElaboratedTypeKeyword Keyword,
   else {
     if (Keyword == ETK_None)
       return T;
     NNS = nullptr;
   }
   return Context.getElaboratedType(Keyword, NNS, T, OwnedTagDecl);
 }
 
-QualType Sema::BuildTypeofExprType(Expr *E, SourceLocation Loc) {
+QualType Sema::BuildTypeofExprType(Expr *E) {
   assert(!E->hasPlaceholderType() && "unexpected placeholder");
 
   if (!getLangOpts().CPlusPlus && E->refersToBitField())
     Diag(E->getExprLoc(), diag::err_sizeof_alignof_typeof_bitfield) << 2;
 
   if (!E->isTypeDependent()) {
     QualType T = E->getType();
     if (const TagType *TT = T->getAs<TagType>())
       DiagnoseUseOfDecl(TT->getDecl(), E->getExprLoc());
   }
   return Context.getTypeOfExprType(E);
 }
 
 /// getDecltypeForExpr - Given an expr, will return the decltype for
 /// that expression, according to the rules in C++11
 /// [dcl.type.simple]p4 and C++11 [expr.lambda.prim]p18.
-static QualType getDecltypeForExpr(Sema &S, Expr *E) {
+QualType Sema::getDecltypeForExpr(Expr *E) {
   if (E->isTypeDependent())
-    return S.Context.DependentTy;
+    return Context.DependentTy;
 
   Expr *IDExpr = E;
   if (auto *ImplCastExpr = dyn_cast<ImplicitCastExpr>(E))
     IDExpr = ImplCastExpr->getSubExpr();
 
   // C++11 [dcl.type.simple]p4:
   //   The type denoted by decltype(e) is defined as follows:
 
   // C++20:
   //     - if E is an unparenthesized id-expression naming a non-type
   //       template-parameter (13.2), decltype(E) is the type of the
   //       template-parameter after performing any necessary type deduction
   // Note that this does not pick up the implicit 'const' for a template
   // parameter object. This rule makes no difference before C++20 so we apply
   // it unconditionally.
   if (const auto *SNTTPE = dyn_cast<SubstNonTypeTemplateParmExpr>(IDExpr))
-    return SNTTPE->getParameterType(S.Context);
+    return SNTTPE->getParameterType(Context);
 
   //     - if e is an unparenthesized id-expression or an unparenthesized class
   //       member access (5.2.5), decltype(e) is the type of the entity named
   //       by e. If there is no such entity, or if e names a set of overloaded
   //       functions, the program is ill-formed;
   //
   // We apply the same rules for Objective-C ivar and property references.
-  if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(IDExpr)) {
+  if (const auto *DRE = dyn_cast<DeclRefExpr>(IDExpr)) {
     const ValueDecl *VD = DRE->getDecl();
-    if (auto *TPO = dyn_cast<TemplateParamObjectDecl>(VD))
-      return TPO->getType().getUnqualifiedType();
-    return VD->getType();
-  } else if (const MemberExpr *ME = dyn_cast<MemberExpr>(IDExpr)) {
-    if (const ValueDecl *VD = ME->getMemberDecl())
+    QualType T = VD->getType();
+    return isa<TemplateParamObjectDecl>(VD) ? T.getUnqualifiedType() : T;
+  }
+  if (const auto *ME = dyn_cast<MemberExpr>(IDExpr)) {
+    if (const auto *VD = ME->getMemberDecl())
       if (isa<FieldDecl>(VD) || isa<VarDecl>(VD))
         return VD->getType();
-  } else if (const ObjCIvarRefExpr *IR = dyn_cast<ObjCIvarRefExpr>(IDExpr)) {
+  } else if (const auto *IR = dyn_cast<ObjCIvarRefExpr>(IDExpr)) {
     return IR->getDecl()->getType();
-  } else if (const ObjCPropertyRefExpr *PR =
-                 dyn_cast<ObjCPropertyRefExpr>(IDExpr)) {
+  } else if (const auto *PR = dyn_cast<ObjCPropertyRefExpr>(IDExpr)) {
     if (PR->isExplicitProperty())
       return PR->getExplicitProperty()->getType();
-  } else if (auto *PE = dyn_cast<PredefinedExpr>(IDExpr)) {
+  } else if (const auto *PE = dyn_cast<PredefinedExpr>(IDExpr)) {
     return PE->getType();
   }
 
   // C++11 [expr.lambda.prim]p18:
   //   Every occurrence of decltype((x)) where x is a possibly
   //   parenthesized id-expression that names an entity of automatic
   //   storage duration is treated as if x were transformed into an
   //   access to a corresponding data member of the closure type that
   //   would have been declared if x were an odr-use of the denoted
   //   entity.
-  using namespace sema;
-  if (S.getCurLambda()) {
-    if (isa<ParenExpr>(IDExpr)) {
-      if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(IDExpr->IgnoreParens())) {
-        if (VarDecl *Var = dyn_cast<VarDecl>(DRE->getDecl())) {
-          QualType T = S.getCapturedDeclRefType(Var, DRE->getLocation());
-          if (!T.isNull())
-            return S.Context.getLValueReferenceType(T);
-        }
+  if (getCurLambda() && isa<ParenExpr>(IDExpr)) {
+    if (auto *DRE = dyn_cast<DeclRefExpr>(IDExpr->IgnoreParens())) {
+      if (auto *Var = dyn_cast<VarDecl>(DRE->getDecl())) {
+        QualType T = getCapturedDeclRefType(Var, DRE->getLocation());
+          return Context.getLValueReferenceType(T);
       }
     }
   }
 
-  return S.Context.getReferenceQualifiedType(E);
+  return Context.getReferenceQualifiedType(E);
 }
 
-QualType Sema::BuildDecltypeType(Expr *E, SourceLocation Loc,
-                                 bool AsUnevaluated) {
+QualType Sema::BuildDecltypeType(Expr *E, bool AsUnevaluated) {
   assert(!E->hasPlaceholderType() && "unexpected placeholder");
 
   if (AsUnevaluated && CodeSynthesisContexts.empty() &&
       !E->isInstantiationDependent() && E->HasSideEffects(Context, false)) {
     // The expression operand for decltype is in an unevaluated expression
     // 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(*this, E));
+  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()) {

clang/lib/Sema/TreeTransform.h

if (T->isConstrained()) {
     }
   }
 
   QualType Result = TL.getType();
   if (getDerived().AlwaysRebuild() || NewDeduced != OldDeduced ||
       T->isDependentType() || T->isConstrained()) {
     // FIXME: Maybe don't rebuild if all template arguments are the same.
     llvm::SmallVector<TemplateArgument, 4> NewArgList;
-    NewArgList.reserve(NewArgList.size());
+    NewArgList.reserve(NewTemplateArgs.size());
     for (const auto &ArgLoc : NewTemplateArgs.arguments())
       NewArgList.push_back(ArgLoc.getArgument());
     Result = getDerived().RebuildAutoType(NewDeduced, T->getKeyword(), NewCD,
                                           NewArgList);
     if (Result.isNull())
       return QualType();
   }
 
if (auto *UPD = dyn_cast<UsingPackDecl>(D)) {
     assert(isa<UnresolvedUsingTypenameDecl>(D) &&
            "UnresolvedUsingTypenameDecl transformed to non-using decl");
     Ty = cast<UnresolvedUsingTypenameDecl>(D);
   }
 
   return SemaRef.Context.getTypeDeclType(Ty);
 }
 
-template<typename Derived>
+template <typename Derived>
 QualType TreeTransform<Derived>::RebuildTypeOfExprType(Expr *E,
-                                                       SourceLocation Loc) {
-  return SemaRef.BuildTypeofExprType(E, Loc);
+                                                       SourceLocation) {
+  return SemaRef.BuildTypeofExprType(E);
 }
 
 template<typename Derived>
 QualType TreeTransform<Derived>::RebuildTypeOfType(QualType Underlying) {
   return SemaRef.Context.getTypeOfType(Underlying);
 }
 
-template<typename Derived>
-QualType TreeTransform<Derived>::RebuildDecltypeType(Expr *E,
-                                                     SourceLocation Loc) {
-  return SemaRef.BuildDecltypeType(E, Loc);
+template <typename Derived>
+QualType TreeTransform<Derived>::RebuildDecltypeType(Expr *E, SourceLocation) {
+  return SemaRef.BuildDecltypeType(E);
 }
 
 template<typename Derived>
 QualType TreeTransform<Derived>::RebuildUnaryTransformType(QualType BaseType,
                                             UnaryTransformType::UTTKind UKind,
                                             SourceLocation Loc) {
   return SemaRef.BuildUnaryTransformType(BaseType, UKind, Loc);
 }

clang/test/CXX/over/over.match/over.match.funcs/over.match.class.deduct/p2.cpp

template<typename T> struct initializer_list {
     const T *ptr;
     __SIZE_TYPE__ size;
     initializer_list();
   };
 }
 
 namespace p0702r1 {
   template<typename T> struct X { // expected-note {{candidate}}
-    X(std::initializer_list<T>); // expected-note {{candidate template ignored: could not match 'initializer_list<type-parameter-0-0>' against 'p0702r1::Z'}}
+    X(std::initializer_list<T>); // expected-note {{candidate template ignored: could not match 'std::initializer_list<T>' against 'p0702r1::Z'}}
   };
 
   X xi = {0};
   X xxi = {xi};
   extern X<int> xi;
   // Prior to P0702R1, this is X<X<int>>.
   extern X<int> xxi;
 

clang/test/CXX/stmt.stmt/stmt.iter/stmt.ranged/p1.cpp

namespace ND {
     struct D {
       void end();
     };
     int *end(D);
   }
 
   namespace NE {
     struct E {
-      void begin(); // expected-note {{member is not a candidate because range type 'p0962r1::NE::E' has no 'end' member}}
+      void begin(); // expected-note {{member is not a candidate because range type 'NE::E' has no 'end' member}}
     };
     int *end(E);
   }
 
   namespace NF {
     struct F {
-      void end(); // expected-note {{member is not a candidate because range type 'p0962r1::NF::F' has no 'begin' member}}
+      void end(); // expected-note {{member is not a candidate because range type 'NF::F' has no 'begin' member}}
     };
     int *begin(F);
   }
 
   void use(NA::A a, NB::B b, NC::C c, ND::D d, NE::E e, NF::F f) {
     for (auto x : a) {}
     for (auto x : b) {}
-    for (auto x : c) {} // expected-error {{invalid range expression of type 'p0962r1::NC::C'; no viable 'end' function available}}
-    for (auto x : d) {} // expected-error {{invalid range expression of type 'p0962r1::ND::D'; no viable 'begin' function available}}
-    for (auto x : e) {} // expected-error {{invalid range expression of type 'p0962r1::NE::E'; no viable 'begin' function available}}
-    for (auto x : f) {} // expected-error {{invalid range expression of type 'p0962r1::NF::F'; no viable 'end' function available}}
+    for (auto x : c) {} // expected-error {{invalid range expression of type 'NC::C'; no viable 'end' function available}}
+    for (auto x : d) {} // expected-error {{invalid range expression of type 'ND::D'; no viable 'begin' function available}}
+    for (auto x : e) {} // expected-error {{invalid range expression of type 'NE::E'; no viable 'begin' function available}}
+    for (auto x : f) {} // expected-error {{invalid range expression of type 'NF::F'; no viable 'end' function available}}
   }
 }

clang/test/CXX/temp/temp.decls/temp.variadic/multi-level-substitution.cpp

namespace PR13386 {
   template<typename...T>
   struct S {
     template<typename...U>
     void f(T &&...t, U &&...u) {} // expected-note {{candidate}}
     template<typename...U>
     void g(U &&...u, T &&...t) {} // expected-note {{candidate}}
     template<typename...U>
     void h(tuple<T, U> &&...) {}
-    // expected-note@-1 {{candidate template ignored: could not match 'tuple<type-parameter-0-0, type-parameter-0-0>' against 'int'}}
+    // expected-note@-1 {{candidate template ignored: could not match 'tuple<T, U>' against 'int'}}
     // expected-note@-2 {{candidate template ignored: substitution failure: deduced incomplete pack <(no value)> for template parameter 'U'}}
 
     template<typename...U>
     struct X {
       template<typename...V>
       void x(tuple<T, U, V> &&...); // expected-error {{different lengths}}
     };
   };

clang/test/CXX/temp/temp.fct.spec/temp.deduct/temp.deduct.call/p1-0x.cpp

 void test_simple_ref_deduction(int *ip, float *fp, double *dp) {
   int *ip1 = first_arg_ref(ip);
   int *ip2 = first_arg_ref(ip, fp);
   int *ip3 = first_arg_ref(ip, fp, dp);
   no_type nt1 = first_arg_ref();
 }
 
 
-// FIXME: Use the template parameter names in this diagnostic.
 template<typename ...Args1, typename ...Args2>
-typename get_nth_type<0, Args1...>::type first_arg_pair(pair<Args1, Args2>...); // expected-note{{candidate template ignored: could not match 'pair<type-parameter-0-0, type-parameter-0-1>' against 'int'}}
+typename get_nth_type<0, Args1...>::type first_arg_pair(pair<Args1, Args2>...); // expected-note{{candidate template ignored: could not match 'pair<Args1, Args2>' against 'int'}}
 
 template<typename ...Args1, typename ...Args2>
 typename get_nth_type<1, Args1...>::type second_arg_pair(pair<Args1, Args2>...);
 
 void test_pair_deduction(int *ip, float *fp, double *dp) {
   int *ip1 = first_arg_pair(make_pair(ip, 17));
   int *ip2 = first_arg_pair(make_pair(ip, 17), make_pair(fp, 17));
   int *ip3 = first_arg_pair(make_pair(ip, 17), make_pair(fp, 17), 

clang/test/CXX/temp/temp.fct.spec/temp.deduct/temp.deduct.call/p4.cpp

 }
 
 namespace PR12132 {
   template<typename S> void fun(const int* const S::* member) {}
   struct A { int* x; };
   void foo() {
     fun(&A::x);
   }
+  struct B { char* x; };
+  void bar() {
+    fun(&B::x);
+    // expected-error@-1 {{no matching function for call to 'fun'}}
+    // expected-note@-9  {{candidate template ignored: could not match 'const int' against 'char'}}
+  }
 }
 
 #if __cplusplus > 201402L
 namespace noexcept_conversion {
   template<typename R> void foo(R());
   template<typename R> void bar(R()) = delete;
   template<typename R> void bar(R() noexcept) {}
   void f() throw() {
namespace noexcept_conversion {
   int x = h(g1, g2); // expected-error {{no matching function}}
 
   // We consider it a defect that deduction does not support the following.
   // FIXME: Check that the defect is resolved as we expect.
   template<bool B> int i(void () noexcept(B));
   int i1 = i(g1);
   int i2 = i(g2);
 }
-#else
-// expected-no-diagnostics
 #endif

clang/test/Index/print-type.cpp

 // CHECK: StructDecl=Specialization:69:8 [Specialization of Specialization:66:8] [type=Specialization<int>] [typekind=Record] [templateargs/1= [type=int] [typekind=Int]] [isPOD=0]
 // CHECK: VarDecl=templRefParam:71:40 (Definition) [type=Specialization<Specialization<bool> &>] [typekind=Unexposed] [templateargs/1= [type=Specialization<bool> &] [typekind=LValueReference]] [canonicaltype=Specialization<Specialization<bool> &>] [canonicaltypekind=Record] [canonicaltemplateargs/1= [type=Specialization<bool> &] [typekind=LValueReference]] [isPOD=1]
 // CHECK: TemplateRef=Specialization:66:8 [type=] [typekind=Invalid] [isPOD=0]
 // CHECK: CallExpr=Specialization:66:8 [type=Specialization<Specialization<bool> &>] [typekind=Unexposed] [templateargs/1= [type=Specialization<bool> &] [typekind=LValueReference]] [canonicaltype=Specialization<Specialization<bool> &>] [canonicaltypekind=Record] [canonicaltemplateargs/1= [type=Specialization<bool> &] [typekind=LValueReference]] [isPOD=1]
 // CHECK: VarDecl=autoTemplRefParam:72:6 (Definition) [type=Specialization<Specialization<bool> &>] [typekind=Auto] [templateargs/1= [type=Specialization<bool> &] [typekind=LValueReference]] [canonicaltype=Specialization<Specialization<bool> &>] [canonicaltypekind=Record] [canonicaltemplateargs/1= [type=Specialization<bool> &] [typekind=LValueReference]] [isPOD=1]
 // CHECK: UnexposedExpr=templRefParam:71:40 [type=const Specialization<Specialization<bool> &>] [typekind=Record] const [templateargs/1= [type=Specialization<bool> &] [typekind=LValueReference]] [isPOD=1]
 // CHECK: DeclRefExpr=templRefParam:71:40 [type=Specialization<Specialization<bool> &>] [typekind=Unexposed] [templateargs/1= [type=Specialization<bool> &] [typekind=LValueReference]] [canonicaltype=Specialization<Specialization<bool> &>] [canonicaltypekind=Record] [canonicaltemplateargs/1= [type=Specialization<bool> &] [typekind=LValueReference]] [isPOD=1]
 // CHECK: TypeAliasDecl=baz:76:7 (Definition) [type=baz] [typekind=Typedef] [templateargs/1= [type=A<void>] [typekind=Unexposed]] [canonicaltype=A<void>] [canonicaltypekind=Record] [canonicaltemplateargs/1= [type=void] [typekind=Void]] [isPOD=0]
-// CHECK: VarDecl=autoTemplPointer:78:6 (Definition) [type=Specialization<Specialization<bool> &> *] [typekind=Auto] [canonicaltype=Specialization<Specialization<bool> &> *] [canonicaltypekind=Pointer] [isPOD=1] [pointeetype=Specialization<Specialization<bool> &>] [pointeekind=Record]
+// CHECK: VarDecl=autoTemplPointer:78:6 (Definition) [type=Specialization<Specialization<bool> &> *] [typekind=Auto] [canonicaltype=Specialization<Specialization<bool> &> *] [canonicaltypekind=Pointer] [isPOD=1] [pointeetype=Specialization<Specialization<bool> &>] [pointeekind=Auto]
 // CHECK: CallExpr=Bar:17:3 [type=outer::inner::Bar] [typekind=Elaborated] [canonicaltype=outer::inner::Bar] [canonicaltypekind=Record] [args= [outer::Foo<bool> *] [Pointer]] [isPOD=0] [nbFields=3]
 // CHECK: StructDecl=:84:3 (Definition) [type=X::(anonymous struct at {{.*}}print-type.cpp:84:3)] [typekind=Record] [isPOD=1] [nbFields=1] [isAnon=1]
 // CHECK: ClassDecl=:85:3 (Definition) [type=X::(anonymous class at {{.*}}print-type.cpp:85:3)] [typekind=Record] [isPOD=1] [nbFields=1] [isAnon=1]
 // CHECK: UnionDecl=:86:3 (Definition) [type=X::(anonymous union at {{.*}}print-type.cpp:86:3)] [typekind=Record] [isPOD=1] [nbFields=2] [isAnon=1]
 // CHECK: EnumDecl=:87:3 (Definition) [type=X::(unnamed enum at {{.*}}print-type.cpp:87:3)] [typekind=Enum] [isPOD=1] [isAnon=1]
 // CHECK: Namespace=:90:11 (Definition) [type=] [typekind=Invalid] [isPOD=0] [isAnon=1]
 // CHECK: Namespace=InlineNS:94:18 (Definition) [type=] [typekind=Invalid] [isPOD=0] [isAnonRecDecl=0] [isInlineNamespace=1]

clang/test/SemaCXX/cxx1z-class-template-argument-deduction.cpp

 }
 
 namespace PR52139 {
   struct Abstract {
     template <class... Ts>
     struct overloaded : Ts... {
       using Ts::operator()...;
     };
     template <class... Ts>
     overloaded(Ts...) -> overloaded<Ts...>;
 
   private:
     virtual void f() = 0;
   };
 }
+
+namespace function_prototypes {
+  template<class T> using fptr1 = void (*) (T);
+  template<class T> using fptr2 = fptr1<fptr1<T>>;
+
+  template<class T> void foo0(fptr1<T>) {
+    static_assert(__is_same(T, const char*));
+  }
+  void bar0(const char *const volatile __restrict);
+  void t0() { foo0(&bar0); }
+
+  template<class T> void foo1(fptr1<const T *>) {
+     static_assert(__is_same(T, char));  
+  }
+  void bar1(const char * __restrict);
+  void t1() { foo1(&bar1); }
+
+  template<class T> void foo2(fptr2<const T *>) {
+    static_assert(__is_same(T, char));
+  }
+  void bar2(fptr1<const char * __restrict>);
+  void t2() { foo2(&bar2); }
+
+  template<class T> void foo3(fptr1<const T *>) {}
+  void bar3(char * __restrict);
+  void t3() { foo3(&bar3); }
+  // expected-error@-1 {{no matching function for call to 'foo3'}}
+  // expected-note@-4  {{candidate template ignored: cannot deduce a type for 'T' that would make 'const T' equal 'char'}}
+
+  template<class T> void foo4(fptr2<const T *>) {}
+  void bar4(fptr1<char * __restrict>);
+  void t4() { foo4(&bar4); }
+  // expected-error@-1 {{no matching function for call to 'foo4'}}
+  // expected-note@-4  {{candidate template ignored: cannot deduce a type for 'T' that would make 'const T' equal 'char'}}
+
+  template<typename T> void foo5(T(T)) {}
+  const int bar5(int);
+  void t5() { foo5(bar5); }
+  // expected-error@-1 {{no matching function for call to 'foo5'}}
+  // expected-note@-4  {{candidate template ignored: deduced conflicting types for parameter 'T' ('const int' vs. 'int')}}
+
+  struct Foo6 {};
+  template<typename T> void foo6(void(*)(struct Foo6, T)) {}
+  void bar6(Foo6, int);
+  void t6() { foo6(bar6); }
+}
 #else
 
 // expected-no-diagnostics
 namespace undefined_warnings {
   // Make sure we don't get an "undefined but used internal symbol" warning for the deduction guide here.
   namespace {
     template <typename T>
     struct TemplDObj {

clang/test/SemaCXX/cxx1z-decomposition.cpp

 // RUN: %clang_cc1 -std=c++17 -verify %s
 
 void use_from_own_init() {
   auto [a] = a; // expected-error {{binding 'a' cannot appear in the initializer of its own decomposition declaration}}
 }
 
 void num_elems() {
   struct A0 {} a0;
   int a1[1], a2[2];
 
   auto [] = a0; // expected-warning {{does not allow a decomposition group to be empty}}
-  auto [v1] = a0; // expected-error {{type 'A0' decomposes into 0 elements, but 1 name was provided}}
+  auto [v1] = a0; // expected-error {{type 'struct A0' decomposes into 0 elements, but 1 name was provided}}
   auto [] = a1; // expected-error {{type 'int[1]' decomposes into 1 element, but no names were provided}} expected-warning {{empty}}
   auto [v2] = a1;
   auto [v3, v4] = a1; // expected-error {{type 'int[1]' decomposes into 1 element, but 2 names were provided}}
   auto [] = a2; // expected-error {{type 'int[2]' decomposes into 2 elements, but no names were provided}} expected-warning {{empty}}
   auto [v5] = a2; // expected-error {{type 'int[2]' decomposes into 2 elements, but only 1 name was provided}}
   auto [v6, v7] = a2;
   auto [v8, v9, v10] = a2; // expected-error {{type 'int[2]' decomposes into 2 elements, but 3 names were provided}}
 }
void enclosing() {
   struct R { int f() { return m; } };
   (void) [&] { return m; };
   (void) [m] {}; // expected-error {{'m' in capture list does not name a variable}}
 }
 
 void bitfield() {
   struct { int a : 3, : 4, b : 5; } a;
   auto &[x, y] = a;
-  auto &[p, q, r] = a; // expected-error-re {{type '(unnamed struct at {{.*}})' decomposes into 2 elements, but 3 names were provided}}
+  auto &[p, q, r] = a; // expected-error-re {{type 'struct (unnamed struct at {{.*}})' decomposes into 2 elements, but 3 names were provided}}
 }
 
 void for_range() {
   int x = 1;
   for (auto[a, b] : x) { // expected-error {{invalid range expression of type 'int'; no viable 'begin' function available}}
     a++;
   }
 

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

namespace Constexpr {
   template<typename T> struct Y { constexpr T f() {} }; // expected-note {{control reached end of constexpr function}}
   void f() {
     X<int>().f();
     Y<void>().f();
     constexpr int q = Y<int>().f(); // expected-error {{must be initialized by a constant expression}} expected-note {{in call to '&Y<int>()->f()'}}
   }
   struct NonLiteral { ~NonLiteral(); } nl; // cxx14-note {{user-provided destructor}}
   // cxx20_2b-note@-1 {{'NonLiteral' is not literal because its destructor is not constexpr}}
-  constexpr auto f2(int n) { return nl; } // expected-error {{return type 'Constexpr::NonLiteral' is not a literal type}}
+  constexpr auto f2(int n) { return nl; } // expected-error {{return type 'struct NonLiteral' is not a literal type}}
 }
 
 // It's not really clear whether these are valid, but this matches g++.
 using size_t = decltype(sizeof(0));
 auto operator new(size_t n, const char*); // expected-error {{must return type 'void *'}}
 auto operator delete(void *, const char*); // expected-error {{must return type 'void'}}
 
 namespace Virtual {

clang/test/SemaCXX/friend.cpp

template<typename T> struct Z {
     friend T h(); // expected-error {{return type}}
   };
   Z<int> zi;
   Z<float> zf; // expected-note {{instantiation}}
 }
 
 namespace qualified_friend_no_match {
   void f(int); // expected-note {{type mismatch at 1st parameter}}
-  template<typename T> void f(T*); // expected-note {{could not match 'type-parameter-0-0 *' against 'double'}}
+  template<typename T> void f(T*); // expected-note {{could not match 'T *' against 'double'}}
   struct X {
     friend void qualified_friend_no_match::f(double); // expected-error {{friend declaration of 'f' does not match any declaration in namespace 'qualified_friend_no_match'}}
     friend void qualified_friend_no_match::g(); // expected-error {{friend declaration of 'g' does not match any declaration in namespace 'qualified_friend_no_match'}}
   };
 
   struct Y {
     void f(int); // expected-note {{type mismatch at 1st parameter}}
-    template<typename T> void f(T*); // expected-note {{could not match 'type-parameter-0-0 *' against 'double'}}
+    template<typename T> void f(T*); // expected-note {{could not match 'T *' against 'double'}}
   };
   struct Z {
     friend void Y::f(double); // expected-error {{friend declaration of 'f' does not match any declaration in 'qualified_friend_no_match::Y'}}
   };
 }

clang/test/SemaCXX/recovery-expr-type.cpp

 template <typename T = void *>
 struct S { // expected-note {{candidate}}
   S(T t);  // expected-note {{candidate}}
   ~S();
 };
 template <typename T> S(T t) -> S<void *>;
 
 void baz() {
-  bar(S(123)); // expected-error {{no matching conversion for functional-style cast from 'int' to 'test11::S<>'}}
+  bar(S(123)); // expected-error {{no matching conversion for functional-style cast from 'int' to 'S<void *>'}}
 }
 } // namespace test11
 
 namespace test12 {
 // Verify we do not crash.
 int fun(int *foo = no_such_function()); // expected-error {{undeclared identifier}}
 void crash1() { fun(); }
 void crash2() { constexpr int s = fun(); }

clang/test/SemaCXX/sizeless-1.cpp

#endif
   // implied by their name.
   _Static_assert(!__is_signed(svint8_t), "");
   _Static_assert(!__is_unsigned(svint8_t), "");
 
 #if __cplusplus >= 201103L
   auto auto_int8 = local_int8;
   auto auto_int16 = local_int16;
 #if __cplusplus >= 201703L
-  auto [auto_int8_a] = local_int8; // expected-error {{cannot decompose non-class, non-array type '__SVInt8_t'}}
+  auto [auto_int8_a] = local_int8; // expected-error {{cannot decompose non-class, non-array type 'svint8_t' (aka '__SVInt8_t')}}
 #endif
 #endif
 
   s_ptr_template<int> y;
   s_ptr_template<int> &x = y;
 
   constructible_from_sizeless cfs1(local_int8);
   constructible_from_sizeless cfs2 = local_int8;
 #if __cplusplus >= 201103L
   constructible_from_sizeless cfs3{local_int8};
 #endif
 
 #if __cplusplus >= 201103L
   local_int8 = ([]() { return svint8_t(); })();
   local_int8 = ([]() -> svint8_t { return svint8_t(); })();
   auto fn1 = [&local_int8](svint8_t x) { local_int8 = x; };
   auto fn2 = [&local_int8](svint8_t *ptr) { *ptr = local_int8; };
 #if __cplusplus >= 201703L
-  auto fn3 = [a(return_int8())] {}; // expected-error {{field has sizeless type '__SVInt8_t'}}
+  auto fn3 = [a(return_int8())] {}; // expected-error {{field has sizeless type 'svint8_t' (aka '__SVInt8_t')}}
 #endif
   auto fn4 = [local_int8](svint8_t *ptr) { *ptr = local_int8; }; // expected-error {{by-copy capture of variable 'local_int8' with sizeless type 'svint8_t'}}
 
   for (auto x : local_int8) { // expected-error {{no viable 'begin' function available}}
   }
   for (auto x : wrapper<svint8_t>()) {
     (void)x;
   }

clang/test/SemaCXX/sugared-auto.cpp

+// RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++20
+
+enum class N {};
+
+using Animal = int;
+
+using AnimalPtr = Animal *;
+
+using Man = Animal;
+using Dog = Animal;
+
+namespace variable {
+
+auto x1 = Animal();
+N t1 = x1; // expected-error {{lvalue of type 'Animal' (aka 'int')}}
+
+auto x2 = AnimalPtr();
+N t2 = x2; // expected-error {{lvalue of type 'AnimalPtr' (aka 'int *')}}
+
+auto *x3 = AnimalPtr();
+N t3 = x3; // expected-error {{lvalue of type 'Animal *' (aka 'int *')}}
+
+// Each variable deduces separately.
+auto x4 = Man(), x5 = Dog();
+N t4 = x4; // expected-error {{lvalue of type 'Man' (aka 'int')}}
+N t5 = x5; // expected-error {{lvalue of type 'Dog' (aka 'int')}}
+
+} // namespace variable
+
+namespace function_basic {
+
+auto f1() { return Animal(); }
+auto x1 = f1();
+N t1 = x1; // expected-error {{lvalue of type 'Animal' (aka 'int')}}
+
+decltype(auto) f2() { return Animal(); }
+auto x2 = f2();
+N t2 = x2; // expected-error {{lvalue of type 'Animal' (aka 'int')}}
+
+auto x3 = [a = Animal()] { return a; }();
+N t3 = x3; // expected-error {{lvalue of type 'Animal' (aka 'int')}}
+
+} // namespace function_basic

clang/test/SemaTemplate/attributes.cpp

namespace preferred_name {
   template<typename T> struct MemberTemplate {
     template<typename U> struct Iter;
     using iterator = Iter<T>;
     using const_iterator = Iter<const T>;
     template<typename U>
     struct [[clang::preferred_name(iterator),
              clang::preferred_name(const_iterator)]] Iter {};
   };
-  auto it = MemberTemplate<int>::Iter<const int>();
+  template<typename T> T desugar(T);
+  auto it = desugar(MemberTemplate<int>::Iter<const int>());
   int n = it; // expected-error {{no viable conversion from 'preferred_name::MemberTemplate<int>::const_iterator' to 'int'}}
 
   template<int A, int B, typename ...T> struct Foo;
   template<typename ...T> using Bar = Foo<1, 2, T...>;
   template<int A, int B, typename ...T> struct [[clang::preferred_name(::preferred_name::Bar<T...>)]] Foo {};
   Foo<1, 2, int, float>::nosuch x; // expected-error {{no type named 'nosuch' in 'preferred_name::Bar<int, float>'}}
 }
 ::preferred_name::Foo<1, 2, int, float>::nosuch x; // expected-error {{no type named 'nosuch' in 'preferred_name::Bar<int, float>'}}

clang/test/SemaTemplate/deduction.cpp

namespace test3 {
 
   public:
     static void madness() {
       Foo::foo<wobble<char> >();
     }
   };
 }
 
+namespace test4 {
+
+template <class> struct a { using b = const float; };
+template <class c> using d = typename a<c>::b;
+
+template <class c> void e(d<c> *, c) {}
+template void e(const float *, int);
+
+} // namespace test4
+
 // Verify that we can deduce enum-typed arguments correctly.
 namespace test14 {
   enum E { E0, E1 };
   template <E> struct A {};
   template <E e> void foo(const A<e> &a) {}
 
   void test() {
     A<E0> a;

clang/test/SemaTemplate/friend.cpp

 };
 inline void foo() {}
 inline void bar() {}
 C<int> c;
 }
 
 namespace qualified_friend {
   void f(int); // expected-note 2{{type mismatch at 1st parameter}}
-  template<typename T> void f(T*); // expected-note 2{{could not match 'type-parameter-0-0 *' against 'double'}}
+  template<typename T> void f(T*); // expected-note 2{{could not match 'T *' against 'double'}}
   template<typename T> void nondep();
 
   template<typename> struct X1 {
     friend void qualified_friend::f(double); // expected-error {{friend declaration of 'f' does not match any declaration in namespace 'qualified_friend'}}
     friend void qualified_friend::g(); // expected-error {{friend declaration of 'g' does not match any declaration in namespace 'qualified_friend'}}
   };
   template<typename T> struct X2 {
     friend void qualified_friend::f(T); // expected-error {{friend declaration of 'f' does not match any declaration in namespace 'qualified_friend'}}
   };
   X1<int> xi;
   X2<double> xd; // expected-note {{in instantiation of}}
   X2<int> x2i;
 
   struct Y {
     void f(int); // expected-note 2{{type mismatch at 1st parameter}}
-    template<typename T> void f(T*); // expected-note 2{{could not match 'type-parameter-0-0 *' against 'double'}}
+    template<typename T> void f(T*); // expected-note 2{{could not match 'T *' against 'double'}}
     template<typename T> void nondep();
   };
 
   template<typename> struct Z1 {
     friend void Y::f(double); // expected-error {{friend declaration of 'f' does not match any declaration in 'qualified_friend::Y'}}
     friend void Y::g(); // expected-error {{friend declaration of 'g' does not match any declaration in 'qualified_friend::Y'}}
   };
   template<typename T> struct Z2 {

clang/test/SemaTemplate/operator-template.cpp

 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++2a %s
 
 // Make sure we accept this
 template<class X>struct A{typedef X Y;};
-template<class X>bool operator==(A<X>,typename A<X>::Y); // expected-note{{candidate template ignored: could not match 'A<type-parameter-0-0>' against 'B<int> *'}}
+template<class X>bool operator==(A<X>,typename A<X>::Y); // expected-note{{candidate template ignored: could not match 'A<X>' against 'B<int> *'}}
 
 int a(A<int> x) { return operator==(x,1); }
 
 int a0(A<int> x) { return x == 1; }
 
 // FIXME: the location information for the note isn't very good
 template<class X>struct B{typedef X Y;};
 template<class X>bool operator==(B<X>*,typename B<X>::Y); // \

libcxx/test/std/utilities/any/any.nonmembers/any.cast/const_correctness.verify.cpp

 
 // <any>
 
 // template <class ValueType>
 // ValueType any_cast(any const &);
 
 // Try and cast away const.
 
+// This test only checks that we static_assert in any_cast when the
+// constraints are not respected, however Clang will sometimes emit
+// additional errors while trying to instantiate the rest of any_cast
+// following the static_assert. We ignore unexpected errors in
+// clang-verify to make the test more robust to changes in Clang.
+// ADDITIONAL_COMPILE_FLAGS: -Xclang -verify-ignore-unexpected=error
+
 #include <any>
 
 struct TestType {};
 struct TestType2 {};
 
 int main(int, char**)
 {
     using std::any;
     using std::any_cast;
 
     any a;
 
-    // expected-error@any:* {{drops 'const' qualifier}}
     // expected-error-re@any:* {{static_assert failed{{.*}} "ValueType is required to be a const lvalue reference or a CopyConstructible type"}}
     any_cast<TestType &>(static_cast<any const&>(a)); // expected-note {{requested here}}
 
-    // expected-error@any:* {{cannot cast from lvalue of type 'const TestType' to rvalue reference type 'TestType &&'; types are not compatible}}
     // expected-error-re@any:* {{static_assert failed{{.*}} "ValueType is required to be a const lvalue reference or a CopyConstructible type"}}
     any_cast<TestType &&>(static_cast<any const&>(a)); // expected-note {{requested here}}
 
-    // expected-error@any:* {{drops 'const' qualifier}}
     // expected-error-re@any:* {{static_assert failed{{.*}} "ValueType is required to be a const lvalue reference or a CopyConstructible type"}}
     any_cast<TestType2 &>(static_cast<any const&&>(a)); // expected-note {{requested here}}
 
-    // expected-error@any:* {{cannot cast from lvalue of type 'const TestType2' to rvalue reference type 'TestType2 &&'; types are not compatible}}
     // expected-error-re@any:* {{static_assert failed{{.*}} "ValueType is required to be a const lvalue reference or a CopyConstructible type"}}
     any_cast<TestType2 &&>(static_cast<any const&&>(a)); // expected-note {{requested here}}
 
   return 0;
 }

libcxx/test/std/utilities/any/any.nonmembers/any.cast/not_copy_constructible.verify.cpp

 // template <class ValueType>
 // ValueType any_cast(any &);
 //
 // template <class ValueType>
 // ValueType any_cast(any &&);
 
 // Test instantiating the any_cast with a non-copyable type.
 
+// This test only checks that we static_assert in any_cast when the
+// constraints are not respected, however Clang will sometimes emit
+// additional errors while trying to instantiate the rest of any_cast
+// following the static_assert. We ignore unexpected errors in
+// clang-verify to make the test more robust to changes in Clang.
+// ADDITIONAL_COMPILE_FLAGS: -Xclang -verify-ignore-unexpected=error
+
 #include <any>
 
 using std::any;
 using std::any_cast;
 
 struct no_copy
 {
     no_copy() {}
     no_copy(no_copy &&) {}
     no_copy(no_copy const &) = delete;
 };
 
 struct no_move {
   no_move() {}
   no_move(no_move&&) = delete;
   no_move(no_move const&) {}
 };
 
 int main(int, char**) {
     any a;
     // expected-error-re@any:* {{static_assert failed{{.*}} "ValueType is required to be an lvalue reference or a CopyConstructible type"}}
-    // expected-error@any:* {{static_cast from 'no_copy' to 'no_copy' uses deleted function}}
     any_cast<no_copy>(static_cast<any&>(a)); // expected-note {{requested here}}
 
     // expected-error-re@any:* {{static_assert failed{{.*}} "ValueType is required to be a const lvalue reference or a CopyConstructible type"}}
-    // expected-error@any:* {{static_cast from 'const no_copy' to 'no_copy' uses deleted function}}
     any_cast<no_copy>(static_cast<any const&>(a)); // expected-note {{requested here}}
 
     any_cast<no_copy>(static_cast<any &&>(a)); // OK
 
     // expected-error-re@any:* {{static_assert failed{{.*}} "ValueType is required to be an rvalue reference or a CopyConstructible type"}}
-    // expected-error@any:* {{static_cast from 'typename remove_reference<no_move &>::type' (aka 'no_move') to 'no_move' uses deleted function}}
     any_cast<no_move>(static_cast<any &&>(a));
 
   return 0;
 }

lldb/test/Shell/SymbolFile/NativePDB/function-types-builtins.cpp

 // CHECK: (void (*)(void *&)) az = {{.*}}
 auto aaa = &unary<int(&)[5]>;
 // CHECK: (void (*)(int (&)[5])) aaa = {{.*}}
 auto aab = &unary<int(*)[5]>;
 // CHECK: (void (*)(int (*)[5])) aab = {{.*}}
 auto aac = &unary<int(&&)[5]>;
 // CHECK: (void (*)(int (&&)[5])) aac = {{.*}}
 auto aad = &unary<int(*const)[5]>;
-// CHECK: (void (*)(int (*)[5])) aad = {{.*}}
+// CHECK: (void (*)(int (*const)[5])) aad = {{.*}}
 
 
 // same test cases with return values, note we can't overload on return type
 // so we need to use a different instantiation each time.
 auto ra = &unaryret<bool, 0>;
 // CHECK: (bool (*)()) ra = {{.*}}
 auto rb = &unaryret<char, 1>;
 // CHECK: (char (*)()) rb = {{.*}}