[clang] Instantiate concepts with sugared template arguments

[mizvekov]

Summary

Since we don't unique specializations for concepts, we can just instantiate
them with the sugared template arguments, at negligible cost.

If we don't track their specializations, we can't resugar them later
anyway, and that would be more expensive than just instantiating them
sugared in the first place since it would require an additional pass.

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

[erichkeane]

This is an improvement, thanks!

clang/lib/Sema/SemaConcept.cpp

1079

Comment here should be "RelativeToPrimary=" I think.

[mizvekov]

clang/lib/Sema/SemaConcept.cpp

1079

This is a new parameter introduced in D134604, you would have to read that dependency first to figure that out :)
I forgot to mention that on the description of this patch.

[erichkeane]

clang/lib/Sema/SemaConcept.cpp

1079

Ah!

[erichkeane]

See @aaron.ballman 's comment here: https://github.com/llvm/llvm-project/issues/59271

Since the release branch is pending, if we don't have a solution or a revert by the 13th, Aaron or I will revert this patch.

clang/lib/Sema/SemaConcept.cpp

substituteParameterMappings(Sema &S, NormalizedConstraint &N,
   return false;
 }
 
 static bool substituteParameterMappings(Sema &S, NormalizedConstraint &N,
                                         const ConceptSpecializationExpr *CSE) {
   TemplateArgumentList TAL{TemplateArgumentList::OnStack,
                            CSE->getTemplateArguments()};
   MultiLevelTemplateArgumentList MLTAL = S.getTemplateInstantiationArgs(
-      CSE->getNamedConcept(), /*Final=*/false, &TAL,
+      CSE->getNamedConcept(), /*Final=*/true, &TAL,
       /*RelativeToPrimary=*/true,
       /*Pattern=*/nullptr,
       /*ForConstraintInstantiation=*/true);
 
   return substituteParameterMappings(S, N, CSE->getNamedConcept(), MLTAL,
                                      CSE->getTemplateArgsAsWritten());
 }
 

clang/lib/Sema/SemaExprCXX.cpp

InitializationKind Kind =
                                             RParenOrBraceLoc);
 
   // C++1z [expr.type.conv]p1:
   //   If the type is a placeholder for a deduced class type, [...perform class
   //   template argument deduction...]
   // C++2b:
   //   Otherwise, if the type contains a placeholder type, it is replaced by the
   //   type determined by placeholder type deduction.
-  DeducedType *Deduced = Ty->getContainedDeducedType();
-  if (Deduced && isa<DeducedTemplateSpecializationType>(Deduced)) {
-    Ty = DeduceTemplateSpecializationFromInitializer(TInfo, Entity,
-                                                     Kind, Exprs);
+  if (const DeducedType *Deduced = Ty->getContainedDeducedType();
+      Deduced && !Deduced->isDeduced()) {
+    if (isa<DeducedTemplateSpecializationType>(Deduced)) {
+      Ty = DeduceTemplateSpecializationFromInitializer(TInfo, Entity, Kind,
+                                                       Exprs);
       if (Ty.isNull())
         return ExprError();
       Entity = InitializedEntity::InitializeTemporary(TInfo, Ty);
-  } else if (Deduced) {
+    } else {
+      assert(isa<AutoType>(Deduced));
       MultiExprArg Inits = Exprs;
       if (ListInitialization) {
         auto *ILE = cast<InitListExpr>(Exprs[0]);
         Inits = MultiExprArg(ILE->getInits(), ILE->getNumInits());
       }
 
       if (Inits.empty())
-      return ExprError(Diag(TyBeginLoc, diag::err_auto_expr_init_no_expression)
-                       << Ty << FullRange);
+        return ExprError(
+            Diag(TyBeginLoc, diag::err_auto_expr_init_no_expression)
       if (Inits.size() > 1) {
         Expr *FirstBad = Inits[1];
         return ExprError(Diag(FirstBad->getBeginLoc(),
                               diag::err_auto_expr_init_multiple_expressions)
                          << Ty << FullRange);
       }
       if (getLangOpts().CPlusPlus2b) {
         if (Ty->getAs<AutoType>())
           Diag(TyBeginLoc, diag::warn_cxx20_compat_auto_expr) << FullRange;
       }
       Expr *Deduce = Inits[0];
       if (isa<InitListExpr>(Deduce))
         return ExprError(
             Diag(Deduce->getBeginLoc(), diag::err_auto_expr_init_paren_braces)
             << ListInitialization << Ty << FullRange);
       QualType DeducedType;
       TemplateDeductionInfo Info(Deduce->getExprLoc());
       TemplateDeductionResult Result =
           DeduceAutoType(TInfo->getTypeLoc(), Deduce, DeducedType, Info);
       if (Result != TDK_Success && Result != TDK_AlreadyDiagnosed)
         return ExprError(Diag(TyBeginLoc, diag::err_auto_expr_deduction_failure)
                          << Ty << Deduce->getType() << FullRange
                          << Deduce->getSourceRange());
       if (DeducedType.isNull()) {
         assert(Result == TDK_AlreadyDiagnosed);
         return ExprError();
       }
 
       Ty = DeducedType;
       Entity = InitializedEntity::InitializeTemporary(TInfo, Ty);
     }
+  }
 
   if (Ty->isDependentType() || CallExpr::hasAnyTypeDependentArguments(Exprs)) {
     // FIXME: CXXUnresolvedConstructExpr does not model list-initialization
     // directly. We work around this by dropping the locations of the braces.
     SourceRange Locs = ListInitialization
                            ? SourceRange()
                            : SourceRange(LParenOrBraceLoc, RParenOrBraceLoc);
     return CXXUnresolvedConstructExpr::Create(Context, Ty.getNonReferenceType(),
InitializationKind Kind
                   ? InitializationKind::CreateDirectList(
                         TypeRange.getBegin(), Initializer->getBeginLoc(),
                         Initializer->getEndLoc())
                   : InitializationKind::CreateDirect(TypeRange.getBegin(),
                                                      DirectInitRange.getBegin(),
                                                      DirectInitRange.getEnd());
 
   // C++11 [dcl.spec.auto]p6. Deduce the type which 'auto' stands in for.
-  auto *Deduced = AllocType->getContainedDeducedType();
-  if (Deduced && isa<DeducedTemplateSpecializationType>(Deduced)) {
+  if (const DeducedType *Deduced = AllocType->getContainedDeducedType();
+      Deduced && !Deduced->isDeduced()) {
+    if (isa<DeducedTemplateSpecializationType>(Deduced)) {
       if (ArraySize)
         return ExprError(
             Diag(*ArraySize ? (*ArraySize)->getExprLoc() : TypeRange.getBegin(),
                  diag::err_deduced_class_template_compound_type)
             << /*array*/ 2
             << (*ArraySize ? (*ArraySize)->getSourceRange() : TypeRange));
 
-    InitializedEntity Entity
-      = InitializedEntity::InitializeNew(StartLoc, AllocType);
+      InitializedEntity Entity =
+          InitializedEntity::InitializeNew(StartLoc, AllocType);
       AllocType = DeduceTemplateSpecializationFromInitializer(
           AllocTypeInfo, Entity, Kind, Exprs);
       if (AllocType.isNull())
         return ExprError();
-  } else if (Deduced) {
+    } else {
+      assert(isa<AutoType>(Deduced));
       MultiExprArg Inits = Exprs;
       bool Braced = (initStyle == CXXNewExpr::ListInit);
       if (Braced) {
         auto *ILE = cast<InitListExpr>(Exprs[0]);
         Inits = MultiExprArg(ILE->getInits(), ILE->getNumInits());
       }
 
       if (initStyle == CXXNewExpr::NoInit || Inits.empty())
         return ExprError(Diag(StartLoc, diag::err_auto_new_requires_ctor_arg)
                          << AllocType << TypeRange);
       if (Inits.size() > 1) {
         Expr *FirstBad = Inits[1];
         return ExprError(Diag(FirstBad->getBeginLoc(),
                               diag::err_auto_new_ctor_multiple_expressions)
                          << AllocType << TypeRange);
       }
       if (Braced && !getLangOpts().CPlusPlus17)
         Diag(Initializer->getBeginLoc(), diag::ext_auto_new_list_init)
             << AllocType << TypeRange;
       Expr *Deduce = Inits[0];
       if (isa<InitListExpr>(Deduce))
         return ExprError(
             Diag(Deduce->getBeginLoc(), diag::err_auto_expr_init_paren_braces)
             << Braced << AllocType << TypeRange);
       QualType DeducedType;
       TemplateDeductionInfo Info(Deduce->getExprLoc());
-    TemplateDeductionResult Result =
-        DeduceAutoType(AllocTypeInfo->getTypeLoc(), Deduce, DeducedType, Info);
+      TemplateDeductionResult Result = DeduceAutoType(
+          AllocTypeInfo->getTypeLoc(), Deduce, DeducedType, Info);
       if (Result != TDK_Success && Result != TDK_AlreadyDiagnosed)
         return ExprError(Diag(StartLoc, diag::err_auto_new_deduction_failure)
                          << AllocType << Deduce->getType() << TypeRange
                          << Deduce->getSourceRange());
       if (DeducedType.isNull()) {
         assert(Result == TDK_AlreadyDiagnosed);
         return ExprError();
       }
       AllocType = DeducedType;
     }
+  }
 
   // Per C++0x [expr.new]p5, the type being constructed may be a
   // typedef of an array type.
   if (!ArraySize) {
     if (const ConstantArrayType *Array
                               = Context.getAsConstantArrayType(AllocType)) {
       ArraySize = IntegerLiteral::Create(Context, Array->getSize(),
                                          Context.getSizeType(),
Sema::BuildExprRequirement(
   else if (ReturnTypeRequirement.isSubstitutionFailure())
     Status = concepts::ExprRequirement::SS_TypeRequirementSubstitutionFailure;
   else if (ReturnTypeRequirement.isTypeConstraint()) {
     // C++2a [expr.prim.req]p1.3.3
     //     The immediately-declared constraint ([temp]) of decltype((E)) shall
     //     be satisfied.
     TemplateParameterList *TPL =
         ReturnTypeRequirement.getTypeConstraintTemplateParameterList();
-    QualType MatchedType =
-        Context.getReferenceQualifiedType(E).getCanonicalType();
+    QualType MatchedType = Context.getReferenceQualifiedType(E);
     llvm::SmallVector<TemplateArgument, 1> Args;
     Args.push_back(TemplateArgument(MatchedType));
 
     auto *Param = cast<TemplateTypeParmDecl>(TPL->getParam(0));
 
     TemplateArgumentList TAL(TemplateArgumentList::OnStack, Args);
     MultiLevelTemplateArgumentList MLTAL(Param, TAL.asArray(),
-                                         /*Final=*/false);
+                                         /*Final=*/true);
     MLTAL.addOuterRetainedLevels(TPL->getDepth());
     Expr *IDC = Param->getTypeConstraint()->getImmediatelyDeclaredConstraint();
     ExprResult Constraint = SubstExpr(IDC, MLTAL);
     if (Constraint.isInvalid()) {
       Status = concepts::ExprRequirement::SS_ExprSubstitutionFailure;
     } else {
       SubstitutedConstraintExpr =
           cast<ConceptSpecializationExpr>(Constraint.get());

clang/lib/Sema/SemaTemplate.cpp

if (CheckTemplateArgumentList(
           const_cast<TemplateArgumentListInfo &>(*TemplateArgs),
           /*PartialTemplateArgs=*/false, SugaredConverted, CanonicalConverted,
           /*UpdateArgsWithConversions=*/false))
     return ExprError();
 
   ConstraintSatisfaction Satisfaction;
   bool AreArgsDependent =
       TemplateSpecializationType::anyDependentTemplateArguments(
-          *TemplateArgs, CanonicalConverted);
-  MultiLevelTemplateArgumentList MLTAL(NamedConcept, CanonicalConverted,
-                                       /*Final=*/false);
+          *TemplateArgs, SugaredConverted);
+  MultiLevelTemplateArgumentList MLTAL(NamedConcept, SugaredConverted,
+                                       /*Final=*/true);
   LocalInstantiationScope Scope(*this);
   if (!AreArgsDependent &&
       CheckConstraintSatisfaction(
           NamedConcept, {NamedConcept->getConstraintExpr()}, MLTAL,
           SourceRange(SS.isSet() ? SS.getBeginLoc() : ConceptNameInfo.getLoc(),
                       TemplateArgs->getRAngleLoc()),
           Satisfaction))
     return ExprError();
 
   return ConceptSpecializationExpr::Create(
       Context,
       SS.isSet() ? SS.getWithLocInContext(Context) : NestedNameSpecifierLoc{},
       TemplateKWLoc, ConceptNameInfo, FoundDecl, NamedConcept,
       ASTTemplateArgumentListInfo::Create(Context, *TemplateArgs),
-      CanonicalConverted, AreArgsDependent ? nullptr : &Satisfaction);
+      SugaredConverted, AreArgsDependent ? nullptr : &Satisfaction);
 }
 
 ExprResult Sema::BuildTemplateIdExpr(const CXXScopeSpec &SS,
                                      SourceLocation TemplateKWLoc,
                                      LookupResult &R,
                                      bool RequiresADL,
                                  const TemplateArgumentListInfo *TemplateArgs) {
   // FIXME: Can we do any checking at this point? I guess we could check the
bool Sema::CheckTemplateArgumentList(
 
   // No problems found with the new argument list, propagate changes back
   // to caller.
   if (UpdateArgsWithConversions)
     TemplateArgs = std::move(NewArgs);
 
   if (!PartialTemplateArgs) {
     TemplateArgumentList StackTemplateArgs(TemplateArgumentList::OnStack,
-                                           CanonicalConverted);
+                                           SugaredConverted);
     // Setup the context/ThisScope for the case where we are needing to
     // re-instantiate constraints outside of normal instantiation.
     DeclContext *NewContext = Template->getDeclContext();
 
     // If this template is in a template, make sure we extract the templated
     // decl.
     if (auto *TD = dyn_cast<TemplateDecl>(NewContext))
       NewContext = Decl::castToDeclContext(TD->getTemplatedDecl());
     auto *RD = dyn_cast<CXXRecordDecl>(NewContext);
 
     Qualifiers ThisQuals;
     if (const auto *Method =
             dyn_cast_or_null<CXXMethodDecl>(Template->getTemplatedDecl()))
       ThisQuals = Method->getMethodQualifiers();
 
     ContextRAII Context(*this, NewContext);
     CXXThisScopeRAII(*this, RD, ThisQuals, RD != nullptr);
 
     MultiLevelTemplateArgumentList MLTAL = getTemplateInstantiationArgs(
-        Template, /*Final=*/false, &StackTemplateArgs,
+        Template, /*Final=*/true, &StackTemplateArgs,
         /*RelativeToPrimary=*/true,
         /*Pattern=*/nullptr,
         /*ForConceptInstantiation=*/true);
     if (EnsureTemplateArgumentListConstraints(
             Template, MLTAL,
             SourceRange(TemplateLoc, TemplateArgs.getRAngleLoc()))) {
       if (ConstraintsNotSatisfied)
         *ConstraintsNotSatisfied = true;

clang/lib/Sema/SemaTemplateDeduction.cpp

CheckDeducedArgumentConstraints(Sema &S, TemplateDeclT *Template,
                                 ArrayRef<TemplateArgument> SugaredDeducedArgs,
                                 ArrayRef<TemplateArgument> CanonicalDeducedArgs,
                                 TemplateDeductionInfo &Info) {
   llvm::SmallVector<const Expr *, 3> AssociatedConstraints;
   Template->getAssociatedConstraints(AssociatedConstraints);
 
   bool NeedsReplacement = DeducedArgsNeedReplacement(Template);
   TemplateArgumentList DeducedTAL{TemplateArgumentList::OnStack,
-                                  CanonicalDeducedArgs};
+                                  SugaredDeducedArgs};
 
   MultiLevelTemplateArgumentList MLTAL = S.getTemplateInstantiationArgs(
-      Template, /*Final=*/false,
+      Template, /*Final=*/true,
       /*InnerMost=*/NeedsReplacement ? nullptr : &DeducedTAL,
       /*RelativeToPrimary=*/true, /*Pattern=*/
       nullptr, /*ForConstraintInstantiation=*/true);
 
   // getTemplateInstantiationArgs picks up the non-deduced version of the
   // template args when this is a variable template partial specialization and
   // not class-scope explicit specialization, so replace with Deduced Args
   // instead of adding to inner-most.
   if (NeedsReplacement)
-    MLTAL.replaceInnermostTemplateArguments(CanonicalDeducedArgs);
+    MLTAL.replaceInnermostTemplateArguments(SugaredDeducedArgs);
 
   if (S.CheckConstraintSatisfaction(Template, AssociatedConstraints, MLTAL,
                                     Info.getLocation(),
                                     Info.AssociatedConstraintsSatisfaction) ||
       !Info.AssociatedConstraintsSatisfaction.IsSatisfied) {
     Info.reset(
         TemplateArgumentList::CreateCopy(S.Context, SugaredDeducedArgs),
         TemplateArgumentList::CreateCopy(S.Context, CanonicalDeducedArgs));
static bool CheckDeducedPlaceholderConstraints(Sema &S, const AutoType &Type,
   for (unsigned I = 0, C = TypeLoc.getNumArgs(); I != C; ++I)
     TemplateArgs.addArgument(TypeLoc.getArgLoc(I));
 
   llvm::SmallVector<TemplateArgument, 4> SugaredConverted, CanonicalConverted;
   if (S.CheckTemplateArgumentList(Concept, SourceLocation(), TemplateArgs,
                                   /*PartialTemplateArgs=*/false,
                                   SugaredConverted, CanonicalConverted))
     return true;
-  MultiLevelTemplateArgumentList MLTAL(Concept, CanonicalConverted,
-                                       /*Final=*/false);
+  MultiLevelTemplateArgumentList MLTAL(Concept, SugaredConverted,
+                                       /*Final=*/true);
   if (S.CheckConstraintSatisfaction(Concept, {Concept->getConstraintExpr()},
                                     MLTAL, TypeLoc.getLocalSourceRange(),
                                     Satisfaction))
     return true;
   if (!Satisfaction.IsSatisfied) {
     std::string Buf;
     llvm::raw_string_ostream OS(Buf);
     OS << "'" << Concept->getName();

clang/test/CXX/expr/expr.prim/expr.prim.req/compound-requirement.cpp

 template<typename T> requires requires (T a) { { a.foo() }; } // expected-note{{because 'a.foo()' would be invalid: no member named 'foo' in 'A'}} expected-note{{because 'a.foo()' would be invalid: member reference base type 'int' is not a structure or union}} expected-note{{because 'a.foo()' would be invalid: 'this' argument to member function 'foo' has type 'const D', but function is not marked const}}
 struct r2 {};
 
 using r2i1 = r2<int>; // expected-error{{constraints not satisfied for class template 'r2' [with T = int]}}
 using r2i2 = r2<A>; // expected-error{{constraints not satisfied for class template 'r2' [with T = A]}}
 using r2i3 = r2<D>;
 using r2i4 = r2<const D>; // expected-error{{constraints not satisfied for class template 'r2' [with T = const D]}}
 
-template<typename T> requires requires { { sizeof(T) }; } // expected-note{{because 'sizeof(T)' would be invalid: invalid application of 'sizeof' to an incomplete type 'void'}} expected-note{{because 'sizeof(T)' would be invalid: invalid application of 'sizeof' to an incomplete type 'nonexistent'}}
+template<typename T> requires requires { { sizeof(T) }; } // expected-note{{because 'sizeof(T)' would be invalid: invalid application of 'sizeof' to an incomplete type 'void'}} expected-note{{because 'sizeof(T)' would be invalid: invalid application of 'sizeof' to an incomplete type 'class nonexistent'}}
 struct r3 {};
 
 using r3i1 = r3<int>;
 using r3i2 = r3<A>;
 using r3i3 = r3<A &>;
 using r3i4 = r3<void>; // expected-error{{constraints not satisfied for class template 'r3' [with T = void]}}
-using r3i4 = r3<class nonexistent>; // expected-error{{constraints not satisfied for class template 'r3' [with T = nonexistent]}}
+using r3i4 = r3<class nonexistent>; // expected-error{{constraints not satisfied for class template 'r3' [with T = class nonexistent]}}
 
 // Non-dependent expressions
 
 template<typename T> requires requires (T t) { { 0 }; { "a" }; { (void)'a' }; }
 struct r4 {};
 
 using r4i1 = r4<int>;
 using r4i2 = r4<int[10]>;
template<typename T> concept C1 =
     requires(T x) {
       {x++};
     };
 
   template<typename T, typename U> constexpr bool is_same_v = false;
   template<typename T> constexpr bool is_same_v<T, T> = true;
 
   template<typename T, typename U> concept same_as = is_same_v<T, U>;
-  // expected-note@-1 {{because 'is_same_v<int, int *>' evaluated to false}}
+  // expected-note@-1 {{because 'is_same_v<int, typename T2::inner>' evaluated to false}}
 
   static_assert(C1<int>);
   static_assert(C1<int*>);
   template<C1 T> struct C1_check {};
   using c1c1 = C1_check<int>;
   using c1c2 = C1_check<int[10]>;
 
   template<typename T> concept C2 =
     requires(T x) {
       {*x} -> same_as<typename T::inner>;
       // expected-note@-1{{because type constraint 'same_as<int, typename T2::inner>' was not satisfied:}}
       // expected-note@-2{{because '*x' would be invalid: indirection requires pointer operand ('int' invalid)}}
     };
 
   struct T1 {
     using inner = int;
     inner operator *() { return 0; }
   };
   struct T2 {
     using inner = int *;
     int operator *() { return 0; }
   };
   static_assert(C2<T1>);
-  template<C2 T> struct C2_check {}; // expected-note{{because 'int' does not satisfy 'C2'}} expected-note{{because 'std_example::T2' does not satisfy 'C2'}}
+  template<C2 T> struct C2_check {}; // expected-note{{because 'int' does not satisfy 'C2'}} expected-note{{because 'T2' does not satisfy 'C2'}}
   using c2c1 = C2_check<int>; // expected-error{{constraints not satisfied for class template 'C2_check' [with T = int]}}
-  using c2c2 = C2_check<T2>; // expected-error{{constraints not satisfied for class template 'C2_check' [with T = std_example::T2]}}
+  using c2c2 = C2_check<T2>; // expected-error{{constraints not satisfied for class template 'C2_check' [with T = T2]}}
 
   template<typename T>
   void g(T t) noexcept(sizeof(T) == 1) {}
 
   template<typename T> concept C5 =
     requires(T x) {
       {g(x)} noexcept; // expected-note{{because 'g(x)' may throw an exception}}
     };
 
   static_assert(C5<char>);
   template<C5 T> struct C5_check {}; // expected-note{{because 'short' does not satisfy 'C5'}}
   using c5 = C5_check<short>; // expected-error{{constraints not satisfied for class template 'C5_check' [with T = short]}}
 }

clang/test/CXX/expr/expr.prim/expr.prim.req/nested-requirement.cpp

struct X {
     template<typename U> requires requires (U u) { requires sizeof(u) == sizeof(T); } // expected-note{{because 'sizeof (u) == sizeof(T)' would be invalid: invalid application of 'sizeof' to an incomplete type 'void'}}
     struct r4 {};
 };
 
 using r4i = X<void>::r4<int>; // expected-error{{constraints not satisfied for class template 'r4' [with U = int]}}
 
 // C++ [expr.prim.req.nested] Examples
 namespace std_example {
-  template<typename U> concept C1 = sizeof(U) == 1; // expected-note{{because 'sizeof(int) == 1' (4 == 1) evaluated to false}}
+  template<typename U> concept C1 = sizeof(U) == 1; // expected-note{{because 'sizeof(decltype(+t)) == 1' (4 == 1) evaluated to false}}
   template<typename T> concept D =
     requires (T t) {
       requires C1<decltype (+t)>; // expected-note{{because 'decltype(+t)' (aka 'int') does not satisfy 'C1'}}
   };
 
   struct T1 { char operator+() { return 'a'; } };
   static_assert(D<T1>);
   template<D T> struct D_check {}; // expected-note{{because 'short' does not satisfy 'D'}}

clang/test/CXX/expr/expr.prim/expr.prim.req/simple-requirement.cpp

 
 using r2i1 = r2<int>; // expected-error{{constraints not satisfied for class template 'r2' [with T = int]}}
 using r2i2 = r2<A>; // expected-error{{constraints not satisfied for class template 'r2' [with T = A]}}
 using r2i3 = r2<D>;
 using r2i4 = r2<const D>; // expected-error{{constraints not satisfied for class template 'r2' [with T = const D]}}
 
 template<typename T> requires requires { sizeof(T); }
 // expected-note@-1{{because 'sizeof(T)' would be invalid: invalid application of 'sizeof' to an incomplete type 'void'}}
-// expected-note@-2{{because 'sizeof(T)' would be invalid: invalid application of 'sizeof' to an incomplete type 'nonexistent'}}
+// expected-note@-2{{because 'sizeof(T)' would be invalid: invalid application of 'sizeof' to an incomplete type 'class nonexistent'}}
 struct r3 {};
 
 using r3i1 = r3<int>;
 using r3i2 = r3<A>;
 using r3i3 = r3<A &>;
 using r3i4 = r3<void>; // expected-error{{constraints not satisfied for class template 'r3' [with T = void]}}
-using r3i4 = r3<class nonexistent>; // expected-error{{constraints not satisfied for class template 'r3' [with T = nonexistent]}}
+using r3i4 = r3<class nonexistent>; // expected-error{{constraints not satisfied for class template 'r3' [with T = class nonexistent]}}
 
 template<typename T> requires requires (T t) { 0; "a"; (void)'a'; }
 struct r4 {};
 
 using r4i1 = r4<int>;
 using r4i2 = r4<int[10]>;
 using r4i3 = r4<int(int)>;
 

clang/test/CXX/expr/expr.prim/expr.prim.req/type-requirement.cpp

namespace std_example {
 
   struct has_inner { using inner = int;};
   struct has_type { using type = int; };
   struct has_inner_and_type { using inner = int; using type = int; };
 
   static_assert(C1<has_inner_and_type> && C2<has_inner_and_type> && C3<has_inner_and_type>);
   template<C1 T> struct C1_check {};
   // expected-note@-1 {{because 'int' does not satisfy 'C1'}}
-  // expected-note@-2 {{because 'std_example::has_type' does not satisfy 'C1'}}
+  // expected-note@-2 {{because 'has_type' does not satisfy 'C1'}}
   template<C2 T> struct C2_check {};
-  // expected-note@-1 {{because 'std_example::has_inner' does not satisfy 'C2'}}
+  // expected-note@-1 {{because 'has_inner' does not satisfy 'C2'}}
   template<C3 T> struct C3_check {};
   // expected-note@-1 {{because 'void' does not satisfy 'C3'}}
   using c1 = C1_check<int>; // expected-error{{constraints not satisfied for class template 'C1_check' [with T = int]}}
-  using c2 = C1_check<has_type>; // expected-error{{constraints not satisfied for class template 'C1_check' [with T = std_example::has_type]}}
-  using c3 = C2_check<has_inner>; // expected-error{{constraints not satisfied for class template 'C2_check' [with T = std_example::has_inner]}}
+  using c2 = C1_check<has_type>; // expected-error{{constraints not satisfied for class template 'C1_check' [with T = has_type]}}
+  using c3 = C2_check<has_inner>; // expected-error{{constraints not satisfied for class template 'C2_check' [with T = has_inner]}}
   using c4 = C3_check<void>; // expected-error{{constraints not satisfied for class template 'C3_check' [with T = void]}}
 }
 
 namespace PR48656 {
 
 template <typename T> concept C = requires { requires requires { T::a; }; };
 // expected-note@-1 {{because 'T::a' would be invalid: no member named 'a' in 'PR48656::T1'}}
 
 template <C...> struct A {};
-// expected-note@-1 {{because 'PR48656::T1' does not satisfy 'C'}}
+// expected-note@-1 {{because 'T1' does not satisfy 'C'}}
 
 struct T1 {};
-template struct A<T1>; // expected-error {{constraints not satisfied for class template 'A' [with $0 = <PR48656::T1>]}}
+template struct A<T1>; // expected-error {{constraints not satisfied for class template 'A' [with $0 = <T1>]}}
 
 struct T2 { static constexpr bool a = false; };
 template struct A<T2>;
 
 template <typename T> struct T3 {
   static void m(auto) requires requires { T::fail; } {}
   // expected-note@-1 {{constraints not satisfied}}
   // expected-note@-2 {{type 'int' cannot be used prior to '::'}}
 };
 template <typename... Args> void t3(Args... args) { (..., T3<int>::m(args)); }
 // expected-error@-1 {{no matching function for call to 'm'}}
 
 template void t3<int>(int); // expected-note {{requested here}}
 
 } // namespace PR48656

clang/test/CXX/temp/temp.constr/temp.constr.normal/p1.cpp

 // RUN: %clang_cc1 -std=c++2a -x c++ -verify %s
 
 template<typename T> concept True = true;
 template<typename T> concept Foo = True<T*>;
 template<typename T> concept Bar = Foo<T&>;
 template<typename T> requires Bar<T> struct S { };
 template<typename T> requires Bar<T> && true struct S<T> { };
 
 template<typename T> concept True2 = sizeof(T) >= 0;
 template<typename T> concept Foo2 = True2<T*>;
-// expected-error@-1{{'type name' declared as a pointer to a reference of type 'type-parameter-0-0 &'}}
+// expected-error@-1{{'type name' declared as a pointer to a reference of type 'T &'}}
 template<typename T> concept Bar2 = Foo2<T&>;
 // expected-note@-1{{while substituting into concept arguments here; substitution failures not allowed in concept arguments}}
 template<typename T> requires Bar2<T> struct S2 { };
 // expected-note@-1{{template is declared here}}
 template<typename T> requires Bar2<T> && true struct S2<T> { };
 // expected-error@-1{{class template partial specialization is not more specialized than the primary template}}
 // expected-note@-2{{while calculating associated constraint of template 'S2' here}}
 

clang/test/CXX/temp/temp.param/p10-2a.cpp

 concept OneOf = (is_same_v<T, Ts> || ...);
 // expected-note@-1 2{{because 'is_same_v<char, char[1]>' evaluated to false}}
 // expected-note@-2 2{{and 'is_same_v<char, char[2]>' evaluated to false}}
 // expected-note@-3 {{because 'is_same_v<short, int>' evaluated to false}}
 // expected-note@-4 {{and 'is_same_v<short, long>' evaluated to false}}
 // expected-note@-5 {{and 'is_same_v<short, char>' evaluated to false}}
 // expected-note@-6 3{{because 'is_same_v<int, char[1]>' evaluated to false}}
 // expected-note@-7 3{{and 'is_same_v<int, char[2]>' evaluated to false}}
-// expected-note@-8 2{{because 'is_same_v<std::nullptr_t, char>' evaluated to false}}
-// expected-note@-9 2{{and 'is_same_v<std::nullptr_t, int>' evaluated to false}}
+// expected-note@-8 2{{because 'is_same_v<decltype(nullptr), char>' evaluated to false}}
+// expected-note@-9 2{{and 'is_same_v<decltype(nullptr), int>' evaluated to false}}
 
 template<OneOf<char[1], char[2]> T, OneOf<int, long, char> U>
 // expected-note@-1 2{{because 'OneOf<char, char[1], char[2]>' evaluated to false}}
 // expected-note@-2 {{because 'OneOf<short, int, long, char>' evaluated to false}}
 using G = T;
 
 using g1 = G<char[1], int>;
 using g2 = G<char, int>; // expected-error{{constraints not satisfied for alias template 'G' [with T = char, U = int]}}

clang/test/SemaTemplate/cxx2a-constraint-caching.cpp

 // RUN:  %clang_cc1 -std=c++2a -verify %s
 // expected-no-diagnostics
 
 template<typename T>
 concept C = (f(T()), true);
 
 template<typename T>
 constexpr bool foo() { return false; }
 
 template<typename T>
   requires (f(T()), true)
 constexpr bool foo() requires (f(T()), true) { return true; }
 
 namespace a {
   struct A {};
   constexpr void f(A a) {}
-}
 
-static_assert(C<a::A>);
-static_assert(foo<a::A>());
+  static_assert(C<A>);
+  static_assert(foo<A>());
 
-namespace a {
   // This makes calls to f ambiguous, but the second check will still succeed
   // because the constraint satisfaction results are cached.
   constexpr void f(A a, int = 2) {}
-}
-static_assert(C<a::A>);
-static_assert(foo<a::A>());
+  static_assert(C<A>);
+  static_assert(foo<A>());
+} // namespace a

clang/test/SemaTemplate/instantiate-requires-expr.cpp

namespace type_requirement {
   };
 
   template<typename T> requires
   false_v<requires { typename T::template temp<T>; }>
   // expected-note@-1 {{because 'false_v<requires { typename contains_template<int>::temp<contains_template<int> >; }>' evaluated to false}}
   // expected-note@-2 {{because 'false_v<requires { typename contains_template<short>::temp<contains_template<short> >; }>' evaluated to false}}
   struct r2 {};
 
-  using r2i1 = r2<contains_template<int>>; // expected-error{{constraints not satisfied for class template 'r2' [with T = type_requirement::contains_template<int>]}}
-  using r2i2 = r2<contains_template<short>>; // expected-error{{constraints not satisfied for class template 'r2' [with T = type_requirement::contains_template<short>]}}
+  using r2i1 = r2<contains_template<int>>; // expected-error{{constraints not satisfied for class template 'r2' [with T = contains_template<int>]}}
+  using r2i2 = r2<contains_template<short>>; // expected-error{{constraints not satisfied for class template 'r2' [with T = contains_template<short>]}}
 
   // substitution error occurs, then requires expr is instantiated again
 
   template<typename T>
   struct a {
       template<typename U> requires (requires { typename T::a::a; }, false)
       // expected-note@-1{{because 'requires { <<error-type>>; } , false' evaluated to false}}
       struct r {};
namespace type_requirement {
 
   using r6i = r6<int, short>; // expected-error{{constraints not satisfied for class template 'r6' [with Ts = <int, short>]}}
 
   template<typename... Ts> requires
   false_v<(requires { typename Ts::template aaa<Ts>; } && ...)>
   // expected-note@-1 {{because 'false_v<requires { <<error-type>>; } && requires { <<error-type>>; }>' evaluated to false}}
   struct r7 {};
 
-  using r7i = r7<int, A>; // expected-error{{constraints not satisfied for class template 'r7' [with Ts = <int, type_requirement::A>]}}
+  using r7i = r7<int, A>; // expected-error{{constraints not satisfied for class template 'r7' [with Ts = <int, A>]}}
 }
 
 namespace expr_requirement {
   // check that compound/simple requirements are instantiated correctly.
 
   template<typename T> requires false_v<requires { sizeof(T); { sizeof(T) }; }>
   // expected-note@-1 {{because 'false_v<requires { sizeof(int); { sizeof(int) }; }>' evaluated to false}}
   // expected-note@-2 {{because 'false_v<requires { <<error-expression>>; { sizeof(T) }; }>' evaluated to false}}

 
 template<typename T> requires
 false_v<(requires(T t) { T{t}; })> // T{t} creates an "UnevaluatedList" context.
 // expected-note@-1 {{because 'false_v<(requires (int t) { int{t}; })>' evaluated to false}}
 struct r6 {};
 
 using r6i = r6<int>;
 // expected-error@-1 {{constraints not satisfied for class template 'r6' [with T = int]}}
+
+namespace sugared_instantiation {
+  template <class C1> concept C = requires { C1{}; };
+  template <class D1> concept D = requires { new D1; };
+
+  // Test that 'deduced auto' doesn't get confused with 'undeduced auto'.
+  auto f() { return 0; }
+  static_assert(requires { { f() } -> C; });
+  static_assert(requires { { f() } -> D; });
+} // namespace sugared_instantiation

clang/test/SemaTemplate/pr52970.cpp

 constexpr bool f(...) { return false; }
 
 static_assert(DotFollowingPointer::f(Good{}), "");
 static_assert(!DotFollowingPointer::f(Bad{}), "");
 
 #if __cplusplus >= 202002L
 template <class T>
 concept C = requires(T t) { t.begin(); };
-  // cxx20-note@-1 {{because 't.begin()' would be invalid: member reference type 'Holder<Incomplete> *' is a pointer}}
+  // cxx20-note@-1 {{because 't.begin()' would be invalid: member reference type 'Bad' (aka 'Holder<Incomplete> *') is a pointer}}
 
 static_assert(C<Good>);
 static_assert(!C<Bad>);
 static_assert(C<Bad>); // cxx20-error {{static assertion failed}}
   // cxx20-note@-1 {{because 'Bad' (aka 'Holder<Incomplete> *') does not satisfy 'C'}}
 #endif
 } // namespace DotFollowingPointer